/*

* Copyright (c) 2002-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:  This class handles the communication between server and

*                user interface

*

*/

// INCLUDE FILES

#include    <aknenv.h>

#include    <StringLoader.h>

#include    <SatUi.rsg>

#include    <e32test.h>

#include    <msatuiadapter.h>

#include    <AknIconArray.h>                //for itemsicon

#include    <gulicon.h>                     //for itemsicon

#include    <aknlayout.cdl.h>               //for TAknWindowLineLayout

#include    <aknlayoutscalable_avkon.cdl.h> //for scalable layouts

#include    <AknUtils.h>

#include    <AknIconUtils.h>

#include    <aknnotedialog.h>

#include    "CSatUiActionPerformer.h"

#include    "MSatUiActionImplementer.h"

#include    "csatuiiconhandler.h"

#include    "tflogger.h"

#include    "satui.hrh"

#include    <ProfileEngineSDKCRKeys.h>

#include    <centralrepository.h>

#include    <cenrepnotifyhandler.h>

// General Settings Cen Rep Keys.

#include    <settingsinternalcrkeys.h>

// CONSTANTS

const TInt KSatActiveProfileOffline = 5; // value from ProfileEngine

// PlayTone durations

const TInt64 KSatDur170ms  = 170000;  // 170ms

const TInt64 KSatDur200ms  = 200000;  // 200ms

const TInt64 KSatDur250ms  = 250000;  // 250ms

const TInt64 KSatDur1200ms = 1200000; // 1200ms

// play tone tones

_LIT8( KNetToneSeqNetBusy, "\x00\x11\x05\x4E\x30\x40\x30\x07\x0B" );

