/*
* Copyright (c) 2002-2008 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 is the handler for the SIM Application Toolkit
*                Select Item proactive command.
*
*/


#include    <e32svr.h>
#include    <basched.h>
#include    "RSatUiSession.h"
#include    "MSatUiObserver.h"
#include    "SatSOpcodes.h"
#include    "CSatCSelectItemHandler.h"
#include    "SatLog.h"

const TInt8 KMenuItemPop( 3 );

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

// -----------------------------------------------------------------------------
// CSatCSelectItemHandler::CSatCSelectItemHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSatCSelectItemHandler::CSatCSelectItemHandler(
    TInt aPriority,
    RSatUiSession* aSession ) :
    CActive( aPriority ),
    iSession( aSession ),
    iSelectItemData(),
    iSelectItemPckg( iSelectItemData ),
    iSelectItemRsp(),
    iSelectItemRspPckg( iSelectItemRsp )
    {
    LOG( SIMPLE,
        "SATINTERNALCLIENT: CSatCSelectItemHandler::CSatCSelectItemHandler calling" )

    // Add to active scheduler.
    CActiveScheduler::Add( this );

    LOG( SIMPLE,
        "SATINTERNALCLIENT: CSatCSelectItemHandler::CSatCSelectItemHandler exiting" )
    }

// -----------------------------------------------------------------------------
// CSatCSelectItemHandler::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSatCSelectItemHandler* CSatCSelectItemHandler::NewL(
    RSatUiSession* aSat )
    {
    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::NewL calling" )

    // Perform the construction.
    CSatCSelectItemHandler* self =
        new ( ELeave ) CSatCSelectItemHandler( EPriorityLow, aSat );

    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::NewL exiting" )
    return self;
    }

// Destructor
CSatCSelectItemHandler::~CSatCSelectItemHandler()
    {
    LOG( SIMPLE,
        "SATINTERNALCLIENT: CSatCSelectItemHandler::~CSatCSelectItemHandler calling" )

    // Cancel any outstanding requests.
    Cancel();
    iSession = NULL;

    LOG( SIMPLE,
        "SATINTERNALCLIENT: CSatCSelectItemHandler::~CSatCSelectItemHandler exiting" )
    }

// -----------------------------------------------------------------------------
// CSatCSelectItemHandler::Start
// Starts the handler.
// -----------------------------------------------------------------------------
//
void CSatCSelectItemHandler::Start()
    {
    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::Start calling" )

    // Empty the IPC data
    RSat::TSelectItemV2 temp;
    iSelectItemData = temp;
    RSat::TSelectItemRspV1 temp2;
    iSelectItemRsp = temp2;

    // Request Select Item notification.
    TIpcArgs arguments( &iSelectItemPckg );

    // Pass the Select Item IPC package.
    iSession->CreateRequest( ESatSProactiveSelectItem, arguments, iStatus );

    // Set this handler to active so that it can receive requests.
    SetActive();

    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::Start exiting" )
    }

