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

// Tests 100% of the public API of the Cone view architecture support.

// The tests performed are server start, coe env and app ui creation, addition of views,

// activation of views, activation message passing, queuing of view events,

// removal of views, view control stacking, key event simulation, control stack flag changing,

// addition of default view, activation of default view, addition of view deactivation observers

// removal of view deactivation observers.

// Also tests the ordering of key event passing for controls on the control stack of the appUi and

// the active view. Low priority controls in the appUi should get key events after higher priority

// controls in the active view. 

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include <e32cons.h>

#include <vwsappst.h>

#include <coeaui.h>

#include <coemain.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <viewclipartner.h>

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "coepriv.h"

#include "COEVWMAN.H"

#include <test/appfwk_test.h>

#include "TVWASTEP.H"

/*************************************************************

 **  

 **  Global constants

 **   

 *************************************************************/

_LIT(KCustomDes,"Custom Message");

_LIT(KNullDes,"");

#define KUidTViewAppOneValue 0xA

const TUid KUidTViewAppOne={KUidTViewAppOneValue};

#define KUidTViewOneValue 0x1

const TUid KUidTViewOne={KUidTViewOneValue};

#define KUidTViewTwoValue 0x2

const TUid KUidTViewTwo={KUidTViewTwoValue};

#define KUidTViewFiveValue 0x5

const TUid KUidTViewFive={KUidTViewFiveValue};

#define VIEW_ONE TVwsViewId(KUidTViewAppOne,KUidTViewOne)

#define VIEW_TWO TVwsViewId(KUidTViewAppOne,KUidTViewTwo)

#define VIEW_FIVE TVwsViewId(KUidTViewAppOne,KUidTViewFive)

#define KUidTViewAppTwoValue 0xB

const TUid KUidTViewAppTwo={KUidTViewAppTwoValue};

#define KUidTViewThreeValue 0x3

const TUid KUidTViewThree={KUidTViewThreeValue};

#define KUidTViewFourValue 0x4

const TUid KUidTViewFour={KUidTViewFourValue};

#define VIEW_THREE TVwsViewId(KUidTViewAppTwo,KUidTViewThree)

#define VIEW_FOUR TVwsViewId(KUidTViewAppTwo,KUidTViewFour)

const TUid KUidTws0CustomMesssageId={0x1};

const TInt KTopControlId=1;

const TInt KBottomControlId=2;

const TInt KViewDeactivationObserverOneId=1;

const TInt KViewDeactivationObserverTwoId=2;

const TInt KViewActivationObserverOneId=1;

const TInt KViewActivationObserverTwoId=2;

const TInt KViewActivationObserverThreeId=3;

// Global variables to check activations & deactivations notifications...

TInt gViewActivationObserverOne;

TInt gViewDeactivationObserverOne;

TInt gViewActivationObserverTwo;

TInt gViewDeactivationObserverTwo;

TInt gViewActivationObserverNotify;

TInt gViewDeactivationObserverNotify;

// Global variables to check controls event consumptions...

TInt gTopControl;

TInt gBottomControl;

TInt gAppUiControl;

enum TTestFrameworkPanic

    {

    ETestFailure = 1

    };

static void PanicWithCondAndInfo(TTestFrameworkPanic aPanic, const TDesC& aCondition, const TDesC& aFileName, const TDesC& aPanicName, TInt aLine)

    {

    TBuf<256> buf;

    _LIT(KPanicDesc1,"Testframework Panic %S, in file %S @ line %i");

    buf.Format(KPanicDesc1, &aPanicName, &aFileName, aLine);

    RDebug::Print(buf);

    _LIT(KPanicDesc2,"Assert condition = \"%S\"");

    buf.Format(KPanicDesc2, &aCondition);

    RDebug::Print(buf);

    _LIT(KPanicCategory,"CTestDriver");

    User::Panic(KPanicCategory,aPanic);

    }

#define _ASSERT_FILENAME(f)  _LIT(KPanicFileName, f);

#define _ASSERT_PANICNAME(p) _LIT(KPanicEnum ## p, # p);

#define _ASSERT_CONDITION(c) _LIT(KPanicCondition, c);

