// 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:

// Name        : CSatNotifyLaunchBrowser.cpp

// Part of     : Common SIM ATK TSY / commonsimatktsy

// LaunchBrowser notification functionality of Sat Tsy

// Version     : 1.0

//

//INCLUDES

#include <satcs.h>                  // Etel SAT IPC definitions

#include "CSatTsy.h"                // Tsy class header

#include "CSatNotifyLaunchBrowser.h"// Tsy class header

#include "CSatNotificationsTsy.h"   // Class header

#include "CBerTlv.h"                // Ber Tlv data handling

#include "TTlv.h"					// TTlv class

#include "CSatDataPackage.h"        // Parameter packing 

#include "TSatUtility.h"            // Utilities

#include "CSatTsyReqHandleStore.h"  // Request handle class

#include "cmmmessagemanagerbase.h"  // Message manager class for forwarding req.

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

// CSatNotifyLaunchBrowser::NewL

// Two-phased constructor.

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

//  

CSatNotifyLaunchBrowser* CSatNotifyLaunchBrowser::NewL

        ( 

        CSatNotificationsTsy* aNotificationsTsy 

        )

    {

   	CSatNotifyLaunchBrowser* const satNotifyLaunchBrowser = 

        new ( ELeave ) CSatNotifyLaunchBrowser( aNotificationsTsy );

    CleanupStack::PushL( satNotifyLaunchBrowser );

    satNotifyLaunchBrowser->ConstructL();

    CleanupStack::Pop( satNotifyLaunchBrowser );

    return satNotifyLaunchBrowser;

    }

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

// CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser

// Destructor

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

//  

CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser

        ( 

		// None

        )

    {

    }

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

// CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser

// Default C++ constructor

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

//  

CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser

        ( 

        CSatNotificationsTsy* aNotificationsTsy 

        ) : iNotificationsTsy ( aNotificationsTsy )

    {

    // None

    }

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

// CSatNotifyLaunchBrowser::ConstructL

// Symbian 2nd phase constructor

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

//  

void CSatNotifyLaunchBrowser::ConstructL

        (

        // None

        )

    {

    iSsStatus = CSatNotificationsTsy::ENotBusy;

    }

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

// CSatNotifyLaunchBrowser::Notify

// This request allows a client to be notified of a Launch Browser proactive 

// command

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

//

TInt CSatNotifyLaunchBrowser::Notify

        (

        const TTsyReqHandle aTsyReqHandle,

        const TDataPackage& aPackage   

        )

    {

    // Save data pointer to client side for completion

    iLaunchBrowserV2Pckg = reinterpret_cast<RSat::TLaunchBrowserV2Pckg*>( 

        aPackage.Des1n() );

    // Save the request handle

    iNotificationsTsy->iSatTsy->SaveReqHandle( aTsyReqHandle, 

		CSatTsy::ESatNotifyLaunchBrowserPCmdReqType );

    // Check if requested notification is already pending

    iNotificationsTsy->NotifySatReadyForNotification( KLaunchBrowser );   

    return KErrNone;

    }

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

// CSatNotifyLaunchBrowser::CancelNotification

// This method cancels an outstanding asynchronous 

// NotifyLaunchBrowser request.

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

//

TInt CSatNotifyLaunchBrowser::CancelNotification

        (

        const TTsyReqHandle aTsyReqHandle

        )

    {

    // Reset the request handle

    TTsyReqHandle reqHandle = iNotificationsTsy->iSatReqHandleStore->

        ResetTsyReqHandle( CSatTsy::ESatNotifyLaunchBrowserPCmdReqType );

	// Reset the data pointer

	iLaunchBrowserV2Pckg = NULL;

	// Complete the request with KErrCancel

	iNotificationsTsy->iSatTsy->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;    

    }

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

// CSatNotifyLaunchBrowser::CompleteNotifyL

// This method completes an outstanding asynchronous 

// NotifyLaunchBrowser request. 

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

//

