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

// 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.

//

// Description:

// Render Orientation Tracking and Publication

// 

#include <hal.h>

#include <e32std.h>

#include "renderorientationtracker.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "wstop.h"

#include "..\debuglog\DEBUGLOG.H"

extern CDebugLogBase* wsDebugLog;

/** Convert a TRenderOrientation value into a TDigitiserOrientation.

Note: The algorithm used makes use of the ordering of the values of the respective enums, 

thus this is checked for (at compile time) at the start of the function.

@param aWservOrientation A value from the TRenderOrientation enums.

@return The equivalent value from the TDigitiserOrientation enums.

*/

inline HALData::TDigitiserOrientation WservToDigitiser(TRenderOrientation aWservOrientation)

	{

	__ASSERT_COMPILE(EDisplayOrientationNormal+1 == EDisplayOrientation90CW);

	__ASSERT_COMPILE(EDisplayOrientationNormal+2 == EDisplayOrientation180);

	__ASSERT_COMPILE(EDisplayOrientationNormal+3 == EDisplayOrientation270CW);

	__ASSERT_COMPILE(HALData::EDigitiserOrientation_000+1 == HALData::EDigitiserOrientation_090);

	__ASSERT_COMPILE(HALData::EDigitiserOrientation_000+2 == HALData::EDigitiserOrientation_180);

	__ASSERT_COMPILE(HALData::EDigitiserOrientation_000+3 == HALData::EDigitiserOrientation_270);

	HALData::TDigitiserOrientation ret=static_cast<HALData::TDigitiserOrientation>

			(HALData::EDigitiserOrientation_000 + (aWservOrientation - EDisplayOrientationNormal));

	return ret;

	}

// Todo remove/undefine this for release

#define TECHVIEW_TESTMODE

CWsRenderOrienationTracker* CWsRenderOrienationTracker::NewL()

    {

    CWsRenderOrienationTracker* self = new(ELeave)CWsRenderOrienationTracker();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CWsRenderOrienationTracker::CWsRenderOrienationTracker()

    : CActive(CActive::EPriorityStandard),

      iRenderOrientationTrackingType(EDisplayOrientationNormal),

      iPublishedRenderOrientation(EDisplayOrientationNormal)

    {

    CActiveScheduler::Add(this);    

    }

void CWsRenderOrienationTracker::ConstructL()

    {    

    const TSecurityPolicy   KRenderOrientationReadSecurityPolicy(ECapability_None);

    const TSecurityPolicy   KRenderOrientationWriteSecurityPolicy(ECapabilityWriteDeviceData);

    // Define P&S Property to publish to

    TInt error = RProperty::Define( KRenderOrientationCategory,

                                    KRenderOrientationKey,

                                    RProperty::EInt,

                                    KRenderOrientationReadSecurityPolicy,

                                    KRenderOrientationWriteSecurityPolicy);

    // Attach the publisher for real-time publishing

    if(KErrNone == error)

        error = iRenderOrientationPublisher.Attach( KRenderOrientationCategory,

                                                    KRenderOrientationKey);

    // Publish the initial value

    if(KErrNone == error)    

        error = DoPublishOrientation(EDisplayOrientationNormal);

    //Set the initial value to HAL

    if(KErrNone == error)

        SetHALOrientation(EDisplayOrientationNormal);

    if (wsDebugLog && KErrNone!=error)

        {

        _LIT(logText,"Orientation Tracker: failed to initialise with error %d");

        wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,logText,error);

        }    

    User::LeaveIfError(error);

    }

CWsRenderOrienationTracker::~CWsRenderOrienationTracker()

    {

    Cancel();

    iRenderOrientationPublisher.Delete(KRenderOrientationCategory, KRenderOrientationKey);

    iRenderOrientationPublisher.Close();

    }

/**

If the orientation of the given window group is useable updates aOrientationTrackingType with the orientation

@param Input: the window group to check

@param Output: the window group's orientation if usable ( otherwise unchanged )

@return KErrNone if the orienation is usable, KErrNotFound if the orientation is not useable, KErrNotSupported if the orientation is unknown

*/

