/*

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

*                user interface

*

*/

// INCLUDE FILES

#include    <e32test.h>

#include    <msatuiadapter.h>

#include    <ProfileEngineSDKCRKeys.h>

#include    <centralrepository.h>

#include    <settingsinternalcrkeys.h>

#include    <gulicon.h> //for itemsicon

#include    <fbs.h>

#include    "csatuiobserver.h"

#include    "msatuiactionimplementer.h"

#include    "csatuiiconhandler.h"

#include    "tflogger.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 =========================================

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

// CSatUiObserver::CSatUiObserver

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

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

//

CSatUiObserver::CSatUiObserver():

    iRefresh(EFalse),

    iIconSupport(ETrue),

    iClearScreenEvent(EFalse)

    {

    }

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

// CSatUiObserver::ConstructL

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

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

//

void CSatUiObserver::ConstructL()

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::ConstructL called")

    TFLOGSTRING("SATAPP: CSatUiObserver::ConstructL exit")

    }

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

// CSatUiObserver::NewL

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

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

//

CSatUiObserver* CSatUiObserver::NewL()

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::NewL() called")

    CSatUiObserver* self = new (ELeave) CSatUiObserver;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TFLOGSTRING("SATAPP: CSatUiObserver::NewL() exit")

    return self;

    }

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

// CSatUiObserver::~CSatUiObserver

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

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

//

CSatUiObserver::~CSatUiObserver()

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::~CSatUiObserver() called")

    iActionImplementer = NULL;

    iAdapter = NULL;

    TFLOGSTRING("SATAPP: CSatUiObserver::~CSatUiObserver() exit")

    }

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

// CSatUiObserver::SetImplementer

// Sets a pointer to CSatUiViewAppUi object.

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

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

//

void CSatUiObserver::SetImplementer(

    MSatUiActionImplementer* aImplementer)

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::SetImplementer calling")

    iActionImplementer = aImplementer;

    TFLOGSTRING("SATAPP: CSatUiObserver::SetImplementer exiting")

    }

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

// CSatUiObserver::Adapter

// Returns a pointer to MSatUiAdapter provided by SatCli.

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

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

//

MSatUiAdapter* CSatUiObserver::Adapter()

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::Adapter calling-exiting")

    return iAdapter;

    }

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