TInt CSatNotifyLaunchBrowser::CompleteNotifyL

        (

        CSatDataPackage* aDataPackage,  

        TInt aErrorCode

        )

    {  

	TInt ret( KErrNone );

	TInt returnValue( KErrNone );		

    // Unpack parameters

    TPtrC8* data;

    aDataPackage->UnPackData( &data );

    // Reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iNotificationsTsy->iSatReqHandleStore->ResetTsyReqHandle( 

        CSatTsy::ESatNotifyLaunchBrowserPCmdReqType );

    // Get ber tlv 

	CBerTlv berTlv;

    berTlv.SetData( *data );

	// Get command details tlv

	CTlv commandDetails;

	berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );	

    // Store command details tlv

	iNotificationsTsy->iTerminalRespData.iCommandDetails.Copy( commandDetails.Data() );	

	// Get command qualifier

	TUint8 cmdQualifier( commandDetails.GetShortInfo( ETLV_CommandQualifier ) );			

	TUint8 pCmdNumber( commandDetails.GetShortInfo( ETLV_CommandNumber ) );

	// In case the request was ongoing, continue..

    if ( CSatTsy::ESatReqHandleUnknown != reqHandle )

        {		

		// Check if busy 

    	if ( CSatNotificationsTsy::ENotBusy != iSsStatus )

    		{

        	if( CSatNotificationsTsy::EUssdBusy == iSsStatus)

    			{

    			// Ussd transaction ongoing

    			CreateTerminalRespL( pCmdNumber, RSat::KMeUnableToProcessCmd, 

			        RSat::KMeBusyOnUssd );	

    			}

    		else

    			{

    			// Ss transaction ongoing

    			CreateTerminalRespL( pCmdNumber, RSat::KMeUnableToProcessCmd, 

			        RSat::KMeBusyOnSs );		

    			}		

    		}

    	else

    		{	    

			// Complete right away if error has occured, otherwise continue..

	        if ( KErrNone == aErrorCode )

	            {			

				// Launch browser structure

				RSat::TLaunchBrowserV2& launchBrowserV2 = 

					( *iLaunchBrowserV2Pckg )();

				// Store command number

                launchBrowserV2.SetPCmdNumber( pCmdNumber );

            	switch ( cmdQualifier )

            		{        

            		case KLaunchBrowserIfNotYetLaunched:

            			{

            			launchBrowserV2.iBrowserSel = 

            				RSat::ELaunchBrowserIfNotAlreadyLaunched;

            			}

            			break;

            		case KUseExistingBrowser:

            			{

            			launchBrowserV2.iBrowserSel = 

            			    RSat::EUseExistingBrowser;

            			break;

            			}

            		case KCloseAndLaunchNewBrowser:

            			{

            			launchBrowserV2.iBrowserSel = 

            				RSat::ECloseExistingLaunchNewBrowserSession;

            			break;

            			}

            		case KLaunchBrowserCmdQualifierNotUsed:

            		case KLaunchBrowserCmdQualifierReserved:

            			{

            			CreateTerminalRespL( pCmdNumber, 

            			    RSat::KCmdTypeNotUnderstood, KNoCause );

                        ret = KErrCorrupt;

            			break;

            			}

            		default: 

            			{

            			launchBrowserV2.iBrowserSel = 

            				RSat::EBrowserSelectionNotSet;

            			break;

            			}

            		}

				if ( KErrNone == ret )

					{

					ret = ParseBrowserIdL( pCmdNumber, berTlv, 

					    launchBrowserV2 );

					}

				if ( KErrNone == ret )

					{

					ret = ParseUrlL( pCmdNumber, berTlv, launchBrowserV2 );

					}

				if ( KErrNone == ret )

					{

					ret = ParseProvisioningFileListL( pCmdNumber, berTlv, 

					    launchBrowserV2 );

					}

				if ( KErrNone == ret )

					{

					ret = ParseBearerListL( pCmdNumber, berTlv, 

					    launchBrowserV2 );

					}

				if ( KErrNone == ret )

					{

					// Text string (Gateway/Proxy) 

					CTlv textString;

					returnValue = berTlv.TlvByTagValue( &textString, 

					    KTlvTextStringTag );

					if ( KErrNone == returnValue )

						{

						TSatUtility::SetText( textString, 

						    launchBrowserV2.iText );

						}

					}

				if ( KErrNone == ret )

					{

					// Alpha ID string (optional) for user confirmation phase

					CTlv alphaIdentifier;

					returnValue = berTlv.TlvByTagValue( &alphaIdentifier, 

						KTlvAlphaIdentifierTag );

					launchBrowserV2.iAlphaId.iStatus = 

					    RSat::EAlphaIdNotPresent;

					if ( KErrNotFound != returnValue )

						{

						TUint8 alphaIdLength( alphaIdentifier.GetLength() );

						if ( alphaIdLength )

							{

							TPtrC8 sourceString;

							// Get the alpha id

							sourceString.Set( alphaIdentifier.GetData( 

							    ETLV_AlphaIdentifier ) );

							// Convert and set the alpha id

							TSatUtility::SetAlphaId( sourceString , 

								launchBrowserV2.iAlphaId.iAlphaId ); 

							launchBrowserV2.iAlphaId.iStatus = 

							    RSat::EAlphaIdProvided;

							}

						else

							{

							launchBrowserV2.iAlphaId.iStatus = 

							    RSat::EAlphaIdNull;

							}

						}

            		// Iconid 

            		TSatUtility::FillIconStructure( berTlv, 

            			launchBrowserV2.iIconId );

            		}

			    } // End of if (KErrNone == aErrorCode)

	        else

	        	{

	        	ret = aErrorCode;

	        	}

	        iNotificationsTsy->iSatTsy->ReqCompleted( reqHandle, ret );

	        }

        }// End of if ( reqHandle != CSatTsy::ESatReqHandleUnknown ) 

	else 

        {

        // Request not on, returning response immediately

		CreateTerminalRespL( pCmdNumber, RSat::KMeUnableToProcessCmd, 

			KNoCause );

		}    

	return ret;

	}

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

