/*

* Copyright (c) 2007 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:  test case

*

*/

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknLayout2ScalableDef.h>

#include <AknLayout2ScalableDataDef.h>

#include <AknLayout2ScalableDecode.h>

#include <eikcolib.h>

#include <badesca.h>

#include <w32std.h>

#include <coecntrl.h>

#include <eikenv.h>

#include <barsread.h>

#include <coemain.h>

#include <eikdialg.h>

#include <akndialog.h>

#include <AknOpenFileService.h>

#include <AknReadingConverter.h>

#include <aknnavi.h>

#include <eiktxlbm.h> // CTextListBoxModel

#include <eiktxlbx.h>

#include <eiklbi.h>

#include <s32file.h>

#include <f32file.h>

#include <AiwGenericParam.h>

#include <AknNotifierAppServer.h>

#include <AknNotiferAppServerApplication.h>

#include <AknNotifierAppServerSession.h>

#include <aknnotifiercontroller.h>

#include <AknNotifierControllerPlugin.h>

#include <AknNotifierControllerUtilities.h>

#include <AknNotifierWrapper.h>

#include <AknNullService.h>

#include <aknsignal.h>

#include <AknSignalNotify.h>

#include <AknSignalNotifyAddition.h>

#include <aknlongtapanimation.h>

#include <AknMarqueeControl.h>

#include <AknMediatorFacade.h>

#include <aknMemoryCardDialog.h>

#include <aknlistloadertfx.h>

#include <AknPhoneNumberGrouping.h>

#include <AknPhoneNumberTextUtils.h>

#include <AknPhoneNumberEditor.h>

#include <aknnoteattributes.h>

#include <eikdialg.h>

#include <eikmenup.h>

#include <bctestdomnotifier.rsg>

#include "bctestdomnotifiercase.h"

#include "bctestdomnotifiercontainer.h"

#include "bctestdomnotifier.hrh"

#include "bctestdomnotifierview.h"

#include "bctestdomnotifierapp.h"

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

// ---------------------------------------------------------------------------

// Symbian 2nd static Constructor

// ---------------------------------------------------------------------------

//