// CSatUiObserver::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 CSatUiObserver::DisplayTextL(

    const TDesC& aText,

    const TDesC& aSimApplicationName,

    const TSatIconId& aIconId,

    TBool& aRequestedIconDisplayed,

    const TBool aSustainedText,

    const TTimeIntervalSeconds aDuration,

    const TBool aWaitUserToClear)

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::DisplayText called")

    TSatUiResponse response(ESatFailure);

    aRequestedIconDisplayed = ETrue;

    TBool selfExplanatoryIcon(EFalse);

    TInt textLength(aText.Length());

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

        {

        TFLOGSTRING("SATAPP: CSatUiObserver::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("SATAPP: CSatUiObserver::DisplayText have icon")

        iconBitmapDisplayText = FetchIcon(aIconId.iIdentifier,

                                           EIconDisplayText);

        if (ESatSelfExplanatory == aIconId.iIconQualifier)

            {

            TFLOGSTRING("SATAPP: CSatUiObserver::DisplayText self \

                explanatory icon")

            selfExplanatoryIcon = ETrue;

            }

        }

    //icon not found not shown

    if (!iconBitmapDisplayText)

        {

        aRequestedIconDisplayed = EFalse;

        }

    iActionImplementer->DispatchTimer(iWait);

    TFLOGSTRING2("CSatUiObserver::DisplayTextL aDuration: %d", aDuration.Int())

    TRAPD(err,

        response = iActionImplementer->DisplayTextL(aText, aSimApplicationName,

            iconBitmapDisplayText, selfExplanatoryIcon,

            aSustainedText, aDuration, aWaitUserToClear);

       );

        {

        response = ESatFailure;

        aRequestedIconDisplayed = EFalse;

        }

        {

        response = ESatSessionTerminatedByUser;

        }

    TFLOGSTRING2("SATAPP: CSatUiObserver::DisplayText exit, return: %d", \

        response)

    return response;

    }

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

// CSatUiObserver::GetInkeyL

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

// from the CSatUiViewAppUi class.

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

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

//

TSatUiResponse CSatUiObserver::GetInkeyL(

    const TDesC& aText,

    const TSatCharacterSet aCharacterSet,

    TChar& aInput,

    const TBool /*aHelpIsAvailable*/,

    const TSatIconId& aIconId,

    TBool& aRequestedIconDisplayed,

    TUint& aDuration,

    const TBool aImmediateDigitResponse)

    {

    TFLOGSTRING("SATAPP: CSatUiObserver::GetInkey called")

    TSatUiResponse response(ESatSuccess);

    aRequestedIconDisplayed = EFalse;

    TBuf<1> input;

    if (aInput.IsAssigned())

        {

        input.Fill(aInput, 1);

        }

        {

        TFLOGSTRING("SATAPP: CSatUiObserver::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("SATAPP: CSatUiObserver::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("SATAPP: CSatUiObserver::GetInkey digit response")

            response = iActionImplementer->GetYesNoL(aText, aCharacterSet,

                aInput, iconBitmapGetInkey, selfExplanatory, aDuration,

                aImmediateDigitResponse);

            }

        else //ESatCharSmsDefaultAlphabet, ESatCharUcs2Alphabet, ESatDigitOnly

            {

            TFLOGSTRING("SATAPP: CSatUiObserver::GetInkey other conditions")

            response = iActionImplementer->GetInputL(

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

                iconBitmapGetInkey, selfExplanatory, aDuration);

                {

                }

            }

       );

        {

        response = ESatFailure;

        }

    if (iActionImplementer->GetEndKey())

        {

        response = ESatSessionTerminatedByUser;

        iActionImplementer->SetEndKey(EFalse);

        }

    iActionImplementer->SetCommandPending(EFalse);

    TFLOGSTRING2("SATAPP: CSatUiObserver::GetInkey exit, return: %d", \

        response)

    return response;

    }

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

// CSatUiObserver::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 CSatUiObserver::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("SATAPP: CSatUiObserver::GetInput called")

    TSatUiResponse response(ESatSuccess);

    aRequestedIconDisplayed = EFalse;

    if (((aCharacterSet == ESatCharSmsDefaultAlphabet) ||

         (aCharacterSet == ESatCharUcs2Alphabet)) &&

         (aHideInput))

        {

        TFLOGSTRING("SATAPP: CSatUiObserver::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);

       );

        {

        TFLOGSTRING2("SATAPP: CSatUiObserver::GetInput err:%d", err)

        response = ESatFailure;

        aRequestedIconDisplayed = EFalse;

        }

    if (iActionImplementer->GetEndKey())

        {

        response = ESatSessionTerminatedByUser;

        iActionImplementer->SetEndKey(EFalse);

        }

    iActionImplementer->SetCommandPending(EFalse);

    TFLOGSTRING2("SATAPP: CSatUiObserver::GetInput response:%d", response)

    TFLOGSTRING2("SATAPP: CSatUiObserver::GetInput aRequestedIconDisplayed:%d",

        aRequestedIconDisplayed)

    TFLOGSTRING("SATAPP: CSatUiObserver::GetInput exit")

    return response;

    }

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

// CSatUiObserver::SetUpMenuL

// Calls the method from the CSatUiViewAppUi class to show

// a SetUpMenu view.

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

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

//

TSatUiResponse CSatUiObserver::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("SATAPP: CSatUiObserver::SetUpMenu called")

    TSatUiResponse response(ESatSuccess);

    TBool selfExplanatoryItems(EFalse);

    CFbsBitmap* iconTitleBitmap = NULL;

    iActionImplementer->SetCommandPending(ETrue);

    TFLOGSTRING2("SATAPP: CSatUiObserver::SetUpMenu item count: %d",

     aMenuItems.MdcaCount())

    if (!aMenuItems.MdcaCount() ||

        (KSatActiveProfileOffline == ProfileState()))

        {

        iActionImplementer->SetCommandPending(EFalse);

        iActionImplementer->ShowNotAvailableNoteL();

        iActionImplementer->CloseSatUI();

        return response;

        }

    //if contextpane icon available for command

    TFLOGSTRING2("SATAPP: CSatUiObserver::SetUpMenu icon qua: %d",

     aIconId.iIconQualifier)

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

        (ESatNotSelfExplanatory == aIconId.iIconQualifier)) &&

         (iIconSupport))

        {

        iconTitleBitmap = FetchIcon(aIconId.iIdentifier,

                                     EIconSetUpMenuContext);

        GetScalableBitmap(iconTitleBitmap, EIconSetUpMenuContext);

        }

    TInt iconCount(0);

    if (aMenuIcons)

        {

        iconCount = aMenuIcons->Count();

        TFLOGSTRING2("SATAPP: CSatUiObserver::SetUpMenu icon count: %d", iconCount)

        }

    //if icons are available for item list

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

        ((aIconListQualifier == ESatSelfExplanatory) ||

        (aIconListQualifier == ESatNotSelfExplanatory)) &&

        (iIconSupport))

        {

        TFLOGSTRING("SATAPP: CSatUiObserver::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);

            if (!iconItemBitmap &&

                {

                TFLOGSTRING("SATAPP: CSatUiObserver::SetUpMenu \

                    SelfExplanatory ")

                CleanupStack::PopAndDestroy(gulIcon); // gulIcon

                continueLoop = EFalse;

                }

            else

                {

                if (!iconItemBitmap &&

                    {

                    TFLOGSTRING("SATAPP: CSatUiObserver::SetUpMenu \

                        not SelfExplanatory ")

                    iconItemBitmap = new(ELeave)CFbsBitmap();

                    }

                else

                    {

                    TFLOGSTRING("SATAPP: CSatUiObserver::SetUpMenu \

                        other conditions ")

                    GetScalableBitmap(iconItemBitmap, EIconSetUpMenuItems);

                    }

                gulIcon->SetBitmap(iconItemBitmap);

                CleanupStack::Pop(gulIcon);

                }

            }

        TFLOGSTRING2("SATAPP: CSatUiObserver::SetUpMenu count: %d", count)