// -----------------------------------------------------------------------------
// CSatCSelectItemHandler::RunL
// Handles the command.
// -----------------------------------------------------------------------------
//
void CSatCSelectItemHandler::RunL()
    {
    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL calling" )

    // Check the status of the asnychronous operation
    if ( KErrNone != iStatus.Int() )
        {
        LOG2(
            SIMPLE,
            "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL error: %d",
            iStatus.Int() )

        // Renew the request
        Start();
        }
    else
        {
        // Create the menu item array.
        CDesC16ArrayFlat* menuItems = new( ELeave ) CDesC16ArrayFlat( 1 );
        CleanupStack::PushL( menuItems );

        // Create the next action indicator array.
        CArrayFixFlat<TSatAction>* menuActions =
            new( ELeave ) CArrayFixFlat<TSatAction>( 1 );
        CleanupStack::PushL( menuActions );

        // Create the menu item icon array.
        CArrayFixFlat<TInt>* menuIcons =
            new( ELeave ) CArrayFixFlat<TInt>( 1 );
        CleanupStack::PushL( menuIcons );

        // Fetch all the menu items.
        // Note that the indexing starts from 1 in SIM item lists.
        // This is the default menu item.
        TInt defaultItem( 0 );
        TBool defaultItemIdFound( EFalse );

        const TInt numberOfItems( static_cast<TInt>(
            iSelectItemData.NumberOfItems() ) );
            
        LOG2( SIMPLE,
        "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL numberOfItems: %d",
        numberOfItems )
        for ( TInt currentItem = 1; currentItem <= numberOfItems; currentItem++ )
            {
            RSat::TItem item;
            TInt action;
            TInt icon( KErrNotFound );

            // Fetch all data for this index.
            iSelectItemData.GetItem( static_cast<TUint>( currentItem ),
                                     item, action, icon );

            if ( item.iItemId == iSelectItemData.iDefaultItemId )
                {
                LOG( SIMPLE, 
                "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL has defaultItemId" )
                defaultItem = currentItem - 1;
                defaultItemIdFound = ETrue;
                }

            // Save the item name
            menuItems->AppendL( item.iItemString );

            // Save icon identifier.
            // icon will be KErrNotFound (-1) if it is not present in the
            // SAT menu.
            menuIcons->AppendL( icon );
            LOG2( SIMPLE,
            "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL action: %d", action )
            if ( KErrNotFound != action )
                {
                // Save the next action indicator, if found.
                menuActions->AppendL( STATIC_CAST( TSatAction, action ) );
                }
            }

        // Do not return partial comprehension response when
        // default item is not set.
        if ( !iSelectItemData.iDefaultItemId )
            {
            LOG( SIMPLE, 
            "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL \
            iSelectItemData.iDefaultItemId false" )
            defaultItemIdFound = ETrue;
            }

        // This will contain the user selection.
        TUint8 selection;

        // Indicates whether help is available
        TBool helpIsAvailable( EFalse );
        if ( iSelectItemData.iHelp == RSat::EHelpAvailable )
            {
            LOG( SIMPLE, 
            "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL EHelpAvailable" )
            helpIsAvailable = ETrue;
            }

        // Has to be casted to TInt before casting to TSatIconQualifier,
        // because gcc warns about the direct cast.
        const struct TSatIconId iconId = { iSelectItemData.iIconId.iIdentifier,
            static_cast<TSatIconQualifier>(
                static_cast<TInt>( iSelectItemData.iIconId.iQualifier ) ) };

        const enum TSatIconQualifier iconListQualifier(
            static_cast<TSatIconQualifier>(
                static_cast<TInt>( iSelectItemData.iIconListQualifier ) ) );

        const enum TSatSelectionPreference selectionPreference(
            static_cast<TSatSelectionPreference>(
                static_cast<TInt>( iSelectItemData.iPreference ) ) );

        // This will contain EFalse if requested icon is not displayed.
        TBool requestedIconDisplayed( ETrue );

        // About lint e64:
        // Error in lint was MDesC8Array = CDesC16ArrayFlat, which
        // is not the case.
        // Notify the registered client and save the response.
        //lint -e{64}
        TSatUiResponse response = iSession->SatUiObserver()->SelectItemL(
            iSelectItemData.iAlphaId.iAlphaId,
            *menuItems,
            menuActions,
            defaultItem,
            selection,
            helpIsAvailable,
            iconId,
            menuIcons,
            iconListQualifier,
            requestedIconDisplayed,
            selectionPreference );

        // By default, this command does not have additional information.
        iSelectItemRsp.iInfoType = RSat::KNoAdditionalInfo;
        iSelectItemRsp.iAdditionalInfo.Zero();

        // must use the same pcmd
        iSelectItemRsp.SetPCmdNumber( iSelectItemData.PCmdNumber() );

        // Examine the client response.
        ExamineClientResponse(
            response, selection, requestedIconDisplayed, defaultItemIdFound );

        // Pass the Select Item response package.
        TIpcArgs arguments( &iSelectItemRspPckg );

        // Perform the IPC data transfer.
        iSession->CreateRequest( ESatSProactiveSelectItemResponse, arguments );

        // Destroy the array objects: menuIcons, menuActions, menuItems.
        CleanupStack::PopAndDestroy( KMenuItemPop, menuItems );

        // Renew the service request.
        Start();
        }

    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::RunL exiting" )
    }