TInt CWsRenderOrienationTracker::CheckWindowGroupOrientation(const CWsWindowGroup& aWinGroup, TRenderOrientationTrackingType& aOrientationTrackingType)

    {

    TInt error = KErrNone;

    TRenderOrientationTrackingType tempOrientationTrackingType = static_cast<TRenderOrientationTrackingType>(aWinGroup.WsOwner()->GetIndicatedAppOrientation());

    switch(tempOrientationTrackingType)

        {

        case EDisplayOrientationNormal:

        case EDisplayOrientation90CW:                

        case EDisplayOrientation180:

        case EDisplayOrientation270CW:            

        case EDisplayOrientationAuto:

            aOrientationTrackingType = tempOrientationTrackingType;

            break;

        case EDisplayOrientationIgnore:

            error = KErrNotFound;

            if (wsDebugLog)

                {

                _LIT(logText,"Orientation Tracker: winGroup %08x orientation is set to be ignored");

                wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,logText,reinterpret_cast<TInt>(&aWinGroup));

                }            

            break;

        default:

            error = KErrNotSupported;

            if (wsDebugLog)

                {

                _LIT(logText,"Orientation Tracker: winGroup %08x has undefined orientation, Error %d");                

                TBuf<LogTBufSize> buf;

                buf.Format(logText, &aWinGroup, error);                

                wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,buf);

                }                          

            break;             

        }

    return error;

    }

/**

Checks that the given group window is appropriate for dictating the render orientation

@param Input:  The group window to check

@return ETrue is the group window is usable, else EFalse  

*/

TBool CWsRenderOrienationTracker::UseableGroupWindow(const CWsWindowGroup& aWinGroup) const

    {

#ifdef TECHVIEW_TESTMODE

    // for some reason IsFocusable seems to return 0 and 2, not 0 and 1

    return NULL!=aWinGroup.Child() &&

            (aWinGroup.IsFocusable() ? ETrue : EFalse);

#else    

    return (NULL!=aWinGroup.Child());     

#endif

    }

/**

Finds the topmost usable windowgroup which has a usable orientation, and outputs that orientation

@param Output: The current render orientation

@return KErrNone if successful, KErrNotFound if the focus window group is not usable, KErrNotSupported if an invalid orientation is found

*/

TInt CWsRenderOrienationTracker::GetFocusWindowOrientation(TRenderOrientationTrackingType& aOrientationTrackingType)

    {

    TInt error = KErrNone;

    CWsWindowGroup* focusWinGroup = CWsTop::FocusWindowGroup();    

    if(!focusWinGroup)

        {

        if(wsDebugLog)

            {

            _LIT(logText,"Orientation Tracker: focusWinGroup not found");

            wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,logText);

            }

        error = KErrNotFound;

        }

    else

        {

        error = CheckWindowGroupOrientation(*focusWinGroup, aOrientationTrackingType);

        }

    return error;

    }

/**

Finds the topmost usable windowgroup which has a usable orientation, and outputs that orientation

@param Output: The current render orientation

@return KErrNone if successful, KErrNotSupported if an invalid orientation is found

*/

TInt CWsRenderOrienationTracker::FindOrientationFromWindowTree(TRenderOrientationTrackingType& aOrientationTrackingType)

    {

    TInt error = KErrNone;

    TRenderOrientationTrackingType tempOrientationTrackingType = iRenderOrientationTrackingType;

    CWsRootWindow* rootWin = CWsTop::CurrentFocusScreen()->RootWindow();

    TBool finished = EFalse;

    for(CWsWindowGroup* winGroup = rootWin->Child(); !finished && NULL != winGroup; winGroup = winGroup->NextSibling())

        {

        if (wsDebugLog)

            {

            _LIT(logText,"Orientation Tracker: winGroup %08x has priority %d, Orientation %d, Focusable %d, Child %08x");

            TBuf<LogTBufSize> buf;

            buf.Format(logText, winGroup, winGroup->OrdinalPriority(), winGroup->WsOwner()->GetIndicatedAppOrientation(),

                    winGroup->IsFocusable()?ETrue:EFalse, winGroup->Child());                                

            wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,buf);

            }               

        // winGroup is a higher priority ordinal, so see if it has an orientation that can be used

        // although we're only interested in window groups with child windows otherwise nothing is visible anyway        

        if(UseableGroupWindow(*winGroup))

            {

            error = CheckWindowGroupOrientation(*winGroup, tempOrientationTrackingType);

            switch(error)

                {

                case KErrNone:

                    {

                    // List is in order, so just find the first one

                    if (wsDebugLog)

                        {

                        _LIT(logText,"Orientation Tracker: Found winGroup %08x with Orientation %d");

                        TBuf<LogTBufSize> buf;

                        buf.Format(logText, winGroup, winGroup->WsOwner()->GetIndicatedAppOrientation());                    

                        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,buf);

                        }

                    finished = ETrue;

                    break;

                    }

                case KErrNotFound:

                    // so keep searching

                    break;                    

                case KErrNotSupported:

                default:

                    finished = ETrue;

                    break;

                }

            }

        }

    // Safe even in error code as won't have been changed by CheckWindowGroupOrientation

    aOrientationTrackingType = tempOrientationTrackingType;

    return error;

    }

/**

First checks to see if the focus window group has a usable orientation, if so that is output.

Otherwise, finds the topmost usable windowgroup which has a usable orientation, and outputs that

@param Output: The current render orientation

@return KErrNone if successful, KErrNotSupported if an invalid orientation is found 

 */