_LIT8( KNetToneSeqNetCallWaiting, "\x00\x11\x05\x4E\x14\x40\x3C\x4E\x14\

\x40\x64\x40\x64\x40\x64\x4E\x14\x40\x3C\x4E\x14\x40\x64\x40\x64\x40\x64\

\x07\x0B" );

_LIT8( KNetToneSeqNetCongestion, "\x00\x11\x05\x4E\x14\x40\x14\x07\x0B" );

_LIT8( KNetToneSeqNetSpecialInformation, "\x00\x11\x05\x4F\x21\x50\

\x21\x51\x21\x40\x64\x07\x0B" );

_LIT8( KNetToneSeqDial,"\x00\x11\x05\x4E\xFE\x4E\xFE\x4E\xFE\x4E\xFE\x4E\xFE\

\x4E\xFE\x4E\xFE\x4E\xFE\x07\x0B");

_LIT8( KNetToneSeqRingGoing, "\x00\x11\x05\x4E\x64\x05\x04\x40\x64\06\x07\x0B" );

// General Beep is set for forever duration. Instead of AVKON definition 170ms.

_LIT8( KGeneralBeep, "\x00\x11\x0A\x76\x00\x0B" );

_LIT8( KErrorTone, "\x00\x11\x0A\x6C\x19\x0B" );

_LIT8( KRadioPathNotAvailable, "\x00\x11\x0A\x05\x03\x4E\x14\x40\x14\x06\x0B" );

_LIT8( KRadioPathAck, "\x00\x11\x0A\x02\xFC\x0A\x80\x4E\x14\x0A\x7f\x0B" );

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CSatUiActionPerformer::CSatUiActionPerformer():

    iRefresh( EFalse ),

    iIconSupport( ETrue ),

    iClearScreenEvent( EFalse )

    {

    }

// Symbian OS default constructor can leave.

void CSatUiActionPerformer::ConstructL()

    {

    TFLOGSTRING( "CSatUiActionPerformer::ConstructL called" )

    //Register to Server as subsession

    //If Server is not up, this function call may take time

    iSatSession.ConnectL();

    iSat.RegisterL( iSatSession, this );

    iAdapter = iSat.Adapter();

    if ( !iAdapter )

        {

        User::Leave( KErrNotFound );

        }

    // create icon handler

    iIconHandler = CSatUiIconHandler::NewL();

    //Item icons

    iItemIcons = new ( ELeave ) CAknIconArray( 1 );

    TFLOGSTRING( "CSatUiActionPerformer::ConstructL exit" )

    }

// Two-phased constructor.

CSatUiActionPerformer* CSatUiActionPerformer::NewL()

    {

    TFLOGSTRING( "CSatUiActionPerformer::NewL() called" )

    CSatUiActionPerformer* self = new ( ELeave ) CSatUiActionPerformer;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TFLOGSTRING( "CSatUiActionPerformer::NewL() exit" )

    return self;

    }

// Destructor.

CSatUiActionPerformer::~CSatUiActionPerformer()

    {

    TFLOGSTRING( "CSatUiActionPerformer::~CSatUiActionPerformer() called" )

    iSat.Close();

    iSatSession.Close();

    if ( iItemIcons )

        {

        iItemIcons->ResetAndDestroy();

        delete iItemIcons;

        }

    // delete icon handler

    delete iIconHandler;

    iIconHandler = NULL;

    iActionImplementer = NULL;

    iAdapter = NULL;

    TFLOGSTRING( "CSatUiActionPerformer::~CSatUiActionPerformer() exit" )

    }

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

// CSatUiActionPerformer::SetImplementer

// Sets a pointer to CSatUiViewAppUi object.

// (other items were commented in a header).

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

//

void CSatUiActionPerformer::SetImplementer(

    MSatUiActionImplementer* aImplementer )

    {

    TFLOGSTRING( "CSatUiActionPerformer::SetImplementer calling" )

    iActionImplementer = aImplementer;

    TFLOGSTRING( "CSatUiActionPerformer::SetImplementer exiting" )

    }

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

// CSatUiActionPerformer::Adapter

// Returns a pointer to MSatUiAdapter provided by SatCli.

// (other items were commented in a header).

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

//

MSatUiAdapter* CSatUiActionPerformer::Adapter()

    {

    TFLOGSTRING( "CSatUiActionPerformer::Adapter calling-exiting" )

    return iAdapter;

    }

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

// CSatUiActionPerformer::DisplayTextL

// Checks length of the text and calls method from

// the CSatUiViewAppUi class if the length is OK.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiActionPerformer::DisplayTextL(

    const TDesC& aText,

    const TDesC& aSimApplicationName,

    const TSatIconId& aIconId,

    TBool& aRequestedIconDisplayed,

    const TBool aSustainedText,

    const TTimeIntervalSeconds aDuration,

    const TBool aWaitUserToClear )

    {

    TFLOGSTRING( "CSatUiActionPerformer::DisplayText called" )

    TSatUiResponse response( ESatFailure );

    aRequestedIconDisplayed = ETrue;

    TBool selfExplanatoryIcon( EFalse );

    TInt textLength( aText.Length() );

    if ( ( !textLength ) || ( textLength > RSat::KTextToDisplayMaxSize ) )

        {

        TFLOGSTRING( "CSatUiActionPerformer::DisplayText no text" )

        aRequestedIconDisplayed = EFalse;

        return response;

        }

    CFbsBitmap* iconBitmapDisplayText = NULL;

    iActionImplementer->SetCommandPending( ETrue );

    //if icon is available for command

    if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||

        ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&

        ( iIconSupport ) )

        {

        TFLOGSTRING( "CSatUiActionPerformer::DisplayText have icon" )

        iconBitmapDisplayText = FetchIcon( aIconId.iIdentifier,

                                           EIconDisplayText );

        if ( ESatSelfExplanatory == aIconId.iIconQualifier )

            {

            TFLOGSTRING( "CSatUiActionPerformer::DisplayText self \

                explanatory icon" )

            selfExplanatoryIcon = ETrue;

            }

        }

    //icon not found not shown

    if ( !iconBitmapDisplayText )

        {

        aRequestedIconDisplayed = EFalse;

        }

    iActionImplementer->DispatchTimer( iWait );

    TRAPD( err,

        response = iActionImplementer->DisplayTextL( aText, aSimApplicationName,

            iconBitmapDisplayText, selfExplanatoryIcon,

            aSustainedText, aDuration, aWaitUserToClear );

        );

    if ( err != KErrNone )

        {

        response = ESatFailure;

        aRequestedIconDisplayed = EFalse;

        }

    if ( iActionImplementer->GetEndKey() )

        {

        response = ESatSessionTerminatedByUser;

        iActionImplementer->SetEndKey( EFalse );

        }

    iActionImplementer->SetCommandPending( EFalse );

    TFLOGSTRING2( "CSatUiActionPerformer::DisplayText exit, return: %d", \

        response )

    return response;

    }

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

// CSatUiActionPerformer::GetInkeyL

// Checks type of the input wanted and calls right method

// from the CSatUiViewAppUi class.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiActionPerformer::GetInkeyL(

    const TDesC& aText,

    const TSatCharacterSet aCharacterSet,

    TChar& aInput,

    const TBool /*aHelpIsAvailable*/,

    const TSatIconId& aIconId,

    TBool& aRequestedIconDisplayed,

    TUint& aDuration,

    const TBool aImmediateDigitResponse )

    {

    TFLOGSTRING( "CSatUiActionPerformer::GetInkey called" )

    TSatUiResponse response( ESatSuccess );

    aRequestedIconDisplayed = EFalse;

    TBuf<1> input;

    if ( aInput.IsAssigned() )

        {

        input.Fill( aInput, 1 );

        }

    if ( ( aCharacterSet == ESatYesNo ) && ( aText.Length() == 0 ) )

        {

        TFLOGSTRING( "CSatUiActionPerformer::GetInkey return ESatFailure" )

        return ESatFailure;

        }

    CFbsBitmap* iconBitmapGetInkey = NULL;

    iActionImplementer->SetCommandPending( ETrue );

    // If icon is available for command

    if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||

        ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&

        ( iIconSupport ) )

        {

        TFLOGSTRING( "CSatUiActionPerformer::GetInkey have icon" )

        TIconCommand iconCommand ( EIconGetInkey );

        if ( ESatYesNo == aCharacterSet )

            {

            iconCommand = EIconGetYesNo;

            }

        iconBitmapGetInkey = FetchIcon( aIconId.iIdentifier,

                iconCommand );

        GetScalableBitmap( iconBitmapGetInkey, iconCommand,

            aRequestedIconDisplayed );

        }

    TBool selfExplanatory( EFalse );

    // Icon is self-explanatory

    if ( ESatSelfExplanatory == aIconId.iIconQualifier )

        {

        selfExplanatory = ETrue;

        }

    iActionImplementer->DispatchTimer( iWait );

    TRAPD( err,

        if ( ESatYesNo == aCharacterSet || aImmediateDigitResponse )

            {

            TFLOGSTRING( "CSatUiActionPerformer::GetInkey digit response" )

            response = iActionImplementer->GetYesNoL( aText, aCharacterSet,

                aInput, iconBitmapGetInkey, selfExplanatory, aDuration,

                aImmediateDigitResponse );

            }

        else //ESatCharSmsDefaultAlphabet, ESatCharUcs2Alphabet, ESatDigitOnly

            {

            TFLOGSTRING( "CSatUiActionPerformer::GetInkey other conditions" )

            response = iActionImplementer->GetInputL(

                aText, aCharacterSet, input, 1, 1, EFalse, ETrue,

                iconBitmapGetInkey, selfExplanatory, aDuration );

            if ( ESatSuccess == response )

                {

                if ( input.Length() )

                    {

                    aInput = input[0];

                    }

                }

            }

        );

    if ( err != KErrNone )

        {

        response = ESatFailure;

        }

    if ( iActionImplementer->GetEndKey() )

        {

        response = ESatSessionTerminatedByUser;

        iActionImplementer->SetEndKey( EFalse );

        }

    iActionImplementer->SetCommandPending( EFalse );

    TFLOGSTRING2( "CSatUiActionPerformer::GetInkey exit, return: %d", \

        response )

    return response;

    }

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