// -----------------------------------------------------------------------------
// CSatCSelectItemHandler::ExamineClientResponse
// Examine the client response.
// -----------------------------------------------------------------------------
//
void CSatCSelectItemHandler::ExamineClientResponse(
    TSatUiResponse aResponse,
    TUint8 aSelection,
    TBool aRequestedIconDisplayed,
    TBool aDefaultItemIdFound )
    {
    LOG2( SIMPLE,
    "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse calling,\
    aResponse: %x", aResponse )

    // Examine the client response.
    switch ( aResponse )
        {
        case ESatSuccess:
            {
            // Convert terminal rsp if icon used
            RSat::TPCmdResult result( RSat::KSuccess );
            RSat::TIconQualifier iconQualifier(
                    iSelectItemData.iIconId.iQualifier );

            //lint -e{961} Else block meaningless
            if ( iSelectItemData.iDefaultItemId && !aDefaultItemIdFound )
                {
                LOG( SIMPLE,
                "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse \
                KPartialComprehension" )
                result = RSat::KPartialComprehension;
                }
            else if ( !aRequestedIconDisplayed )
                {
                LOG( SIMPLE,
                "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse \
                aRequestedIconDisplayed false" )
                if ( iconQualifier == RSat::ESelfExplanatory ||
                     iconQualifier == RSat::ENotSelfExplanatory )
                    {
                    LOG( SIMPLE,
                    "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse \
                    IconNotDisplayed" )
                    result = RSat::KSuccessRequestedIconNotDisplayed;
                    }
                }

            iSelectItemRsp.iGeneralResult = result;

            // Change the additional information type.
            iSelectItemRsp.iInfoType = RSat::KItemIdentifier;

            // Search for the correct item ID.
            // Underflow not possible due to selection
            // being of type TUint8
            if ( aSelection > iSelectItemData.NumberOfItems() - 1 )
                {
                LOG( SIMPLE,
                "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse \
                ESatSuccess ESelectedItemOutOfRange" )
                iSession->Panic( ESelectedItemOutOfRange );
                }

            // Get the item with the desired index.
            RSat::TItem item;
            iSelectItemData.GetItem( aSelection + 1, item );

            // Save the index of the item selected by the user.
            iSelectItemRsp.iAdditionalInfo.SetLength( 1 );
            iSelectItemRsp.iAdditionalInfo[0] = item.iItemId;
            break;
            }
        // Otherwise, just return the response.
        case ESatFailure:
            {
            iSelectItemRsp.iInfoType = RSat::KMeProblem;
            iSelectItemRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;
            iSelectItemRsp.iAdditionalInfo.SetLength( 1 );
            iSelectItemRsp.iAdditionalInfo[0] = RSat::KNoSpecificMeProblem;
            break;
            }
        case ESatSessionTerminatedByUser:
            {
            iSelectItemRsp.iGeneralResult = RSat::KPSessionTerminatedByUser;
            break;
            }
        case ESatBackwardModeRequestedByUser:
            {
            iSelectItemRsp.iGeneralResult =
                RSat::KBackwardModeRequestedByUser;
            break;
            }
        case ESatNoResponseFromUser:
            {
            iSelectItemRsp.iGeneralResult = RSat::KNoResponseFromUser;
            break;
            }
        case EHelpRequestedByUser:
            {
            iSelectItemRsp.iGeneralResult = RSat::KHelpRequestedByUser;

            // Change the additional information type.
            iSelectItemRsp.iInfoType = RSat::KItemIdentifier;

            // Search for the correct item ID.
            // Underflow not possible due to selection
            // being of type TUint8
            if ( aSelection > iSelectItemData.NumberOfItems() - 1 )
                {
                LOG( SIMPLE,
                "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse \
                EHelpRequestedByUser ESelectedItemOutOfRange" )
                iSession->Panic( ESelectedItemOutOfRange );
                }

            // Get the item with the desired index.
            RSat::TItem item;
            iSelectItemData.GetItem( aSelection + 1, item );

            // Save the index of the item selected by the user.
            iSelectItemRsp.iAdditionalInfo.SetLength( 1 );
            iSelectItemRsp.iAdditionalInfo[0] = item.iItemId;
            break;
            }
        case EPCmdNotAcceptedByUser:
        case ESatCmdDataNotUnderstood:
        default:
            {
            iSession->Panic( ESatInvalidResponse );
            break;
            }
        }

    LOG( SIMPLE,
        "SATINTERNALCLIENT: CSatCSelectItemHandler::ExamineClientResponse exiting" )
    }

// -----------------------------------------------------------------------------
// CSatCSelectItemHandler::DoCancel
// Cancels the pending request.
// -----------------------------------------------------------------------------
//
void CSatCSelectItemHandler::DoCancel()
    {
    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::DoCancel calling" )

    // Complete the request with cancel code.
    TRequestStatus* requestStatus = &iStatus;
    User::RequestComplete( requestStatus, KErrCancel );

    LOG( SIMPLE, "SATINTERNALCLIENT: CSatCSelectItemHandler::DoCancel exiting" )
    }