TInt CWsRenderOrienationTracker::GetIndicatedOrientation(TRenderOrientationTrackingType& aOrientationTrackingType)

    {

    // First check the focus window group

    TInt error = GetFocusWindowOrientation(aOrientationTrackingType);

    // Don't look for another window if the focus window is usable

    // or if an error has occured, then don't change current orientation

    switch(error)

        {

        case KErrNone:

            {

            if(wsDebugLog)

                {

                _LIT(logText,"Orientation Tracker: Using focus window %08x for orientation");

                wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,logText,reinterpret_cast<TInt>(CWsTop::FocusWindowGroup()));

                }

            break;

            }

        case KErrNotFound:

            {

            // Can't use focus window group, so find the topmost windowgroup with a valid orientation

            error = FindOrientationFromWindowTree(aOrientationTrackingType);

            break;

            }

        default:

            // Unrecoverable error, abort and leave published orientation unchanged

            break;

        }

    return error;

    }

/**

Checks to see if the render orientation has changed, and publishes any new orientaion

via publish and subscribe

@see KRenderOrientationCategory

@see KRenderOrientationKey 

*/

void CWsRenderOrienationTracker::CheckRenderOrientation()

    {

    TRenderOrientationTrackingType newOrientationTrackingType = iRenderOrientationTrackingType;    

    TInt error = GetIndicatedOrientation(newOrientationTrackingType);

    // if the tracking type has changed...

    if(KErrNone == error && iRenderOrientationTrackingType != newOrientationTrackingType)

        {

        if(EDisplayOrientationAuto == iRenderOrientationTrackingType)

            {

            // change from auto type, so we need to cancel request for updates from the theme server        

            Cancel();

            }    

        iRenderOrientationTrackingType = newOrientationTrackingType;

        if(EDisplayOrientationAuto == iRenderOrientationTrackingType)

            {

            // Change to auto type, so we need to request updates from the theme server            

            // Attach to the Theme server to get orientation change updates

            error = iThemeOrientationProperty.Attach( KThemeOrientationCategory, KThemeOrientationKey );

            if (wsDebugLog)

                {

                if(KErrNone == error)

                    {

                    // Information Log

                    _LIT(logText,"Orientation Tracker: Attached to theme orientation property");

                    wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,logText);

                    }

                else

                    {

                    // Error Log

                    _LIT(logText,"Orientation Tracker: Error %d attaching to theme orientation property");

                    wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,logText, error);                

                    }

                }              

            RequestDeviceOrientationNotification();

            }

        // See if the  has changed, and publish if it has        

        error = DoOrientationTracking();

        }

    if (wsDebugLog && KErrNone != error)

        {

        _LIT(logText,"Orientation Tracker: Error %d Checking Render Orientation");

        wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,logText, error);

        }  

    }

/**

Requests notification of change of the theme server orientation

@Pre iThemeOrientationProperty has had Attach called on it

*/

void CWsRenderOrienationTracker::RequestDeviceOrientationNotification()

    {

    if(!IsActive())

        {

        if (wsDebugLog)

            {

            _LIT(logText,"Orientation Tracker: Subscribing to theme orientation property");

            wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,logText);

            }          

        // Request for Theme Server Orientation P&S  

        iThemeOrientationProperty.Subscribe(iStatus);        

        SetActive();

        }

    }

/**

Cancels and closes (detaches) from the theme orientation publish and subscribe

*/

void CWsRenderOrienationTracker::CancelDeviceOrientationNotification()

    {

    // Cancel Request for Theme Server Orientation P&S  

    iThemeOrientationProperty.Cancel();

    iThemeOrientationProperty.Close();

    if (wsDebugLog)

        {

        _LIT(logText,"Orientation Tracker: Cancelled/closed theme orientation property");

        wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything,logText);

        }      

    }

/**

Called when the theme servers orientation has changed.

Re-requests unless cancelled

*/

void CWsRenderOrienationTracker::RunL()

    {

    TInt error = iStatus.Int();

    if(KErrNone == error)

        {

        // Re-request

        RequestDeviceOrientationNotification();

        TInt error = DoOrientationTracking();

        if (wsDebugLog && KErrNone != error)

            {

            _LIT(logText,"Orientation Tracker: Error %d processing theme orientation property");

            wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,logText, error);

            }         

        }

    else if (wsDebugLog && KErrCancel != error)

        {

        _LIT(logText,"Orientation Tracker: Error %d from theme orientation property, not resubscribed");

        wsDebugLog->MiscMessage(CDebugLogBase::ELogImportant,logText, error);     

        }

    }

/**

Cancels the request for notification for changes to theme orientation

*/

void CWsRenderOrienationTracker::DoCancel()

    {

    CancelDeviceOrientationNotification();

    }