CBCDomainTestNotifierCase* CBCDomainTestNotifierCase::NewL( CBCDomainTestNotifierContainer*

    aContainer )

    {

    CBCDomainTestNotifierCase* self = new( ELeave ) CBCDomainTestNotifierCase(

        aContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// C++ default constructor

// ---------------------------------------------------------------------------

//

CBCDomainTestNotifierCase::CBCDomainTestNotifierCase( CBCDomainTestNotifierContainer*

    aContainer )

    : iContainer( aContainer )

    {

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CBCDomainTestNotifierCase::~CBCDomainTestNotifierCase()

    {

    }

// ---------------------------------------------------------------------------

// Symbian 2nd Constructor

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::ConstructL()

    {

    BuildScriptL();

    }

// ---------------------------------------------------------------------------

// CBCDomainTestNotifierCase::BuildScriptL

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::BuildScriptL()

    {

    // Add script as your need.

    AddTestL( DELAY(1), LeftCBA, KeyOK, LeftCBA, Down, KeyOK, LeftCBA, Down,

        Down, KeyOK, DELAY(3), RightCBA, LeftCBA, Down, Down, Down, KeyOK, DELAY(3), RightCBA,

        TEND  );

    }

// ---------------------------------------------------------------------------

// CBCDomainTestNotifierCase::RunL

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::RunL( TInt aCmd )

    {

    if ( aCmd < EBCTestCmdOutline1 || aCmd > EBCTestCmdOutline4 )

        {

        return;

        }

    // Call release before prepare to let container has time to draw the

    // control created in PrepareCaseL.

    ReleaseCaseL();

    PrepareCaseL( aCmd );

    switch ( aCmd )

        {

        case EBCTestCmdOutline1:

            TestFunctionL();

            break;

        case EBCTestCmdOutline2:

// TestSignalL() has some problem, so comment it currently.

//            TestSignalL();

            break;

        case EBCTestCmdOutline3:

            TestOtherL();

            break;

        case EBCTestCmdOutline4:

            TestPhoneL();

			break;

        default:

            break;

        }

    }

// ---------------------------------------------------------------------------

// CBCDomainTestNotifierCase::PrepareCaseL

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::PrepareCaseL( TInt aCmd )

    {

    switch ( aCmd )

        {

        case EBCTestCmdOutline1:

            // Here is a simple demo. You should create your control

            // instead of this.

            iControl = new( ELeave ) CCoeControl();

            iControl->SetContainerWindowL( *iContainer );

            iControl->MakeVisible( ETrue );

            break;

        default:

            break;

        }

    // Pass the owner of iControl to iContainer.

    iContainer->SetControl( iControl );

    }

// ---------------------------------------------------------------------------

// CBCDomainTestNotifierCase::ReleaseCaseL

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::ReleaseCaseL()

    {

    // let container delete the component control.

    iContainer->ResetControl();

    iControl = NULL;

    }

// ---------------------------------------------------------------------------

// CBCDomainTestNotifierCase::TestFunctionL

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::TestFunctionL()

    {

    //aknopenfileservice.h

    RFs& fs = CEikonEnv::Static()->FsSession();

    RFile rfile;

    _LIT( KFilePath, "c:\\BCTestLog\\test.txt" );

    rfile.Create( fs, KFilePath, EFileWrite | EFileShareAny );

    CleanupClosePushL( rfile );

    // AknNotiferAppServerApplication.h

    CBCNotifierAppServer *notifierapp = new ( ELeave )

         CBCNotifierAppServer();

    CleanupStack::PushL( notifierapp );

    CApaDocument* tmp = notifierapp->CreateDocumentL();

    CApaAppServer* appserver = NULL;

    notifierapp->NewAppServerL( appserver );

    delete tmp;

    delete appserver;

    CleanupStack::PopAndDestroy( notifierapp );

    _LIT( KHandleCommandL, "HandleCommandL" );

    _LIT( KSetFadedL, "SetFadedL" );

    _LIT( KHandleKeyEventL, "HandleKeyEventL" );

    _LIT( KHandleError, "HandleError" );

    _LIT( KHandleSystemEventL, "HandleSystemEventL" );

    _LIT( KManager, "Manager" );

    _LIT( KSetManager, "SetManager" );

    _LIT( KEikSrvBlocked, "EikSrvBlocked" );

    CAknNotifierAppServerAppUi* notifier = static_cast<CAknNotifierAppServerAppUi*>

        ( CEikonEnv::Static()->AppUi() );

    notifier->CAknNotifierAppServerAppUi::HandleCommandL( EEikCmdCanceled );

    AssertTrueL( ETrue, KHandleCommandL );

    notifier->SetFadedL( EFalse );

    AssertTrueL( ETrue, KSetFadedL );

    TKeyEvent keyevent = { EKeyEnter, EStdKeyEnter, 0, 0  };

    notifier->HandleKeyEventL( keyevent, EEventNull );

    AssertTrueL( ETrue, KHandleKeyEventL );

    TInt handleErr = 0;

    SExtendedError exterr;

    TBuf<32> errbuf( KCAknNotifierAppServerAppUi );

    notifier->HandleError( handleErr, exterr , errbuf , errbuf );

    AssertTrueL( ETrue, KHandleError );

    TWsEvent wsevent;

    notifier->HandleSystemEventL( wsevent );

    AssertTrueL( ETrue, KHandleSystemEventL );

    MEikSrvNotifierManager* manager = notifier->Manager();

    AssertTrueL( ETrue, KManager );

    notifier->SetManager( manager );

    AssertTrueL( ETrue, KSetManager );

    notifier->EikSrvBlocked();

    AssertTrueL( ETrue, KEikSrvBlocked );

    //notifier->SuppressAppSwitching( ETrue );

    //_LIT( KSuppressAppSwitching, "SuppressAppSwitching" );

    //AssertTrueL( ETrue, KSuppressAppSwitching );

    // AknNotiferAppServer.h

    _LIT( KNotiServer, "CAknNotifierAppServer");

    _LIT( KStartNotifierL, "StartNotifierL");

    _LIT( KUpdateNotifierL, "UpdateNotifierL");

    _LIT( KCancelNotifier, "CancelNotifier");

    _LIT( KStartNotifierAndGetResponseL, "StartNotifierAndGetResponseL");

    _LIT( KAppendNotifierLibNameL, "AppendNotifierLibNameL");

    _LIT( KSetImplementationFinderL, "SetImplementationFinderL");

    _LIT( KUnbalanceReferenceCountForNotif, "UnbalanceReferenceCountForNotif");

    _LIT( KCreateServiceL, "CreateServiceL");

    _LIT( KCAknNotifierAppServerDestroy, "SCAknNotifierAppServerDestroy" );

    _LIT( KUpdateNotifierAndGetResponseL, "UpdateNotifierAndGetResponseL" );

////////////////////////////////////////////////////////////////////////////////////////////////

    CAknNotifierAppServer *notiserver = new ( ELeave ) CAknNotifierAppServer();

    CleanupStack::PushL( notiserver );

    AssertNotNullL( notiserver, KNotiServer );

    _LIT(KLabName, "ictsuiutilsnotif.dll");

	//_LIT(KLabName, "aknoldstylenotif.dll");

    notiserver->AppendNotifierLibNameL( KLabName );

    AssertTrueL( ETrue,KAppendNotifierLibNameL );

    //TRAP( err, notiserver->LoadNotifiersL() );

    //AssertTrueL( ETrue,KLoadNotifiersL );

    TBuf8<32> bf;

    TRAP( err,notiserver->StartNotifierL(

        KUidBCDomainTestNotifier, bf, bf ) );

    AssertTrueL( ETrue,KStartNotifierL );

    TRAP( err, notiserver->UpdateNotifierL(

        KUidBCDomainTestNotifier, bf, bf ) );

    AssertTrueL( ETrue,KUpdateNotifierL );

    notiserver->CancelNotifier( KUidBCDomainTestNotifier );

    AssertTrueL( ETrue,KCancelNotifier );

    RMessagePtr2 msg;

    TInt replyslot = 1;

    TRAP( err, notiserver->StartNotifierAndGetResponseL(

        KUidBCDomainTestNotifier, bf, msg, replyslot ) );

    AssertTrueL( ETrue, KStartNotifierAndGetResponseL );

    MNotifLibraryOwningServer* pFinder = NULL;

    notiserver->SetImplementationFinderL( pFinder );

    AssertTrueL( ETrue, KSetImplementationFinderL );

    notiserver->UnbalanceReferenceCountForNotif(

        KUidBCDomainTestNotifier, EFalse );

    AssertTrueL( ETrue,KUnbalanceReferenceCountForNotif );

    TRAP( err, notiserver->CreateServiceL( KUidBCDomainTestNotifier ) );

    AssertTrueL( ETrue, KCreateServiceL );

    TRAP( err, notiserver->UpdateNotifierAndGetResponseL(

        KUidBCDomainTestNotifier, bf, msg, replyslot ) );

    AssertTrueL( ETrue, KUpdateNotifierAndGetResponseL );

    CleanupStack::PopAndDestroy( notiserver );

    AssertTrueL( ETrue,KCAknNotifierAppServerDestroy );

////////////////////////////////////////////////////////////////////////////////////

    // AknNotifierAppServerSession.h

    // aknnotifiercontrollerutilities.h

    CAknNotifierControllerUtility* ntf =

                new ( ELeave )CAknNotifierControllerUtility(0);

    CleanupStack::PushL( ntf );

    ntf->DoStopNotifications();

    CleanupStack::PopAndDestroy( ntf );

    _LIT( KCAknNotifierControllerUtility,

                "CAknNotifierControllerUtility::DoStopNotifications()" );

    AssertTrueL( ETrue, KCAknNotifierControllerUtility );

    // aknnotifiercontroller.h

    _LIT( KCancelAllNotifications, "CancelAllNotifications" );

    _LIT( KHideAllNotifications, "HideAllNotifications" );

    AknNotifierController::HideAllNotifications( EFalse );

    AssertTrueL( ETrue, KHideAllNotifications );

    AknNotifierController::CancelAllNotifications();

    AssertTrueL( ETrue, KCancelAllNotifications );

    // aknnullservice.h

    _LIT( KCAknNullService, "CAknNullService" );

    _LIT( KCAknNullServiceDestroy, "CAknNullServiceDestroy" );

    MAknServerAppExitObserver* os = new ( ELeave ) CBCserverAppExitObserver();

    TUid KUidTest = { 0xA004000 };

    CAknNullService* nullserv = NULL;

    TRAP( err, nullserv = CAknNullService::NewL( KUidTest, os ) );

    CleanupStack::PushL( nullserv );

    AssertTrueL( ETrue,KCAknNullService );

    CleanupStack::Pop();

    AssertTrueL( ETrue,KCAknNullServiceDestroy );

    delete os;

    CAknLongTapAnimation* ltAnimation = CAknLongTapAnimation::NewL();

    CleanupStack::PushL( ltAnimation );

    _LIT( KCAknLongTapAnimationNewL, "CAknLongTapAnimation::NewL()" );

    AssertTrueL( ETrue, KCAknLongTapAnimationNewL );

    if (ltAnimation)

        {

        ltAnimation->ShowAnimationL( 10, 10 );

        _LIT( KCAknLongTapAnimationShowAnimationL,

            "CAknLongTapAnimation::ShowAnimationL()" );

        AssertTrueL( ETrue, KCAknLongTapAnimationShowAnimationL );

        ltAnimation->HideAnimation();

        _LIT( KCAknLongTapAnimationHideAnimation,

            "CAknLongTapAnimation::HideAnimation()" );

        AssertTrueL( ETrue, KCAknLongTapAnimationHideAnimation );

        }

    CleanupStack::PopAndDestroy();//ltAnimation

    }

// ---------------------------------------------------------------------------

// CBCDomainTestNotifierCase::TestSignalL

// ---------------------------------------------------------------------------

//

void CBCDomainTestNotifierCase::TestSignalL()

    {

    // aknsignal.h

    _LIT( KCAknSignalPane, "CAknSignalPane" );

    _LIT( KConstructFromResourceL, "ConstructFromResourceL" );

    _LIT( KSetSignalLevel, "SetSignalLevel" );

    _LIT( KShowGprsIcon, "ShowGprsIcon" );

    _LIT( KShowCommonPacketDataIcon, "ShowCommonPacketDataIcon" );

    _LIT( KShowWcdmaIcon, "ShowWcdmaIcon" );

    _LIT( KShowHsdpaIcon, "ShowHsdpaIcon" );

    _LIT( KShowEdgeIcon, "ShowEdgeIcon" );

    _LIT( KCAknSignalPaneDestroy, "SCAknSignalPaneDestroy" );

    CAknSignalPane* signalpane = new ( ELeave ) CAknSignalPane();

    CleanupStack::PushL( signalpane );

    AssertNotNullL( signalpane, KCAknSignalPane );

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader,

        R_BCTESTDOMNOTIFIER_VIEW );

    signalpane->ConstructFromResourceL( reader );

    AssertTrueL( ETrue, KConstructFromResourceL );

    signalpane->SetSignalLevel( 5 );

    AssertTrueL( ETrue, KSetSignalLevel );

    signalpane->ShowGprsIcon( EAknSignalGprsIndicatorOff );

    AssertTrueL( ETrue, KShowGprsIcon );

    signalpane->ShowCommonPacketDataIcon(

        EAknSignalCommonPacketDataIndicatorOff );

    AssertTrueL( ETrue,KShowCommonPacketDataIcon );

    signalpane->ShowWcdmaIcon( EAknSignalWcdmaIndicatorOff );

    AssertTrueL( ETrue, KShowWcdmaIcon );

    signalpane->ShowHsdpaIcon( EAknSignalHsdpaIndicatorOff );

    AssertTrueL( ETrue, KShowHsdpaIcon );

    signalpane->ShowCdmaIcon( EAknSignalCdmaIndicatorOff );

    AssertTrueL( ETrue, KShowHsdpaIcon );

    signalpane->ShowEdgeIcon( EAknSignalEdgeIndicatorOff );

    AssertTrueL( ETrue, KShowEdgeIcon );

    signalpane->SetNaviPaneBackgroundType( EAknNaviPaneBackgroundTypeNotDefined );

    // Extension Func ExtensionInterface()

    _LIT( KPositionChanged,"PositionChanged" );

    CleanupStack::PopAndDestroy();// reader

    CleanupStack::PopAndDestroy( signalpane );

    AssertTrueL( ETrue,KCAknSignalPaneDestroy );

    CBCSignalPane* bcsinpane = new ( ELeave ) CBCSignalPane();

    CEikonEnv::Static()->CreateResourceReaderLC( reader,

         R_BCTESTDOMNOTIFIER_VIEW );

    bcsinpane->ConstructFromResourceL( reader );

    bcsinpane->PositionChanged();

    AssertTrueL( ETrue, KPositionChanged );

    CleanupStack::PopAndDestroy();//reader

    delete bcsinpane;

    AssertTrueL( ETrue,KPositionChanged );

    // AknSignalNotifyAddition.h

    _LIT( KAknSignalNotifyAddition, "AknSignalNotifyAddition" );

    CAknNavigationControlContainer* navicontrol = new ( ELeave )

         CAknNavigationControlContainer();

    navicontrol->ConstructL();

    AssertTrueL( ETrue, KAknSignalNotifyAddition );

    delete navicontrol;

    //AknNotifierWrapper.h

    _LIT( KCAknCommonNotifierWrapper, "CAknCommonNotifierWrapper" );

    _LIT( KSetCustomSecurityHandler, "SetCustomSecurityHandler" );

    _LIT( KStartNotifierL, "StartNotifierL" );

    _LIT( KCancelNotifier, "SCancelNotifier" );

    _LIT( KStartNotifierL2, "StartNotifierL2" );

    _LIT( KUpdateNotifierL1, "UpdateNotifierL1" );

    _LIT( KUpdateNotifierL2, "UpdateNotifierL2" );

    _LIT( KDoNotifierControllerCommand, "DoNotifierControllerCommand" );

    _LIT( KStartL1, "StartL1" );

    _LIT( KStartL2, "StartL2" );

    _LIT( KUpdateL, "UpdateL" );

    _LIT( KSInfo, "Info" );

    _LIT( KNotifierCapabilites, "NotifierCapabilites" );

    _LIT( KCancel, "Cancel" );

    _LIT( KNewServerRequestL, "NewServerRequestL" );

    _LIT( KAsyncMessageCompleted, "AsyncMessageCompleted" );

    TBuf<32> plibaryname;

    TUid kuid = {0xA0004000};

    TUid  channel = EAknNotifierChannelNote;

    CAknCommonNotifierWrapper* notiwrap = CAknCommonNotifierWrapper::NewL(

        kuid, channel, MEikSrvNotifierBase2::ENotifierPriorityLowest,

        KSInfo, 64, EFalse );

    CleanupStack::PushL( notiwrap );

    AssertNotNullL( notiwrap, KCAknCommonNotifierWrapper );

    TBuf8<32> bf;

    RMessagePtr2 msg;

    TInt replyslot = 1;

    TUid KUid1 = { 0xA0004001 };

    TUid KUid2 = { 0xA0004002 };

    MAknNotifierCustomSecurityCheck* handler = NULL;

    notiwrap->SetCustomSecurityHandler( handler );

    AssertTrueL( ETrue, KSetCustomSecurityHandler );

    delete handler;

    notiwrap->StartNotifierL( KUid1, bf, replyslot, msg );

    AssertTrueL( ETrue, KStartNotifierL );

    TInt err = 0;

    TRAP( err, notiwrap->StartNotifierL( KUid2, bf ) );

    AssertTrueL( ETrue, KStartNotifierL2 );

    notiwrap->CancelNotifier( KUid1 );

    notiwrap->CancelNotifier( KUid2 );

    AssertTrueL( ETrue, KCancelNotifier );