// Copyright (c) 2010 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:
//

/**
 @file
 @test
 @internalComponent - Internal Nokia test code 
*/

#include <w32std.h>

#include <wspublishandsubscribedata.h>
#include "trenderorientation.h"

const TInt KPublishTimeout  = 1000000;  // 1 second in microseconds
const TInt KNumIterations   = 20;

// Values for the device orientation that we receive via P&S from the Theme Server
// Must match those in renderorientationtracker.h, and, obviously, those used by the real theme server 
const TUid  KThemeOrientationCategory   = {0x20022E82}; // == KHbPsHardwareCoarseOrientationCategoryUid 
const TUint KThemeOrientationKey        = 0x4F726965; // == KHbPsHardwareCoarseOrientationKey 

void CWindowStuff::ConstructL()
    {
    User::LeaveIfError(iWs.Connect());
    iWs.SetAutoFlush(ETrue);
    
    iWindowGroup = RWindowGroup(iWs);
    User::LeaveIfError(iWindowGroup.Construct(reinterpret_cast<TUint32>(&iWindowGroup)));
    
    iChildWindow = RWindow(iWs);
    User::LeaveIfError(iChildWindow.Construct(iWindowGroup, reinterpret_cast<TUint32>(&iChildWindow)));
    }

CWindowStuff::~CWindowStuff()
    {
    Destroy();
    }

void CWindowStuff::Destroy()
    {
    iChildWindow.Close();
    iWindowGroup.Close();
    iWs.Close();    
    }

CTRenderOrientation::CTRenderOrientation()
    {
    // check that these two enums are aligned
    __ASSERT_COMPILE(EDisplayOrientationAuto == ENumWindowThings);
    
    SetTestStepName(KTRenderOrientation);
    }

CTRenderOrientation::~CTRenderOrientation()
    {
    }

TRenderOrientation CTRenderOrientation::GetRenderOrientationL()
    {    
    return GetOrientationL(iWsRenderOrientationProperty);    
    }

TRenderOrientation CTRenderOrientation::GetThemeOrientationL()
    {    
    return GetOrientationL(iThemeOrientationProperty);    
    }

TRenderOrientation CTRenderOrientation::GetOrientationL(RProperty& aProperty)
    {
    TInt orientation=EDisplayOrientationNormal;
    User::LeaveIfError(aProperty.Get(orientation));
    
    TESTL(orientation >= EDisplayOrientationNormal);
    TESTL(orientation < EDisplayOrientationAuto);    
    
    return static_cast<TRenderOrientation>(orientation);    
    }

void CTRenderOrientation::TestOrientationChangeL(const TDesC& aStepName, TTestPhase aTestPhase)
    {
    SetTestStepID(aStepName);
    
    if(EThemeOrientationChange == aTestPhase)
        {               
        TESTL(EDisplayOrientationNormal == GetThemeOrientationL());
        iWindowStuff[EFirstWindowThing].Session().IndicateAppOrientation(EDisplayOrientationAuto);        
        }
    
    TInt renderOrientation = GetRenderOrientationL();
    
    // For consistancy, check that we are starting from the same orientation
    TESTL(EDisplayOrientationNormal == renderOrientation);    
    
    // Set-up the timer
    iProfiler->InitResults();
    iTimingsTaken = 0;    
    
    // repeat numerous times to get a decent average
    for(TInt iterations=0; iterations < KNumIterations; ++iterations)
        {
        renderOrientation = GetRenderOrientationL();
        // For consistancy, check that we are starting from the same orientation
        TESTL(EDisplayOrientationNormal == renderOrientation);           
        
        // loop through the orientations, ending up changing back to normal
        for(++renderOrientation; renderOrientation <= EDisplayOrientationAuto; ++renderOrientation)
            {
            // % can be slow, do it outside of the timing
            TRenderOrientation testOrientation = static_cast<TRenderOrientation>(renderOrientation%EDisplayOrientationAuto);
            
            iWsRenderOrientationProperty.Subscribe(iRenderOrientationStatus);            
            // start the timeout timer
            iTimeoutTimer.After(iTimeoutStatus, KPublishTimeout);
            // start the results timer
            iProfiler->StartTimer();
            
            switch(aTestPhase)
                {
                case EIndicatedOrientationChange:
                    // Do the indicated orientation Change
                    iWindowStuff[EFirstWindowThing].Session().IndicateAppOrientation(testOrientation);
                    break;
                    
                case EWindowOrdinalChange:
                    // move the relevant window group to the front
                    // N.B. this will go wrong if the number of orientations and windows are not equal
                    iWindowStuff[testOrientation].WindowGroup().SetOrdinalPosition(0);
                    break;
                    
                case EThemeOrientationChange:
                    // Needs the focus window to be in auto mode
                    iThemeOrientationProperty.Set(testOrientation);
                    break;
                    
                default:
                    TESTL(EFalse);
                }
        
            // Wait for the update to have been published ( or time out while waiting )
            User::WaitForRequest(iRenderOrientationStatus, iTimeoutStatus);
            
            iProfiler->MarkResultSetL();
            ++iTimingsTaken;
            
            if(KErrNone != iRenderOrientationStatus.Int())
                {
                // timed out
                iWsRenderOrientationProperty.Cancel();                
                TESTL(EFalse);
                }
            else
                {
                // Check that it is actually the expected orientation
                TESTL(GetRenderOrientationL() == testOrientation);
                }

            if(KRequestPending == iTimeoutStatus.Int())
                {
                // as expected, so cancel the timeout timer
                iTimeoutTimer.Cancel();
                }
            else
                {
                // timed out
                TESTL(EFalse);
                }
            }
        }    
    
    // wrap it up    
    iProfiler->ResultsAnalysis(KTRenderOrientation,KErrNotFound,ENone,ENone,iTimingsTaken);
    }

