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

     }