// CSatNotifyLaunchBrowser::TerminalResponseL

// Called by ETel server, passes terminal response to DOS

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

//

TInt CSatNotifyLaunchBrowser::TerminalResponseL

        ( 

        TDes8* aRsp

        )

    {

	TInt   ret( KErrNone );

    TUint8 additionalInfo( KNoCause );

    RSat::TLaunchBrowserRspV2Pckg* aRspPckg = 

            reinterpret_cast<RSat::TLaunchBrowserRspV2Pckg*>( aRsp );

    RSat::TLaunchBrowserRspV2& rspV2 = ( *aRspPckg ) ();

    // Get Proactive command number

    TUint8 pCmdNumber( rspV2.PCmdNumber() );

    // Check that general result value is valid

    if ( ( RSat::KSuccess != rspV2.iGeneralResult ) && 

         ( RSat::KPSessionTerminatedByUser  != rspV2.iGeneralResult ) && 

         ( RSat::KBackwardModeRequestedByUser != rspV2.iGeneralResult ) && 

         ( RSat::KNoResponseFromUser != rspV2.iGeneralResult ) && 

         ( RSat::KMeUnableToProcessCmd != rspV2.iGeneralResult ) && 

         ( RSat::KCmdBeyondMeCapabilities != rspV2.iGeneralResult ) && 

         ( RSat::KCmdDataNotUnderstood != rspV2.iGeneralResult ) && 

         ( RSat::KLaunchBrowserError != rspV2.iGeneralResult ) && 

         ( RSat::KPCmdNotAcceptedByUser != rspV2.iGeneralResult ) &&

         ( RSat::KCmdTypeNotUnderstood != rspV2.iGeneralResult ) &&

         ( RSat::KPartialComprehension != rspV2.iGeneralResult ) &&

         ( RSat::KMissingInformation != rspV2.iGeneralResult ) &&

         ( RSat::KNetworkUnableToProcessCmd != rspV2.iGeneralResult ) &&

         ( RSat::KCmdNumberNotKnown != rspV2.iGeneralResult ) )

        {

        // Invalid general result

        ret = KErrCorrupt;

        }

    // Check that infotype is valid: from enum TBrowserError in etelsat.h

    if ( ( RSat::KMeProblem != rspV2.iInfoType ) && 

         ( RSat::KNoAdditionalInfo != rspV2.iInfoType ) && 

         ( RSat::KBearerUnvailable != rspV2.iInfoType ) && 

         ( RSat::KBrowserUnavailable != rspV2.iInfoType ) && 

         ( RSat::KMeUnableToReadProvisioningData != rspV2.iInfoType ) && 

         ( RSat::KNoSpecificBrowserError != rspV2.iInfoType ) )

        {

        ret = KErrCorrupt;

        }

    // If there is Me (Mobile Equipment) error, additional info is needed

    if ( ( RSat::KMeProblem == rspV2.iInfoType ) )

        {

        // Check the length of additional info

        if ( 0 != rspV2.iAdditionalInfo.Length() )

            {

            additionalInfo = rspV2.iAdditionalInfo[0];

			}

        else

            {

            // Invalid additional info field

            ret = KErrCorrupt;

            }

        }

    CreateTerminalRespL( pCmdNumber, static_cast<TUint8>( 

        rspV2.iGeneralResult ), additionalInfo );                            

	return ret;

    }

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