// CSatUiActionPerformer::GetInputL

// Checks type of the input wanted and whether it should be

// hidden and calls right method from the CSatUiViewAppUi class.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiActionPerformer::GetInputL(

    const TDesC& aText,

    const TSatCharacterSet aCharacterSet,

    TDes& aInput,

    const TInt aMinLength,

    const TInt aMaxLength,

    const TBool aHideInput,

    const TBool /*aHelpIsAvailable*/,

    const TSatIconId& aIconId,

    TBool& aRequestedIconDisplayed )

    {

    TFLOGSTRING( "CSatUiActionPerformer::GetInput called" )

    TSatUiResponse response( ESatSuccess );

    aRequestedIconDisplayed = EFalse;

    if ( ( ( aCharacterSet == ESatCharSmsDefaultAlphabet ) ||

         ( aCharacterSet == ESatCharUcs2Alphabet ) ) &&

         ( aHideInput ) )

        {

        TFLOGSTRING( "CSatUiActionPerformer::GetInput return ESatFailure" )

        return ESatFailure;

        }

    CFbsBitmap* iconBitmapGetInput = NULL;

    iActionImplementer->SetCommandPending( ETrue );

    // If icon is available for command

    if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||

        ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&

        ( iIconSupport ) )

        {

        iconBitmapGetInput = FetchIcon( aIconId.iIdentifier, EIconGetInput );

        GetScalableBitmap( iconBitmapGetInput, EIconGetInput,

            aRequestedIconDisplayed );

        }

    TBool selfExplanatory( EFalse );

    // Icon is self-explanatory

    if ( ESatSelfExplanatory == aIconId.iIconQualifier )

        {

        selfExplanatory = ETrue;

        }

    iActionImplementer->DispatchTimer( iWait );

    TUint duration ( 0 );

    TRAPD( err,

        response = iActionImplementer->GetInputL(

            aText, aCharacterSet, aInput, aMinLength, aMaxLength,

            aHideInput, EFalse, iconBitmapGetInput, selfExplanatory,

            duration );

        );

    if ( err != KErrNone )

        {

        TFLOGSTRING2( "CSatUiActionPerformer::GetInput err:%d", err )

        response = ESatFailure;

        aRequestedIconDisplayed = EFalse;

        }

    if ( iActionImplementer->GetEndKey() )

        {

        response = ESatSessionTerminatedByUser;

        iActionImplementer->SetEndKey( EFalse );

        }

    iActionImplementer->SetCommandPending( EFalse );

    TFLOGSTRING2( "CSatUiActionPerformer::GetInput response:%d", response )

    TFLOGSTRING2( "CSatUiActionPerformer::GetInput aRequestedIconDisplayed:%d",

        aRequestedIconDisplayed )

    TFLOGSTRING( "CSatUiActionPerformer::GetInput exit" )

    return response;

    }

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