/**

Gets the orientation published from theme server

@param Output: the theme server orientation

@return KErrNone if successful, KErrNotSupported if the theme server returns an unknown orientation, else any of the system wide error codes 

*/

TInt CWsRenderOrienationTracker::GetThemeOrientation(TRenderOrientation& aThemeOrientation)

    { 

    TInt themeOrientation=EDisplayOrientationNormal;

    TInt error = iThemeOrientationProperty.Get(themeOrientation);

    if(wsDebugLog && KErrNone != error)

        {

        _LIT(logText,"Orientation Tracker: Error %d getting theme orientation property");

        wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,logText, error);     

        }

    if(KErrNone == error)

        {

        // Translate the received orientation    

        switch(themeOrientation)

            {           

            case EDisplayOrientationNormal:

            case EDisplayOrientation90CW:

            case EDisplayOrientation180:

            case EDisplayOrientation270CW:

                // only update if orientation is supported

                aThemeOrientation = static_cast<TRenderOrientation>(themeOrientation);

                break;

            default:

                error = KErrNotSupported;

                if (wsDebugLog)

                    {

                    _LIT(logText,"Orientation Tracker: Unsupported orientation %d from theme orientation property, Error %d");

                    TBuf<LogTBufSize> buf;

                    buf.Format(logText, themeOrientation, error);

                    wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,buf);     

                    }                

                break;

            }

        }

    return error;  

    }

/**

Processes the indicated orientation into an actual orientation

@return KErrNone for success, KErrNotSupported if the orientation is unknown, else any of the system wide error codes

*/

TInt CWsRenderOrienationTracker::DoOrientationTracking()

    {

    TInt error = KErrNone;

    TRenderOrientation newDeviceOrientation;

    switch(iRenderOrientationTrackingType)

        {

        case EDisplayOrientationNormal:

        case EDisplayOrientation90CW:                

        case EDisplayOrientation180:

        case EDisplayOrientation270CW:            

            newDeviceOrientation = iRenderOrientationTrackingType;

            break;

        case EDisplayOrientationAuto:

            error = GetThemeOrientation(newDeviceOrientation);

            break;

        default:

            error = KErrNotSupported;

            if (wsDebugLog)

                {

                _LIT(logText,"Orientation Tracker: Unsupported orientation tracking type %d, error %d");

                TBuf<LogTBufSize> buf;

                buf.Format(logText, iRenderOrientationTrackingType, error);

                wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,buf);     

                }              

            break;            

        }    

    if(KErrNone == error)

        {

        error = PublishOrientation(newDeviceOrientation);

        }

    return error;

    }

/**

Publishes the given value

@param The render orientation to publish

@return KErrNone for success, else any of the system wide erro codes

*/

TInt CWsRenderOrienationTracker::DoPublishOrientation(const TRenderOrientation aRenderOrientation)

    {

    TInt error = iRenderOrientationPublisher.Set(aRenderOrientation);

    // if it's published OK, then remember the newly published value

    if(KErrNone == error)

        {

        iPublishedRenderOrientation = aRenderOrientation;

        if(wsDebugLog)

            {

            _LIT(logText,"Orientation Tracker: Published render orientation %d");

            wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, logText, aRenderOrientation);

            }

        }

    else if(wsDebugLog)

        {

        _LIT(logText,"Orientation Tracker: Error %d setting render orientation property");

        wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate, logText, error);                   

        }

    return error;

    }

void CWsRenderOrienationTracker::SetHALOrientation(const TRenderOrientation aRenderOrientation)

    {

    // If the render orientation is EDisplayOrientationAuto then don't update HAL

    // The application and HAL should always have the same state for the orientation.

    if(EDisplayOrientationAuto != aRenderOrientation)

        {

        TInt error = HAL::Set(CWsTop::CurrentFocusScreen()->ScreenNumber(), HALData::EDigitiserOrientation, WservToDigitiser(iPublishedRenderOrientation));

        //Just log the error if there is one.

        if(wsDebugLog && error != KErrNone)

            {

            _LIT(logText,"Orientation Tracker: Error %d setting digitiser orientation");

            wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate, logText, error);           

            } 

        }

    }

/**

If the current orientation differs from the previously published value then publishes the current value

@param The render orientation to check and publish

@return KErrNone for success, else any of the system wide erro codes

*/

TInt CWsRenderOrienationTracker::PublishOrientation(const TRenderOrientation aRenderOrientation)

    {

    TInt error = KErrNone;

    if(aRenderOrientation != iPublishedRenderOrientation)

        {

        // If the device Orientation has changed, publish it

        error = DoPublishOrientation(aRenderOrientation);

        if(KErrNone == error)

            SetHALOrientation(aRenderOrientation);

        }

    return error;

    }