// CSatNotifyLaunchBrowser::SetSatTsySsStatus

// Stores Ss status information.

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

//

void CSatNotifyLaunchBrowser::SetSsStatus

		(

		CSatDataPackage* aDataPackage

		)

	{

	// Unpack parameters

	aDataPackage->UnPackData( iSsStatus );

	}

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

// CSatNotifyLaunchBrowser::ParseBrowserIdL

// Help method for CompleteNotify, sets the Browser ID

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

//

TInt CSatNotifyLaunchBrowser::ParseBrowserIdL

        ( 

        TUint8 aPCmdNumber,

        CBerTlv& aBerTlv,

        RSat::TLaunchBrowserV2& aLaunchBrowserV2

        )

    {

    TInt ret( KErrNone );

    CTlv browserId; // optional

	TInt returnValue = aBerTlv.TlvByTagValue( &browserId, 

		KTlvBrowserIdentityTag );

	if ( KErrNotFound != returnValue )

		{

		// Browser id 0x00 allowed, other values are RFU

		if ( 0x00 != browserId.GetShortInfo( ETLV_BrowserIdentity ) )

			{				

			CreateTerminalRespL( aPCmdNumber, RSat::KCmdDataNotUnderstood, 

			    KNoCause );

			ret = KErrCorrupt;

			}

		else

			{

			aLaunchBrowserV2.iBrowserId = ( RSat::TBrowserIdentity )

				browserId.GetShortInfo( ETLV_BrowserIdentity );

			}

		}

	else

		{

		aLaunchBrowserV2.iBrowserId = RSat::EBrowserIdNotSet;

		}

	return ret;

    }

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

// CSatNotifyLaunchBrowser::ParseUrlL

// Help method for CompleteNotify, sets the URL

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

//

TInt CSatNotifyLaunchBrowser::ParseUrlL

        ( 

        TUint8 aPCmdNumber,

        CBerTlv& aBerTlv,

        RSat::TLaunchBrowserV2& aLaunchBrowserV2

        )

    {

    TInt ret( KErrNone );

    CTlv url; // mandatory

	TInt returnValue = aBerTlv.TlvByTagValue( &url, KTlvUrlTag );

	if ( KErrNotFound != returnValue )

		{

		if ( RSat::KUrlMaxSize < url.GetLength() )

			{

			CreateTerminalRespL( aPCmdNumber, RSat::KMeUnableToProcessCmd, 

			    KNoCause );

			ret = KErrCorrupt;

			}

		else

			{

			aLaunchBrowserV2.iUrl.Copy( url.GetData( ETLV_Url ) );

			}

		}

	else

		{

		CreateTerminalRespL( aPCmdNumber, RSat::KErrorRequiredValuesMissing, 

	        KNoCause );

		ret = KErrCorrupt;

		}

	return ret;