#define TEST_ASSERT(c, p) \

        do  { \

            if (!(c)) \

                { \

                _ASSERT_FILENAME(__FILE__); \

                _ASSERT_PANICNAME(p); \

                _ASSERT_CONDITION(#c); \

                PanicWithCondAndInfo(p, KPanicCondition, KPanicFileName, KPanicEnum ## p, __LINE__); \

                } \

            } while (0)

// Use this method as a way to test when usage of TEST macro is not possible

//inline void TEST_ASSERT(TBool aCondition){ TEST_ASSERT(aCondition, ETestFailure); }

/*************************************************************

 **  

 **  CViewActivationObserver  - implements the MCoeViewActivationObserver interface

 **  

 *************************************************************/

CViewActivationObserver* CViewActivationObserver::NewL(TInt aObserverId)

	{

	CViewActivationObserver* self=new(ELeave) CViewActivationObserver(aObserverId);

	return self;

	}

CViewActivationObserver::CViewActivationObserver(TInt aObserverId) : iObserverId(aObserverId)

	{

	}

CViewActivationObserver::~CViewActivationObserver()

	{

	}

void CViewActivationObserver::HandleViewActivation(const TVwsViewId& aNewlyActivatedViewId,const TVwsViewId& aViewIdToBeDeactivated)

	{

	RDebug::Print(_L("CViewActivationObserver::HandleViewActivation: Observer 0x%x - Newly Active View: 0x%x - Deactivate 0x%x"), iObserverId, aNewlyActivatedViewId.iViewUid.iUid, aViewIdToBeDeactivated.iViewUid.iUid);

	// for testing purposes

	if (iObserverId == KViewActivationObserverOneId)

		gViewActivationObserverOne++;

	else if (iObserverId == KViewActivationObserverTwoId)

		gViewActivationObserverTwo++;

	}

/*************************************************************

 **  

 **  CViewDeactivationObserver  - implements the MCoeViewDeactivationObserver interface

 **  

 *************************************************************/

CViewDeactivationObserver* CViewDeactivationObserver::NewL(TInt aObserverId)

	{

	CViewDeactivationObserver* self=new(ELeave) CViewDeactivationObserver(aObserverId);

	return self;

	}

CViewDeactivationObserver::CViewDeactivationObserver(TInt aObserverId) : iObserverId(aObserverId)

	{

	}

CViewDeactivationObserver::~CViewDeactivationObserver()

	{

	}

void CViewDeactivationObserver::HandleViewDeactivation(const TVwsViewId& aViewIdToBeDeactivated,const TVwsViewId& aNewlyActivatedViewId)

	{

	RDebug::Print(_L("CViewDeactivationObserver::HandleViewDeactivation: Observer 0x%x - Deactivate 0x%x - Newly Active View: 0x%x"), iObserverId, aViewIdToBeDeactivated.iViewUid.iUid, aNewlyActivatedViewId.iViewUid.iUid);

	// for testing purposes

	if (iObserverId == KViewDeactivationObserverOneId)

		gViewDeactivationObserverOne++;

	else if (iObserverId == KViewDeactivationObserverTwoId)

		gViewDeactivationObserverTwo++;

	}

/*************************************************************

 **  

 **  CViewActivationObserver_Notify  - implements the MCoeViewActivationObserver interface for notifications only

 **  

 *************************************************************/

CViewActivationObserver_Notify* CViewActivationObserver_Notify::NewL()

	{

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

	return self;

	}

CViewActivationObserver_Notify::CViewActivationObserver_Notify() 

	{

	}

CViewActivationObserver_Notify::~CViewActivationObserver_Notify()

	{

	}

void CViewActivationObserver_Notify::HandleViewActivation(const TVwsViewId& aNewlyActivatedViewId,const TVwsViewId& aViewIdToBeDeactivated)

	{

	RDebug::Print(_L("Notified CViewActivationObserver_Notify::HandleViewActivation: Newly Active View: 0x%x - Deactivate 0x%x"), aNewlyActivatedViewId.iViewUid.iUid, aViewIdToBeDeactivated.iViewUid.iUid);

	// for testing purposes

	gViewActivationObserverNotify++;

	}

/*************************************************************

 **  

 **  CViewDeactivationObserver_Notify  - implements the MCoeViewDeactivationObserver interface for notifications only

 **  

 *************************************************************/

CViewDeactivationObserver_Notify* CViewDeactivationObserver_Notify::NewL()

	{

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

	return self;

	}

CViewDeactivationObserver_Notify::CViewDeactivationObserver_Notify()

	{

	}

CViewDeactivationObserver_Notify::~CViewDeactivationObserver_Notify()

	{

	}

void CViewDeactivationObserver_Notify::HandleViewDeactivation(const TVwsViewId& aViewIdToBeDeactivated,const TVwsViewId& aNewlyActivatedViewId)

	{

	RDebug::Print(_L("Notified CViewDeactivationObserver_Notify::HandleViewDeactivation: Deactivate 0x%x - Newly Active View: 0x%x"), aViewIdToBeDeactivated.iViewUid.iUid, aNewlyActivatedViewId.iViewUid.iUid);

	// for testing purposes

	gViewDeactivationObserverNotify++;

	}

/*************************************************************

 **  

 **  CTVwaTestControl

 **  

 *************************************************************/

CTVwaTestControl::CTVwaTestControl(TVwsViewId& aViewId, TInt aControlId) : iViewId(aViewId), iControlId(aControlId)

    {

    }

void CTVwaTestControl::ConstructL()

    {

    CreateWindowL();

    SetExtent(TPoint(0,0),TSize(0,0));

    ActivateL();

    }

CTVwaTestControl::~CTVwaTestControl()

    {

    }

TKeyResponse CTVwaTestControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    {

    if (aType!=EEventKey)

	    return(EKeyWasConsumed);

	RDebug::Print(_L("Key Event: View: 0x%x - Control: 0x%x - Key 0x%x"), iViewId.iViewUid.iUid, iControlId, aKeyEvent.iCode);

	// for testing purposes

	if (iControlId == KTopControlId)

		gTopControl++;

	else if (iControlId == KBottomControlId)

		gBottomControl++;

	// For testing purposes, if the control receives a 'C', let's consume it.

	if (aKeyEvent.iCode == 'C')

	    return(EKeyWasConsumed);

	else

		return(EKeyWasNotConsumed);

    }

/*************************************************************

 **  

 **  CAppUiTestControl

 **  

 *************************************************************/

CAppUiTestControl::CAppUiTestControl()

    {

    }

void CAppUiTestControl::ConstructL()

    {

    CreateWindowL();

    SetExtent(TPoint(0,0),TSize(0,0));

    ActivateL();

    }

CAppUiTestControl::~CAppUiTestControl()

    {

    }

TKeyResponse CAppUiTestControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    {

    if (aType!=EEventKey)

	    return(EKeyWasConsumed);

	RDebug::Print(_L("AppUi Control Key Event: Key 0x%x"), aKeyEvent.iCode);

	// for testing purposes

	gAppUiControl++;

	// For testing purposes, if the control receives a 'U', let's consume it.

	if (aKeyEvent.iCode == 'C')

	    return(EKeyWasConsumed);

	else

		return(EKeyWasNotConsumed);

    }

/*************************************************************

 **  

 **  CTestView

 **  

 *************************************************************/

CTestView::~CTestView()

	{

	RemoveFromStack(iTopControl);

	delete iTopControl;

	RemoveFromStack(iBottomControl);

	delete iBottomControl;

	}

CTestView::CTestView(const TVwsViewId& aViewId,CCoeAppUi& aAppUi)

	:iAppUi(aAppUi),iViewId(aViewId)

	{

	}

void CTestView::ConstructL()

	{

	iTopControl=new(ELeave) CTVwaTestControl(iViewId,KTopControlId);

    iTopControl->ConstructL();

	iBottomControl=new(ELeave) CTVwaTestControl(iViewId,KBottomControlId);

    iBottomControl->ConstructL();

	AddToStackL(iBottomControl);

	AddToStackL(iTopControl);

	}

/**

  Getter of view id.\n 

 */

TVwsViewId CTestView::ViewId() const

	{

	return iViewId;

	}

/**

  Activates the supplied view id.\n

 */

void CTestView::ViewActivatedL(const TVwsViewId& aPrevViewId,TUid aCustomMessageId,const TDesC8& aCustomMessage)

	{

	DoActivateNarrowL(aPrevViewId,aCustomMessageId,aCustomMessage);

	if (aPrevViewId.iAppUid.iUid == KUidTViewAppOneValue && iViewId.iAppUid.iUid == KUidTViewAppOneValue)

		{

		TSecureId processId = aPrevViewId.iAppUid;

		const TSecurityPolicy policy(processId);

		TInt previousAppInitiatedViewSwitch = 0;

		RDebug::Print(_L("Calling  CheckSourceOfViewSwitchL where appUid and processID are same ..."));

		TRAPD(err, previousAppInitiatedViewSwitch = iAppUi.CheckSourceOfViewSwitchL(policy, KSuppressPlatSecDiagnostic));

		TEST_ASSERT(err == KErrNone, ETestFailure);

		TEST_ASSERT(!previousAppInitiatedViewSwitch, ETestFailure);

		RDebug::Print(_L("Test for CheckSourceOfViewSwitchL complete ..."));

		}

	// CheckSourceOfViewSwitchL leaves with KErrUnknown if called outside of an implementation of MCoeView's ViewConstructL or ViewActivatedL

	// Do that if and only if we're switching between iAppUi (i.e. KTVwaStandardAppUiId, not KTVwaEmbeddedAppUiId)

	if (aPrevViewId.iAppUid.iUid == KUidTViewAppOneValue && iViewId.iAppUid.iUid == KUidTViewAppOneValue)

		{

		TInt r = 0;

		RDebug::Print(_L("Calling CheckSourceOfViewSwitchL with a valid TVendorId..."));

		TRAPD(err, r = iAppUi.CheckSourceOfViewSwitchL(TSecurityPolicy(TVendorId(0x70000001))));

		TEST_ASSERT(err == KErrNone, ETestFailure);

		TEST_ASSERT(r, ETestFailure);

		RDebug::Print(_L("Calling CheckSourceOfViewSwitchL with an invalid TVendorId..."));

		APPFWK_NEGATIVE_PLATSEC_START;

		TRAP(err, r = iAppUi.CheckSourceOfViewSwitchL(TSecurityPolicy(TVendorId(0x70000002)), __PLATSEC_DIAGNOSTIC_STRING("z:/conetest/menutest_t_vwa.script negative testing")));

		APPFWK_NEGATIVE_PLATSEC_FINISH;

		TEST_ASSERT(err == KErrNone, ETestFailure);

		TEST_ASSERT(!r, ETestFailure);

		}

	}

/**

  Activates the supplied view id but narrows down the supplied message from 16-bit unicode to 8 bit ASCII.

 */

void CTestView::DoActivateNarrowL(const TVwsViewId& aPrevViewId,TUid aCustomMessageId,const TDesC8& aCustomMessage)

	{

	HBufC16* wideCustomMessage=HBufC16::NewLC(aCustomMessage.Length()/2);

	TPtr16 ptr=wideCustomMessage->Des();

	ptr.Copy((TUint16*)aCustomMessage.Ptr(),aCustomMessage.Length()/2);

	DoActivateL(aPrevViewId,aCustomMessageId,ptr);

	CleanupStack::PopAndDestroy(wideCustomMessage);

	}

/**

  Activates the supplied view id.\n

 */

void CTestView::DoActivateL(const TVwsViewId& aPrevViewId,TUid aCustomMessageId,const TDesC16& aCustomMessage)

	{

	RDebug::Print(_L("CTestView::ViewActivatedL:: 0x%x - Previous View: 0x%x"), iViewId.iViewUid.iUid, aPrevViewId.iViewUid.iUid);

	RDebug::Print(_L("Message - Id: 0x%x - Text: %S"),aCustomMessageId.iUid, &aCustomMessage);

	}

/**

  Handles a change to the screen device returning the value of the TVwsViewIdAndMessage

  object that describes what the view architecture should do next.\n

 */

TVwsViewIdAndMessage CTestView::ViewScreenDeviceChangedL()

	{

	RDebug::Print(_L("CTestView::ViewScreenDeviceChangedL: 0x%x"), iViewId.iViewUid.iUid);

	return TVwsViewIdAndMessage();

	}

/**

  Prints a message which view has been deactivated.\n

 */

void CTestView::ViewDeactivated()

	{

	RDebug::Print(_L("CTestView::ViewDeactivated: 0x%x "), iViewId.iViewUid.iUid);

	}

/**

  Debug print of the uid of the top control.\n

 */

void CTestView::ViewConstructL()

	{

	if(!iTopControl && !iBottomControl)

		{

		ConstructL();

		}

	RDebug::Print(_L("CTestView::ViewConstructL: 0x%x "), iViewId.iViewUid.iUid);

	}

/**

  Activates view with id aViewId.\n

 */

void CTestView::ActivateViewL(const TVwsViewId& aViewId)

	{

	iAppUi.ActivateViewL(aViewId);

	}

/**

  Activates view with id aViewId and send a message.\n

 */

void CTestView::ActivateViewL(const TVwsViewId& aViewId,TUid aCustomMessageId,const TDesC16& aCustomMessage)

	{

	HBufC8* narrowMessage=HBufC8::NewLC(aCustomMessage.Size());

	TPtr8 ptr=narrowMessage->Des();

	ptr.Copy((TUint8*)aCustomMessage.Ptr(),aCustomMessage.Size());

	iAppUi.ActivateViewL(aViewId,aCustomMessageId,narrowMessage->Des());

	CleanupStack::PopAndDestroy(narrowMessage);

	}

/**

  Add aControl to Cone's control stack with priority aPriority and behaviour aStackingFlags.\n

 */

void CTestView::AddToStackL(CCoeControl* aControl,TInt aPriority,TInt aStackingFlags)

	{

	iAppUi.AddToStackL(*this, aControl,aPriority,aStackingFlags);

	}

/**

  Remove aControl from Cone's control stack.\n

 */

void CTestView::RemoveFromStack(CCoeControl* aControl)

	{

	iAppUi.RemoveFromStack(aControl);

	}

/**

  Updates the value of the flags for aControl on the control stack.

  The mask aMask defines which flags are modified, while aFlags defines the values they are set to.\n

 */

void CTestView::UpdateStackedControlFlags(CCoeControl* aControl,TInt aFlags,TInt aMask)

	{

	iAppUi.UpdateStackedControlFlags(aControl,aFlags,aMask);

	}

/**

  Set the top control to refuse all key events.\n

 */

void CTestView::UpdateControlStackingFlags()