TVerdict CTRenderOrientation::doTestStepL()
    {     
    INFO_PRINTF1(_L("Testing: Indicated Orientation Change"));
    TestOrientationChangeL(_L("GRAPHICS-UI-BENCH-0xxx1"), EIndicatedOrientationChange);
    
    INFO_PRINTF1(_L("Testing: Window Ordinal Position Change"));
    TestOrientationChangeL(_L("GRAPHICS-UI-BENCH-0xxx2"), EWindowOrdinalChange);
    
    INFO_PRINTF1(_L("Testing: Theme Orientation Change"));
    TestOrientationChangeL(_L("GRAPHICS-UI-BENCH-0xxx3"), EThemeOrientationChange);
    
    return TestStepResult();    
    }

_LIT(KThemeServerPropertyDefine, "twsthemeserverpropertydefine.exe");
_LIT(KThemeServerPropertyDefineCmdDefine, "define");
_LIT(KThemeServerPropertyDefineCmdDelete, "delete");   
   
void CTRenderOrientation::ThemeServerProperty(const TDesC& aCmd)
    {
    /* This Process called with the argument KThemeServerPropertyDefineCmdDelete, deletes 
       the theme server RProperty. This is because an RProperty can only be defined and 
       deleted from within a process with the same UID3 as the RProperty catogory you are 
       trying to define/delete.*/
    RProcess themeServerPropertyDefine;
    TInt err = themeServerPropertyDefine.Create(KThemeServerPropertyDefine, aCmd);
    if (KErrNone != err)
        {
        _LIT(KLog, "themeServerPropertyDefine.Create() failed with error: %d");
        INFO_PRINTF2(KLog, err);
        TEST(EFalse);        
        }
    
    //wait for themeServerPropertyDefine process to terminate
    TRequestStatus themeServerPropertyDefineLogonStatus;
    themeServerPropertyDefine.Logon(themeServerPropertyDefineLogonStatus);
    themeServerPropertyDefine.Resume();
    User::WaitForRequest(themeServerPropertyDefineLogonStatus);
    if (themeServerPropertyDefineLogonStatus != KErrNone)
        {
        _LIT(KLog, "themeServerPropertyDefine.Logon() failed with error: %d");
        INFO_PRINTF2(KLog, themeServerPropertyDefineLogonStatus);
        TEST(EFalse);        
        }
    themeServerPropertyDefine.Close();    
    }

TVerdict CTRenderOrientation::doTestStepPreambleL()
    {
    // Create in reverse order so that windowThing 0 is at the front
    for(TInt windowThing = ENumWindowThings - 1; windowThing >= 0 ; --windowThing)
        {
        iWindowStuff[windowThing].ConstructL();
        TRenderOrientation orientation = static_cast<TRenderOrientation>(windowThing%EDisplayOrientationAuto);
        iWindowStuff[windowThing].Session().IndicateAppOrientation(orientation);
        iWindowStuff[windowThing].WindowGroup().SetOrdinalPosition(0);
        }
    
    User::LeaveIfError(iWsRenderOrientationProperty.Attach(KRenderOrientationCategory, KRenderOrientationKey));
    
    ThemeServerProperty(KThemeServerPropertyDefineCmdDefine);
    User::LeaveIfError(iThemeOrientationProperty.Attach(KThemeOrientationCategory, KThemeOrientationKey));
    
    User::LeaveIfError(iTimeoutTimer.CreateLocal());
    
    return CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();
    }

TVerdict CTRenderOrientation::doTestStepPostambleL()
    {
    iTimeoutTimer.Close();
    
    iThemeOrientationProperty.Close();
    ThemeServerProperty(KThemeServerPropertyDefineCmdDelete);    
    iWsRenderOrientationProperty.Close();
    
    for(TInt windowThing = 0; windowThing < ENumWindowThings; ++windowThing)
        {
        iWindowStuff[windowThing].Destroy();
        }
    
    return CTe_graphicsperformanceSuiteStepBase::doTestStepPostambleL();
    }