/*

* 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:  Handles LaunchBrowser command

*

*/

#include    <MSatShellController.h>

#include    <cmmanager.h>

#include    <cmconnectionmethod.h>

#include    <cmconnectionmethoddef.h>

#include    <cmpluginpacketdatadef.h>

#include    <cmdestination.h>

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CLaunchBrowserHandler.h"

#include    "SatLog.h"

#include    "MSatSystemState.h"

// The pause constant for checking if BrowserApp has exited.

// This value may be adjusted to ensure the time sequence

const TInt KSatSShortLoopTimeout = 800000; //0.8 sec

// How many times the browser status is checked, when waiting for

// browser shutdown. Total time

// used to check the exiting of browser app is

// KSatSWaitCount * KSatSShortLoopTimeout.

const TInt KSatSWaitCount = 10;

// Invalid PDP type

const TInt KSatInvalidPdpType = -1;

#ifdef _DEBUG

// Class name for error information.

//lint -e752 Accessed in __ASSERT_DEBUG, but lint will not notice it.

_LIT( KLaunchBrowserHandlerName, "CLaunchBrowserHandler" );

#endif

const TInt KSatMaxIPv4AddressLength( 15 );

const TInt KSatMaxIPv6AddressLength( 39 );

const TInt KSatMinIPv4AddressLength( 7 );

const TInt KSatMinIPv6AddressLength( 7 );

const TInt KSatMaxIPv4SegmentCounter( 3 );

const TInt KSatMaxIPv4SegmentLength( 3 );

const TInt KSatIPv4Broadcast( 255 );

const TInt KSatIPv4Network( 0 );

const TInt KSatMaxIPv6SegmentCounter( 7 );

const TInt KSatMaxIPv6SegmentLength( 4 );

const TUint32 KSatLaunchBrowserProxyPortNumber( 80 );

const TUint32 KSatMaxProxyPortNumber( 9999 );

const TUint32 KSatMinProxyPortNumber( 0 );

// Granularity for getting connection methods from CM session

const TUint32 KSatCMGranularity( 5 );

_LIT( KSatAccessPointName, "SAT Launch Browser" );

_LIT( KSatGprsAccessPointName, "internet" );

_LIT( KSatIPv4Delimiter, "." );

_LIT( KSatIPv6Delimiter, ":" );

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

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

// Two-phased constructor.

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

//

CLaunchBrowserHandler* CLaunchBrowserHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::NewL calling" )

    CLaunchBrowserHandler* self = new( ELeave ) CLaunchBrowserHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CLaunchBrowserHandler::~CLaunchBrowserHandler()

    {

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::~CSatSLaunchBrowserHandler \

        calling" )

    if ( iAfterWait.IsStarted() )

        {

        iAfterWait.AsyncStop();

        }

    if ( iAfterTimer )

        {

        iAfterTimer->Cancel();

        delete iAfterTimer;

        iAfterTimer = NULL;

        }

    iWsSession.Close();

    Cancel();

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::~CSatSLaunchBrowserHandler \

        exiting" )

    }

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

// From class MSatCommand.

// Response from the client.

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

//