// CSatUiActionPerformer::SetUpMenuL

// Calls the method from the CSatUiViewAppUi class to show

// a SetUpMenu view.

// (other items were commented in a header).

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

//

TSatUiResponse CSatUiActionPerformer::SetUpMenuL(

    const TDesC& aText,

    const MDesCArray& aMenuItems,

    const CArrayFixFlat<TSatAction>* aMenuItemNextActions,

    const TBool aHelpIsAvailable,

    const TSatIconId& aIconId,

    const CArrayFixFlat<TInt>* aMenuIcons,

    const enum TSatIconQualifier aIconListQualifier,

    const enum TSatSelectionPreference /*aSelectionPreference*/ )

    {

    TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu called" )

    TSatUiResponse response( ESatSuccess );

    TBool selfExplanatoryItems( EFalse );

    CFbsBitmap* iconTitleBitmap = NULL;

    iActionImplementer->SetCommandPending( ETrue );

    if ( !aMenuItems.MdcaCount() ||

        ( KSatActiveProfileOffline == 

            iActionImplementer->ProfileState() ) )

        {

        iActionImplementer->SetCommandPending( EFalse );

        iActionImplementer->ShowNotAvailableNoteL();

        iActionImplementer->CloseSatUI();

        return response;

        }

    //if contextpane icon available for command

    if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||

        ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&

         ( iIconSupport ) )

        {

        iconTitleBitmap = FetchIcon( aIconId.iIdentifier,

                                     EIconSetUpMenuContext );

        GetScalableBitmap( iconTitleBitmap, EIconSetUpMenuContext );

        }

    iItemIcons->ResetAndDestroy();

    TInt iconCount( 0 );

    if ( aMenuIcons )

        {

        iconCount = aMenuIcons->Count();

        }

    //if icons are available for item list

    if ( ( aMenuItems.MdcaCount() == iconCount ) &&

        ( ( aIconListQualifier == ESatSelfExplanatory ) ||

        ( aIconListQualifier == ESatNotSelfExplanatory ) ) &&

        ( iIconSupport ) )

        {

        TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu have icon" )

        if ( aIconListQualifier == ESatSelfExplanatory )

            {

            selfExplanatoryItems = ETrue;

            }

        TBool continueLoop( ETrue );

        TInt count( 0 );      

        for ( count = 0; ( count < iconCount ) && continueLoop; count++ )

            {

            CGulIcon* gulIcon = CGulIcon::NewLC();

            TUint8 itemIconId( STATIC_CAST( TUint8,

                aMenuIcons->operator[]( count ) ) );

            CFbsBitmap* iconItemBitmap = NULL;

            iconItemBitmap = FetchIcon( itemIconId, EIconSetUpMenuItems );