void CLaunchBrowserHandler::ClientResponse()

    {

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::ClientResponse calling" )

    // TPCmdResult

    iLaunchBrowserRsp.iGeneralResult = RSat::KLaunchBrowserError;

    // TAdditionalInfoType

    iLaunchBrowserRsp.iInfoType = RSat::KNoAdditionalInfo;

    iLaunchBrowserRsp.iAdditionalInfo.Zero();

    iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

    // Perform the action that we just queried the user for.

    if ( iQueryRsp.iAccepted )

        {

        // Launch the Browser.

        TRAPD( err, LaunchBrowserL() );

        if ( KErrNone != err )

            {

            iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            LOG2( SIMPLE, "LAUNCHBROWSER: \

                CLaunchBrowserHandler::ClientResponse error: %i", err )

            }

        else

            {

            LOG( SIMPLE,

                "LAUNCHBROWSER: CLBH::CR ESetUpMenuRequested registered" )

            TRAP_IGNORE( iUtils->RegisterL(

                this, MSatUtils::ESetUpMenuRequested ) )

            }

        }

    else // User denied this action

        {

        iLaunchBrowserRsp.iGeneralResult = RSat::KPCmdNotAcceptedByUser;

        LOG( SIMPLE, "LAUNCHBROWSER: \

            CLaunchBrowserHandler::ClientResponse not accepted" )

        if ( iQueryRsp.iSessionTerminatedByUser )

            {

            LOG( SIMPLE, "LAUNCHBROWSER: \

                 CLaunchBrowserHandler::ClientResponse close ui session" )

            // Next SimSession end will close the ui session

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            }

        }

    // If command had icon data and was done succesfully, report that icon

    // was not shown

    // To be removed when icons are allowed in this command

    if ( ( RSat::KSuccess == iLaunchBrowserRsp.iGeneralResult ) &&

        iIconCommand )

        {

        LOG( SIMPLE, "LAUNCHBROWSER: \

                 CLaunchBrowserHandler::ClientResponse icon not display" )

        iLaunchBrowserRsp.iGeneralResult =

            RSat::KSuccessRequestedIconNotDisplayed;

        }

    TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::ClientResponse exiting" )

    }

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

// From class CSatCommandHandler.

// Event notification

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

//

void CLaunchBrowserHandler::Event( TInt aEvent )

    {

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::Event calling" )

    switch ( aEvent )

        {

        // SetUpMenu is listening by SAT Client.

        case MSatUtils::ESetUpMenuRequested:

            {

            LOG( NORMAL,

                "LAUNCHBROWSER::Event ESetUpMenuRequested catched and unreg" )

            iUtils->UnregisterEvent( this, MSatUtils::ESetUpMenuRequested );

            // Browser is brought to the top after short period of time.

            break;

            }

        default:

            {

            LOG2( NORMAL, "LAUNCHBROWSER:   Unexpected event: %i", aEvent )

            CSatCommandHandler::Event( aEvent );

            }

        }

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::Event exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CLaunchBrowserHandler::DoCancel()

    {

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::DoCancel calling" )

    iUtils->USatAPI().NotifyLaunchBrowserCancel();

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CLaunchBrowserHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::IssueUSATRequest calling" )

    // Clear the IPC package.

    new (&iLaunchBrowserData) RSat::TLaunchBrowserV2();

    iQueryRsp.iAccepted = EFalse; // default

    iUtils->USatAPI().NotifyLaunchBrowser( aStatus, iLaunchBrowserPckg );

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// Precheck before executing the command.

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

//

TBool CLaunchBrowserHandler::CommandAllowed()

    {

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed calling" )

    iLaunchBrowserRsp.iGeneralResult = RSat::KLaunchBrowserError;

    iLaunchBrowserRsp.iInfoType = RSat::KNoAdditionalInfo;

    iLaunchBrowserRsp.iAdditionalInfo.Zero();

    RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

        iUtils->SystemState().GetNetworkRegistrationStatus() );

    TBool commandAllowed( ETrue );

    if ( RSat::EBrowserIdNotSpecified == iLaunchBrowserData.iBrowserId )

        {

        // When get unknown browser id, such as RFU value, return

        // terminal response of command not understood.

        iLaunchBrowserRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        commandAllowed = EFalse;

        LOG( SIMPLE, "LAUNCHBROWSER: \

            CLaunchBrowserHandler::CommandAllowed unknown browser id" )

        }

    else if ( ( RSat::EAlphaIdProvided !=

        iLaunchBrowserData.iAlphaId.iStatus ) &&

        ( RSat::ESelfExplanatory ==

            iLaunchBrowserData.iIconId.iQualifier ||

          RSat::ENotSelfExplanatory ==

            iLaunchBrowserData.iIconId.iQualifier ) )

        {

        iLaunchBrowserRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        commandAllowed = EFalse;

        LOG( SIMPLE, "LAUNCHBROWSER: \

            CLaunchBrowserHandler::CommandAllowed icon without alpha id" )

        }

    else if (

        ( RMobilePhone::ERegisteredOnHomeNetwork != registrationStatus ) &&

        ( RMobilePhone::ERegisteredRoaming != registrationStatus ) )

        {

        iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

        iLaunchBrowserRsp.iAdditionalInfo.SetLength( 1 );

        iLaunchBrowserRsp.iAdditionalInfo[0] = RSat::KNoService;

        commandAllowed = EFalse;

        LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed\

             MS is out of service (Net. Reg. status wrong)" )

        }

    else if ( RSat::EBrowserSelectionNotSet == iLaunchBrowserData.iBrowserSel )

        {

        iLaunchBrowserRsp.iGeneralResult = RSat::KCmdTypeNotUnderstood;

        commandAllowed = EFalse;

        LOG( SIMPLE, "LAUNCHBROWSER: \

            CLaunchBrowserHandler::CommandAllowed selection not set" )

        }

    else if ( RSat::ELaunchBrowserIfNotAlreadyLaunched ==

        iLaunchBrowserData.iBrowserSel )

        {

        if ( BrowserExists() )

            {

            iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

            iLaunchBrowserRsp.iAdditionalInfo.Append( 

                RSat::KBrowserUnavailable );

            commandAllowed = EFalse;

            LOG( SIMPLE, "LAUNCHBROWSER: \

                CLaunchBrowserHandler::CommandAllowed not launched" )

            }

        }

    else

        {

        LOG( SIMPLE,

            "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed ok" )

        }

    if ( !commandAllowed )

        {

        LOG( SIMPLE,

            "CLaunchBrowserHandler::CommandAllowed commandAllowed false" )

        iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

        TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

        }

    // Set icon command flag whether icon data was received and set qualifier

    // to no icon id

    // To be removed when icons are allowed in this command

    else if ( ( RSat::ESelfExplanatory ==

        iLaunchBrowserData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory ==

        iLaunchBrowserData.iIconId.iQualifier ) )

        {

         LOG( SIMPLE,

            "CLaunchBrowserHandler::CommandAllowed commandAllowed ENoIconId" )

        iIconCommand = ETrue;

        iLaunchBrowserData.iIconId.iQualifier = RSat::ENoIconId;

        }

    else

        {

        iIconCommand = EFalse;

        }

    LOG2( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed exiting, \

         commandAllowed: %d", commandAllowed )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Answers for need of UI session.

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

//

TBool CLaunchBrowserHandler::NeedUiSession()

    {

    LOG( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession calling" )

    const RSat::TAlphaId alphaId( iLaunchBrowserData.iAlphaId );

    iNeedUiSession = ETrue;

    if ( ( ( alphaId.iStatus == RSat::EAlphaIdProvided &&

        alphaId.iAlphaId.Length() == 0 ) ||

        alphaId.iStatus == RSat::EAlphaIdNull ) &&

        ( !iUtils->SystemState().IsConfirmSatOperationsOn() ) )

        {

        iNeedUiSession = EFalse;

        LOG( NORMAL,

            "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession no  \

            Ui session needed" )

        }

    if ( iUtils->CoverUiSupported() && iNeedUiSession )

        {

        LOG( NORMAL,

            "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession Ui session \

            needed" )

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ELaunchBrowser;

        medEventData.iAlphaId = iLaunchBrowserData.iAlphaId;

        if ( iUtils->SystemState().IsConfirmSatOperationsOn() )

            {

            LOG( NORMAL,

            "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession \

             KSatLongDuration" )

            medEventData.iDuration.iNumOfUnits = KSatLongDuration;

            }

        else

            {

            medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

            }

        medEventData.iDuration.iTimeUnit = RSat::ESeconds;

        medEventData.iIconID = iLaunchBrowserData.iIconId;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG2( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession exiting, \

         iNeedUiSession: %d", iNeedUiSession )

    return iNeedUiSession;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CLaunchBrowserHandler::HandleCommand()

    {

    LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::HandleCommand calling" )

    // Register service request handler for LaunchBrowser command,

    // If there is already service request for query, registering

    // updates command handler, so client responses comes to this

    // command handler

    TRAPD( err, iUtils->RegisterServiceRequestL(

        ESatSProactiveQuery,

        ESatSProactiveQueryResponse,

        this ) );

    if ( KErrNone != err )

        {

        iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

        iLaunchBrowserRsp.iAdditionalInfo.SetLength( 1 );

        iLaunchBrowserRsp.iAdditionalInfo[0] = RSat::KNoSpecificMeProblem;

        iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

        TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

        LOG2( SIMPLE,

        "LAUNCHBROWSER: CLaunchBrowserHandler::HandleCommand error: %i", err )

        }

    else if ( iNeedUiSession )

        {

        iQueryData.iCommand = ESatSLaunchBrowserQuery;

        iQueryData.iQueryText = iLaunchBrowserData.iAlphaId.iAlphaId;

        iQueryData.iIconId.iIdentifier =

            iLaunchBrowserData.iIconId.iIdentifier;

        LOG2( SIMPLE, "CLaunchBrowserHandler::HandleCommand \

              iLaunchBrowserData.iIconId.iQualifier: %i", 

              iLaunchBrowserData.iIconId.iQualifier )

        switch ( iLaunchBrowserData.iIconId.iQualifier )

            {

            case RSat::ESelfExplanatory:

                {

                // Icon qualifier is self explanatory (to display instead

                // of the alpha id or text string).

                iQueryData.iIconId.iIconQualifier = ESatSelfExplanatory;

                break;

                }

            case RSat::ENotSelfExplanatory:

                {

                // Icon qualifier is not self explanatory.

                iQueryData.iIconId.iIconQualifier = ESatNotSelfExplanatory;

                break;

                }

            default:

                {

                // Icon qualifier not present

                iQueryData.iIconId.iIconQualifier = ESatENoIconId;

                break;

                }

            }

        if ( RSat::EAlphaIdNotPresent == iLaunchBrowserData.iAlphaId.iStatus )

            {

            LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::HandleCommand \

                 EAlphaIdNotPresent" )

            iQueryData.iAlphaIdStatus = ESatAlphaIdNotProvided;

            }

        else if ( RSat::EAlphaIdProvided ==

            iLaunchBrowserData.iAlphaId.iStatus )

            {

            LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::HandleCommand \

                 EAlphaIdProvided" )

            iQueryData.iAlphaIdStatus = ESatAlphaIdNotNull;

            }

        else

            {

            iQueryData.iAlphaIdStatus = ESatAlphaIdNull;

            }

        iQueryData.iSimApplicationName = iUtils->SatAppName();

        // Ask the user permission to launch browser. Reply will come

        // to ClientResponse() method.

        iUtils->SatUiHandler().UiSession()->SendCommand(

            &iQueryPckg,

            &iQueryRspPckg,

            ESatSProactiveQuery );

        }

    else // transparent launch

        {

        // Launch the Browser.

        TRAP( err, LaunchBrowserL() );

        if ( KErrNone != err )

            {

            iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;