1 /*

     2 * Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Handles LaunchBrowser command

    15 *

    16 */

    17 

    18 

    19 

    20 #include    <MSatShellController.h>

    21 #include    <cmmanager.h>

    22 #include    <cmconnectionmethod.h>

    23 #include    <cmconnectionmethoddef.h>

    24 #include    <cmpluginpacketdatadef.h>

    25 #include    <cmdestination.h>

    26 

    27 #include    "MSatApi.h"

    28 #include    "MSatUtils.h"

    29 #include    "MSatUiSession.h"

    30 #include    "SatSOpcodes.h"

    31 #include    "MSatSUiClientHandler.h"

    32 #include    "CLaunchBrowserHandler.h"

    33 #include    "SatLog.h"

    34 #include    "MSatSystemState.h"

    35 

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

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

    38 const TInt KSatSShortLoopTimeout = 800000; //0.8 sec

    39 

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

    41 // browser shutdown. Total time

    42 // used to check the exiting of browser app is

    43 // KSatSWaitCount * KSatSShortLoopTimeout.

    44 const TInt KSatSWaitCount = 10;

    45 

    46 // Invalid PDP type

    47 const TInt KSatInvalidPdpType = -1;

    48 

    49 #ifdef _DEBUG

    50 // Class name for error information.

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

    52 _LIT( KLaunchBrowserHandlerName, "CLaunchBrowserHandler" );

    53 #endif

    54 

    55 const TInt KSatMaxIPv4AddressLength( 15 );

    56 const TInt KSatMaxIPv6AddressLength( 39 );

    57 const TInt KSatMinIPv4AddressLength( 7 );

    58 const TInt KSatMinIPv6AddressLength( 7 );

    59 const TInt KSatMaxIPv4SegmentCounter( 3 );

    60 const TInt KSatMaxIPv4SegmentLength( 3 );

    61 const TInt KSatIPv4Broadcast( 255 );

    62 const TInt KSatIPv4Network( 0 );

    63 const TInt KSatMaxIPv6SegmentCounter( 7 );

    64 const TInt KSatMaxIPv6SegmentLength( 4 );

    65 const TUint32 KSatLaunchBrowserProxyPortNumber( 80 );

    66 const TUint32 KSatMaxProxyPortNumber( 9999 );

    67 const TUint32 KSatMinProxyPortNumber( 0 );

    68 // Granularity for getting connection methods from CM session

    69 const TUint32 KSatCMGranularity( 5 );

    70 

    71 _LIT( KSatAccessPointName, "SAT Launch Browser" );

    72 _LIT( KSatGprsAccessPointName, "internet" );

    73 _LIT( KSatIPv4Delimiter, "." );

    74 _LIT( KSatIPv6Delimiter, ":" );

    75 

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

    77 // -----------------------------------------------------------------------------

    78 // Two-phased constructor.

    79 // -----------------------------------------------------------------------------

    80 //

    81 CLaunchBrowserHandler* CLaunchBrowserHandler::NewL( MSatUtils* aUtils )

    82     {

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

    84 

    85     CLaunchBrowserHandler* self = new( ELeave ) CLaunchBrowserHandler;

    86 

    87     CleanupStack::PushL( self );

    88     self->BaseConstructL( aUtils );

    89     self->ConstructL();

    90     CleanupStack::Pop( self );

    91 

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

    93     return self;

    94     }

    95 

    96 

    97 // -----------------------------------------------------------------------------

    98 // Destructor.

    99 // -----------------------------------------------------------------------------

   100 //

   101 CLaunchBrowserHandler::~CLaunchBrowserHandler()

   102     {

   103     LOG( SIMPLE,

   104         "LAUNCHBROWSER: CLaunchBrowserHandler::~CSatSLaunchBrowserHandler \

   105         calling" )

   106 

   107     if ( iAfterWait.IsStarted() )

   108         {

   109         iAfterWait.AsyncStop();

   110         }

   111 

   112     if ( iAfterTimer )

   113         {

   114         iAfterTimer->Cancel();

   115         delete iAfterTimer;

   116         iAfterTimer = NULL;

   117         }

   118 

   119     iWsSession.Close();

   120 

   121     Cancel();

   122 

   123     LOG( SIMPLE,

   124         "LAUNCHBROWSER: CLaunchBrowserHandler::~CSatSLaunchBrowserHandler \

   125         exiting" )

   126     }

   127 

   128 // -----------------------------------------------------------------------------

   129 // From class MSatCommand.

   130 // Response from the client.

   131 // -----------------------------------------------------------------------------

   132 //

   133 void CLaunchBrowserHandler::ClientResponse()

   134     {

   135     LOG( SIMPLE,

   136         "LAUNCHBROWSER: CLaunchBrowserHandler::ClientResponse calling" )

   137 

   138     // TPCmdResult

   139     iLaunchBrowserRsp.iGeneralResult = RSat::KLaunchBrowserError;

   140 

   141     // TAdditionalInfoType

   142     iLaunchBrowserRsp.iInfoType = RSat::KNoAdditionalInfo;

   143     iLaunchBrowserRsp.iAdditionalInfo.Zero();

   144     iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

   145 

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

   147     if ( iQueryRsp.iAccepted )

   148         {

   149         // Launch the Browser.

   150         TRAPD( err, LaunchBrowserL() );

   151         if ( KErrNone != err )

   152             {

   153             iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

   154             LOG2( SIMPLE, "LAUNCHBROWSER: \

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

   156             }

   157         else

   158             {

   159             LOG( SIMPLE,

   160                 "LAUNCHBROWSER: CLBH::CR ESetUpMenuRequested registered" )

   161             TRAP_IGNORE( iUtils->RegisterL(

   162                 this, MSatUtils::ESetUpMenuRequested ) )

   163             }

   164         }

   165     else // User denied this action

   166         {

   167         iLaunchBrowserRsp.iGeneralResult = RSat::KPCmdNotAcceptedByUser;

   168         LOG( SIMPLE, "LAUNCHBROWSER: \

   169             CLaunchBrowserHandler::ClientResponse not accepted" )

   170         if ( iQueryRsp.iSessionTerminatedByUser )

   171             {

   172             LOG( SIMPLE, "LAUNCHBROWSER: \

   173                  CLaunchBrowserHandler::ClientResponse close ui session" )

   174             // Next SimSession end will close the ui session

   175             iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

   176             }

   177         }

   178         

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

   180     // was not shown

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

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

   183         iIconCommand )

   184         {

   185         LOG( SIMPLE, "LAUNCHBROWSER: \

   186                  CLaunchBrowserHandler::ClientResponse icon not display" )

   187         iLaunchBrowserRsp.iGeneralResult =

   188             RSat::KSuccessRequestedIconNotDisplayed;

   189         }

   190 

   191     TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

   192 

   193     LOG( SIMPLE,

   194         "LAUNCHBROWSER: CLaunchBrowserHandler::ClientResponse exiting" )

   195     }

   196 

   197 // -----------------------------------------------------------------------------

   198 // From class CSatCommandHandler.

   199 // Event notification

   200 // -----------------------------------------------------------------------------

   201 //

   202 void CLaunchBrowserHandler::Event( TInt aEvent )

   203     {

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

   205 

   206     switch ( aEvent )

   207         {

   208         // SetUpMenu is listening by SAT Client.

   209         case MSatUtils::ESetUpMenuRequested:

   210             {

   211             LOG( NORMAL,

   212                 "LAUNCHBROWSER::Event ESetUpMenuRequested catched and unreg" )

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

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

   215             //iUtils->SatUiHandler().ShellController().

   216             //    BringBrowserToForegroundAfterPeriod();

   217             break;

   218             }

   219 

   220         default:

   221             {

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

   223             CSatCommandHandler::Event( aEvent );

   224             }

   225         }

   226 

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

   228     }

   229 

   230 // -----------------------------------------------------------------------------

   231 // From class CActive.

   232 // Cancels the sat request.

   233 // -----------------------------------------------------------------------------

   234 //

   235 void CLaunchBrowserHandler::DoCancel()

   236     {

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

   238 

   239     iUtils->USatAPI().NotifyLaunchBrowserCancel();

   240 

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

   242     }

   243 

   244 // -----------------------------------------------------------------------------

   245 // From class CSatCommandHandler.

   246 // Requests the command notification.

   247 // -----------------------------------------------------------------------------

   248 //

   249 void CLaunchBrowserHandler::IssueUSATRequest( TRequestStatus& aStatus )

   250     {

   251     LOG( SIMPLE,

   252         "LAUNCHBROWSER: CLaunchBrowserHandler::IssueUSATRequest calling" )

   253 

   254     // Clear the IPC package.

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

   256     iQueryRsp.iAccepted = EFalse; // default

   257 

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

   259 

   260     LOG( SIMPLE,

   261         "LAUNCHBROWSER: CLaunchBrowserHandler::IssueUSATRequest exiting" )

   262     }

   263 

   264 // -----------------------------------------------------------------------------

   265 // From class CSatCommandHandler.

   266 // Precheck before executing the command.

   267 // -----------------------------------------------------------------------------

   268 //

   269 TBool CLaunchBrowserHandler::CommandAllowed()

   270     {

   271     LOG( SIMPLE,

   272         "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed calling" )

   273 

   274     iLaunchBrowserRsp.iGeneralResult = RSat::KLaunchBrowserError;

   275     iLaunchBrowserRsp.iInfoType = RSat::KNoAdditionalInfo;

   276     iLaunchBrowserRsp.iAdditionalInfo.Zero();

   277 

   278     RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

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

   280 

   281     TBool commandAllowed( ETrue );

   282 

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

   284         {

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

   286         // terminal response of command not understood.

   287         iLaunchBrowserRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

   288         commandAllowed = EFalse;

   289         LOG( SIMPLE, "LAUNCHBROWSER: \

   290             CLaunchBrowserHandler::CommandAllowed unknown browser id" )

   291         }

   292     else if ( ( RSat::EAlphaIdProvided !=

   293         iLaunchBrowserData.iAlphaId.iStatus ) &&

   294         ( RSat::ESelfExplanatory ==

   295             iLaunchBrowserData.iIconId.iQualifier ||

   296           RSat::ENotSelfExplanatory ==

   297             iLaunchBrowserData.iIconId.iQualifier ) )

   298         {

   299         iLaunchBrowserRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

   300         commandAllowed = EFalse;

   301         LOG( SIMPLE, "LAUNCHBROWSER: \

   302             CLaunchBrowserHandler::CommandAllowed icon without alpha id" )

   303         }

   304     else if (

   305         ( RMobilePhone::ERegisteredOnHomeNetwork != registrationStatus ) &&

   306         ( RMobilePhone::ERegisteredRoaming != registrationStatus ) )

   307         {

   308         iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

   309         iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

   310         iLaunchBrowserRsp.iAdditionalInfo.SetLength( 1 );

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

   312         commandAllowed = EFalse;

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

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

   315         }

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

   317         {

   318         iLaunchBrowserRsp.iGeneralResult = RSat::KCmdTypeNotUnderstood;

   319         commandAllowed = EFalse;

   320         LOG( SIMPLE, "LAUNCHBROWSER: \

   321             CLaunchBrowserHandler::CommandAllowed selection not set" )

   322         }

   323     else if ( RSat::ELaunchBrowserIfNotAlreadyLaunched ==

   324         iLaunchBrowserData.iBrowserSel )

   325         {

   326         if ( BrowserExists() )

   327             {

   328             iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

   329             iLaunchBrowserRsp.iAdditionalInfo.Append( 

   330                 RSat::KBrowserUnavailable );

   331             commandAllowed = EFalse;

   332             LOG( SIMPLE, "LAUNCHBROWSER: \

   333                 CLaunchBrowserHandler::CommandAllowed not launched" )

   334             }

   335         }

   336     else

   337         {

   338         LOG( SIMPLE,

   339             "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed ok" )

   340         }

   341 

   342     if ( !commandAllowed )

   343         {

   344         LOG( SIMPLE,

   345             "CLaunchBrowserHandler::CommandAllowed commandAllowed false" )

   346         iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

   347         TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

   348         }

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

   350     // to no icon id

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

   352     else if ( ( RSat::ESelfExplanatory ==

   353         iLaunchBrowserData.iIconId.iQualifier ) ||

   354         ( RSat::ENotSelfExplanatory ==

   355         iLaunchBrowserData.iIconId.iQualifier ) )

   356         {

   357          LOG( SIMPLE,

   358             "CLaunchBrowserHandler::CommandAllowed commandAllowed ENoIconId" )

   359         iIconCommand = ETrue;

   360         iLaunchBrowserData.iIconId.iQualifier = RSat::ENoIconId;

   361         }

   362     else

   363         {

   364         iIconCommand = EFalse;

   365         }

   366 

   367     LOG2( SIMPLE,

   368         "LAUNCHBROWSER: CLaunchBrowserHandler::CommandAllowed exiting, \

   369          commandAllowed: %d", commandAllowed )

   370     return commandAllowed;

   371     }

   372 

   373 // -----------------------------------------------------------------------------

   374 // From class CSatCommandHandler.

   375 // Answers for need of UI session.

   376 // -----------------------------------------------------------------------------

   377 //

   378 TBool CLaunchBrowserHandler::NeedUiSession()

   379     {

   380     LOG( SIMPLE,

   381         "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession calling" )

   382 

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

   384 

   385     iNeedUiSession = ETrue;

   386 

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

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

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

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

   391         {

   392         iNeedUiSession = EFalse;

   393         LOG( NORMAL,

   394             "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession no  \

   395             Ui session needed" )

   396         }

   397 

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

   399         {

   400         LOG( NORMAL,

   401             "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession Ui session \

   402             needed" )

   403         TSatCommandData medEventData;

   404         medEventData.iPCmdNumber = RSat::ELaunchBrowser;

   405         medEventData.iAlphaId = iLaunchBrowserData.iAlphaId;

   406 

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

   408             {

   409             LOG( NORMAL,

   410             "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession \

   411              KSatLongDuration" )

   412             medEventData.iDuration.iNumOfUnits = KSatLongDuration;

   413             }

   414         else

   415             {

   416             medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

   417             }

   418 

   419         medEventData.iDuration.iTimeUnit = RSat::ESeconds;

   420         medEventData.iIconID = iLaunchBrowserData.iIconId;

   421         TSatCommandPckg tPckg( medEventData );

   422         iUtils->RaiseSatEvent( tPckg );

   423         }

   424 

   425     LOG2( SIMPLE,

   426         "LAUNCHBROWSER: CLaunchBrowserHandler::NeedUiSession exiting, \

   427          iNeedUiSession: %d", iNeedUiSession )

   428     return iNeedUiSession;

   429     }

   430 

   431 // -----------------------------------------------------------------------------

   432 // From class CSatCommandHandler.

   433 // Called when USAT API notifies that command.

   434 // -----------------------------------------------------------------------------

   435 //

   436 void CLaunchBrowserHandler::HandleCommand()

   437     {

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

   439 

   440     // Register service request handler for LaunchBrowser command,

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

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

   443     // command handler

   444     TRAPD( err, iUtils->RegisterServiceRequestL(

   445         ESatSProactiveQuery,

   446         ESatSProactiveQueryResponse,

   447         this ) );

   448 

   449     if ( KErrNone != err )

   450         {

   451         iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

   452         iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

   453         iLaunchBrowserRsp.iAdditionalInfo.SetLength( 1 );

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

   455         iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

   456         TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

   457 

   458         LOG2( SIMPLE,

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

   460         }

   461     else if ( iNeedUiSession )

   462         {

   463         iQueryData.iCommand = ESatSLaunchBrowserQuery;

   464         iQueryData.iQueryText = iLaunchBrowserData.iAlphaId.iAlphaId;

   465         iQueryData.iIconId.iIdentifier =

   466             iLaunchBrowserData.iIconId.iIdentifier;

   467         LOG2( SIMPLE, "CLaunchBrowserHandler::HandleCommand \

   468               iLaunchBrowserData.iIconId.iQualifier: %i", 

   469               iLaunchBrowserData.iIconId.iQualifier )

   470         switch ( iLaunchBrowserData.iIconId.iQualifier )

   471             {

   472             case RSat::ESelfExplanatory:

   473                 {

   474                 // Icon qualifier is self explanatory (to display instead

   475                 // of the alpha id or text string).

   476                 iQueryData.iIconId.iIconQualifier = ESatSelfExplanatory;

   477                 break;

   478                 }

   479 

   480             case RSat::ENotSelfExplanatory:

   481                 {

   482                 // Icon qualifier is not self explanatory.

   483                 iQueryData.iIconId.iIconQualifier = ESatNotSelfExplanatory;

   484                 break;

   485                 }

   486 

   487             default:

   488                 {

   489                 // Icon qualifier not present

   490                 iQueryData.iIconId.iIconQualifier = ESatENoIconId;

   491                 break;

   492                 }

   493             }

   494 

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

   496             {

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

   498                  EAlphaIdNotPresent" )

   499             iQueryData.iAlphaIdStatus = ESatAlphaIdNotProvided;

   500             }

   501         else if ( RSat::EAlphaIdProvided ==

   502             iLaunchBrowserData.iAlphaId.iStatus )

   503             {

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

   505                  EAlphaIdProvided" )

   506             iQueryData.iAlphaIdStatus = ESatAlphaIdNotNull;

   507             }

   508         else

   509             {

   510             iQueryData.iAlphaIdStatus = ESatAlphaIdNull;

   511             }

   512 

   513         iQueryData.iSimApplicationName = iUtils->SatAppName();

   514 

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

   516         // to ClientResponse() method.

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

   518             &iQueryPckg,

   519             &iQueryRspPckg,

   520             ESatSProactiveQuery );

   521         }

   522     else // transparent launch

   523         {

   524         // Launch the Browser.

   525         TRAP( err, LaunchBrowserL() );

   526 

   527         if ( KErrNone != err )

   528             {

   529             iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

   530             LOG2( SIMPLE, "LAUNCHBROWSER: \

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

   532             }

   533         else

   534             {

   535             LOG( SIMPLE,

   536                 "LAUNCHBROWSER: CLBH::CR ESetUpMenuRequested registered" )

   537             TRAP_IGNORE( iUtils->RegisterL(

   538                 this, MSatUtils::ESetUpMenuRequested ) )

   539             }

   540 

   541         TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

   542         }

   543 

   544     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::HandleCommand exiting" )

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // From class CSatCommandHandler.

   549 // Indicates the failure of launching ui client.

   550 // -----------------------------------------------------------------------------

   551 //

   552 void CLaunchBrowserHandler::UiLaunchFailed()

   553     {

   554     LOG( SIMPLE,

   555         "LAUNCHBROWSER: CLaunchBrowserHandler::UiLaunchFailed calling" )

   556 

   557     iLaunchBrowserRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

   558     iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

   559     iLaunchBrowserRsp.iAdditionalInfo.SetLength( 1 );

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

   561     iLaunchBrowserRsp.SetPCmdNumber( iLaunchBrowserData.PCmdNumber() );

   562     TerminalRsp( RSat::ELaunchBrowser, iLaunchBrowserRspPckg );

   563 

   564     LOG( SIMPLE,

   565         "LAUNCHBROWSER: CLaunchBrowserHandler::UiLaunchFailed exiting" )

   566     }

   567     

   568 // -----------------------------------------------------------------------------

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

   570 // might leave.

   571 // -----------------------------------------------------------------------------

   572 //

   573 //lint -e{1403, 1769} Can not be initialized, harmless.

   574 CLaunchBrowserHandler::CLaunchBrowserHandler() :

   575     CSatCommandHandler(),

   576     iLaunchBrowserData(),

   577     iLaunchBrowserPckg( iLaunchBrowserData ),

   578     iLaunchBrowserRsp(),

   579     iLaunchBrowserRspPckg( iLaunchBrowserRsp ),

   580     iQueryData(),

   581     iQueryPckg( iQueryData ),

   582     iQueryRsp(),

   583     iQueryRspPckg( iQueryRsp ),

   584     iUidWmlBrowser( TUid::Uid( KWmlcHandler ) ),

   585     iAfterTimer( NULL ),

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

   587     iIconCommand( EFalse )

   588     {

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

   590         calling - exiting" )

   591     }

   592 

   593 // -----------------------------------------------------------------------------

   594 // Symbian 2nd phase constructor can leave.

   595 // -----------------------------------------------------------------------------

   596 //

   597 void CLaunchBrowserHandler::ConstructL()

   598     {

   599     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::ConstructL calling" )

   600 

   601     // Open the Window server session.

   602     User::LeaveIfError( iWsSession.Connect() );

   603 

   604     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::ConstructL exiting" )

   605     }

   606 

   607 

   608 // -----------------------------------------------------------------------------

   609 // Checks if Browser application is launched.

   610 // -----------------------------------------------------------------------------

   611 //

   612 TBool CLaunchBrowserHandler::BrowserExists()

   613     {

   614     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::BrowserExists calling" )

   615     TBool browserExists( EFalse );

   616 

   617     TApaTaskList taskList( iWsSession );

   618     TApaTask task = taskList.FindApp( iUidWmlBrowser );

   619     browserExists = task.Exists();

   620 

   621     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::BrowserExists exiting" )

   622     return browserExists;

   623     }

   624 

   625 // -----------------------------------------------------------------------------

   626 // The Launch Browser handler.

   627 // -----------------------------------------------------------------------------

   628 //

   629 void CLaunchBrowserHandler::LaunchBrowserL()

   630     {

   631     LOG( SIMPLE,

   632         "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL calling" )

   633 

   634     // Check the URL length.

   635     const TInt urlLen( iLaunchBrowserData.iUrl.Length() );

   636 

   637     // ID of the accesspoint in the communications database.

   638     TUid accesspointID( TUid::Uid( KErrNotFound ) );

   639 

   640     // If apId is given by SIM card, then we use that, otherwise,

   641     // get default apId from default connection method.

   642     TUint32 apId( 0 );

   643     // GCF is supported since S60 5.0

   644     apId = GetAccessPointByGatewayAddressL();

   645     if ( apId )

   646         {

   647         LOG2( SIMPLE, 

   648               "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL, \

   649               Get gcf AP id = %d", apId )

   650         accesspointID.iUid = static_cast<TInt32>( apId );

   651         }    

   652     

   653     // Get default AP if GCF ap not found

   654     if ( KErrNotFound == accesspointID.iUid )

   655         {

   656         LOG( SIMPLE, 

   657              "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL, \

   658              no gcf AP id" )

   659         apId = GetAccessPointByDefaultL();

   660         if ( apId )

   661             {

   662             LOG2( SIMPLE, 

   663                   "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL, \

   664                   default AP id = %d", apId )            

   665             accesspointID.iUid = static_cast<TInt32>( apId );

   666             }

   667         }

   668     

   669     LOG2( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL, \

   670           accesspointID.iUid=%d", accesspointID.iUid )

   671     

   672     HBufC* param = NULL;

   673     // If the URL is given by SIM, then we use that

   674     if ( urlLen )

   675         {

   676         // Url is given by SIM, and we use that.

   677         param = HBufC::NewLC( urlLen );

   678         param->Des().Copy( iLaunchBrowserData.iUrl );

   679         LOG3( SIMPLE, 

   680               "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL,\

   681               url is given by SIM, url=%s, length=%d", 

   682               param, param->Des().Length() )

   683         }  

   684     // If no url from SIM, get default URL by selected access point.

   685     else if ( !param && accesspointID.iUid > 0 )

   686         {

   687         param = GetDefaultUrlByAccessPointLC( 

   688                 static_cast<TUint32>( accesspointID.iUid) );

   689         LOG3( SIMPLE, 

   690               "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL,\

   691               url is given by IAP, url=%s, length=%d",

   692               param, param->Des().Length() )

   693         }

   694     else

   695         {

   696         param = KNullDesC().AllocLC();

   697         LOG( SIMPLE, 

   698              "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL no url" )

   699         }

   700     

   701     switch ( iLaunchBrowserData.iBrowserSel )

   702         {

   703         case RSat::ECloseExistingLaunchNewBrowserSession:

   704             {

   705             LOG( NORMAL, "LAUNCHBROWSER: CLaunchBrowserHandler:: \

   706                  LaunchBrowserL, ECloseExistingLaunchNewBrowserSession" )

   707             CloseBrowser();  // Close Browser Session if it exists.

   708             LaunchWithUrlL( param->Des(), accesspointID );

   709             break;

   710             }

   711 

   712         case RSat::ELaunchBrowserIfNotAlreadyLaunched:

   713             {

   714             LOG( NORMAL, "LAUNCHBROWSER: CLaunchBrowserHandler:: \

   715                  LaunchBrowserL, ELaunchBrowserIfNotAlreadyLaunched" )

   716             if ( BrowserExists() )

   717                 {

   718                 LOG( SIMPLE,"CLaunchBrowserHandler::LaunchBrowserL \

   719                      BrowserExists" )

   720                 // Browser exists, error response returned.

   721                 iLaunchBrowserRsp.iGeneralResult = RSat::KLaunchBrowserError;

   722                 iLaunchBrowserRsp.iInfoType = RSat::KMeProblem;

   723                 iLaunchBrowserRsp.iAdditionalInfo.Append( 

   724                     RSat::KBrowserUnavailable );

   725                 }

   726             else

   727                 {

   728                 LaunchWithUrlL( param->Des(), accesspointID );

   729                 }

   730             break;

   731             }

   732 

   733         case RSat::EUseExistingBrowser:

   734             {

   735             // SAT Shell Controller looks if browser already exists.

   736             LOG( NORMAL, "LAUNCHBROWSER: CLaunchBrowserHandler:: \

   737                  LaunchBrowserL,EUseExistingBrowser" )

   738             LaunchWithUrlL( param->Des(), accesspointID );

   739             break;

   740             }

   741 

   742         case RSat::EBrowserSelectionNotSet:

   743         default:

   744             __ASSERT_DEBUG( EFalse,

   745                 Panic( KLaunchBrowserHandlerName, KErrBadName ) );

   746             break;

   747         }

   748 

   749     CleanupStack::PopAndDestroy( param );

   750 

   751     LOG( SIMPLE,

   752         "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchBrowserL exiting" )

   753     }

   754 

   755 // --------------------------------------------------------------------------

   756 // Closes the Browser application if it is active and waits until

   757 // closing is complete.

   758 // --------------------------------------------------------------------------

   759 //

   760 void CLaunchBrowserHandler::CloseBrowser()

   761     {

   762     LOG( SIMPLE, 

   763          "LAUNCHBROWSER: CLaunchBrowserHandler::CloseBrowser calling" )

   764     TApaTaskList taskList( iWsSession );

   765     TApaTask task = taskList.FindApp( iUidWmlBrowser );

   766 

   767     if ( task.Exists() )

   768         {

   769         task.SendSystemEvent( EApaSystemEventShutdown );

   770 

   771         TBool browserExists( ETrue );

   772         TInt waitCount( 0 );

   773         LOG2( SIMPLE, 

   774               "CLaunchBrowserHandler::CloseBrowser browserExists: %d",

   775               browserExists )

   776         // Make sure that closing is completed.

   777         while ( browserExists )

   778             {

   779             After( KSatSShortLoopTimeout );

   780             ++waitCount;

   781 

   782             TApaTask newTask = taskList.FindApp( iUidWmlBrowser );

   783             browserExists = newTask.Exists();

   784 

   785             if ( KSatSWaitCount <= waitCount )

   786                 {

   787                 newTask.KillTask();

   788                 browserExists = EFalse;

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

   790                     CloseBrowser force kill task" )

   791                 }

   792             }

   793         }

   794 

   795     LOG( SIMPLE, 

   796          "LAUNCHBROWSER: CLaunchBrowserHandler::CloseBrowser exiting" )

   797     }

   798 

   799 // --------------------------------------------------------------------------

   800 // Launches The Browser with URL.

   801 // --------------------------------------------------------------------------

   802 //

   803 void CLaunchBrowserHandler::LaunchWithUrlL( const TDesC& aParam,

   804     const TUid& aAccessPointUid )

   805     {

   806     LOG( SIMPLE,

   807         "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchWithUrlL calling" )

   808     LOG3( SIMPLE,

   809          "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchWithUrlL\

   810           url=%s, IAP=%d", &aParam, aAccessPointUid.iUid )        

   811 

   812     // Browser launching called.

   813     //TInt err = iUtils->SatUiHandler().ShellController().LaunchBrowserL(

   814     //    aParam, aAccessPointUid );

   815     TInt err =  KErrNone;

   816 

   817     if ( KErrNone == err )

   818         {

   819         if ( !iQueryRsp.iRequestedIconDisplayed &&

   820             ( ( RSat::ESelfExplanatory ==

   821             iLaunchBrowserData.iIconId.iQualifier ) ||

   822             ( RSat::ENotSelfExplanatory ==

   823             iLaunchBrowserData.iIconId.iQualifier ) ) )

   824             {

   825             iLaunchBrowserRsp.iGeneralResult =

   826                 RSat::KSuccessRequestedIconNotDisplayed;

   827             LOG( SIMPLE,

   828                 "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchWithUrlL \

   829                 no icon shown" )

   830             }

   831         else

   832             {

   833             iLaunchBrowserRsp.iGeneralResult = RSat::KSuccess;

   834             LOG( SIMPLE,

   835                 "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchWithUrlL \

   836                 command ok" )

   837             }

   838         }

   839     else

   840         {

   841         iLaunchBrowserRsp.iGeneralResult  = RSat::KLaunchBrowserError;

   842         iLaunchBrowserRsp.iInfoType       = RSat::KMeProblem;

   843         iLaunchBrowserRsp.iAdditionalInfo.Append( 

   844                 RSat::KBrowserUnavailable );

   845         LOG2( SIMPLE, 

   846         "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchWithUrlL error: %i", 

   847         err )

   848         }

   849 

   850     LOG( SIMPLE,

   851         "LAUNCHBROWSER: CLaunchBrowserHandler::LaunchWithUrlL exiting" )

   852     }

   853 

   854 // --------------------------------------------------------------------------

   855 // Starts timer. Function returns as the given time has elapsed or

   856 // timer is cancelled.

   857 // --------------------------------------------------------------------------

   858 void CLaunchBrowserHandler::After(

   859     const TTimeIntervalMicroSeconds32& aDelay,

   860     const TTimeIntervalMicroSeconds32& aInterval )

   861     {

   862     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::After calling" )

   863 

   864     if ( !iAfterWait.IsStarted() )

   865         {

   866         TRAPD( err, iAfterTimer = CPeriodic::NewL( EPriorityStandard ) )

   867         LOG2( SIMPLE, 

   868         "LAUNCHBROWSER: CLaunchBrowserHandler::After err: %i", err )

   869         if ( ( KErrNone == err ) && iAfterTimer )

   870             {

   871             iAfterTimer->Start(

   872                 aDelay, aInterval, TCallBack( DelayCallBack, this ) );

   873             iAfterWait.Start();

   874 

   875             delete iAfterTimer;

   876             iAfterTimer = NULL;

   877             }

   878         }

   879 

   880     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::After exiting" )

   881     }

   882 

   883 // --------------------------------------------------------------------------

   884 // Timer call back function

   885 // --------------------------------------------------------------------------

   886 TInt CLaunchBrowserHandler::DelayCallBack( TAny* aPtr )

   887     {

   888     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::DelayCallBack \

   889     calling" )

   890     CLaunchBrowserHandler* ptrThis =

   891         static_cast<CLaunchBrowserHandler*>( aPtr );

   892 

   893     if ( ptrThis && ( ptrThis->iAfterWait.IsStarted() ) )

   894         {

   895         LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::DelayCallBack \

   896              stop iAfterWait" )

   897         ptrThis->iAfterWait.AsyncStop();

   898         }

   899     LOG( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler::DelayCallBack \

   900     exiting" )

   901     return ( EFalse );

   902     }

   903 

   904 // --------------------------------------------------------------------------

   905 // Create a new access point using the Access Point Engine.

   906 // --------------------------------------------------------------------------

   907 //

   908 TUint32 CLaunchBrowserHandler::CreateAccessPointL( 

   909         const TDesC16& aApName,

   910         const TDesC16& aProxyServerAddr,

   911         const TUint32 aProxyPortNumber,

   912         const RPacketContext::TProtocolType& aIPvType )

   913     {

   914     LOG( SIMPLE, 

   915          "LAUNCHBROWSER: CLaunchBrowserHandler::CreateAccessPointL calling" )

   916 

   917     // Connection method interface.

   918     RCmConnectionMethod cm;

   919     // Connection method manager interface.

   920     RCmManager cmManager;

   921     // Used to exit connection methods go through loop

   922     TBool exitConnectionMethodsLoop( EFalse );

   923     

   924     cmManager.OpenLC();

   925 

   926     // Find if the access point with the same name is already exist.

   927     // If such access point exists, delete it and then create a new one.

   928      

   929     // Get the Connection Methods does not belogns to any destination

   930     RArray<TUint32> array = RArray<TUint32>( KSatCMGranularity );

   931     CleanupClosePushL( array );

   932 

   933     cmManager.ConnectionMethodL( array );

   934 

   935     // Go through the Connection Method list to find if there is matched one

   936      

   937     for( TInt i = 0; 

   938          ( i < array.Count() ) && !exitConnectionMethodsLoop; ++i)

   939         {

   940         cm = cmManager.ConnectionMethodL( array[i] );

   941         CleanupClosePushL( cm );

   942         

   943         // query the access point name

   944         HBufC * pa = NULL;

   945         pa = cm.GetStringAttributeL( CMManager::ECmName );

   946         CleanupStack::PushL(pa);

   947         

   948         if ( *pa == aApName )

   949             {

   950             // Find the matched connection method

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

   952                  CreateAccessPointL, find the existing ap" )

   953             cm.DeleteL();

   954             exitConnectionMethodsLoop = ETrue;

   955             }

   956         CleanupStack::PopAndDestroy( pa );

   957         CleanupStack::PopAndDestroy( &cm ); 

   958         } 

   959     CleanupStack::PopAndDestroy( &array );

   960 

   961     // Create a connection method without destination.

   962     cm = cmManager.CreateConnectionMethodL( KUidPacketDataBearerType );

   963     CleanupClosePushL( cm );

   964     

   965     // Fulfill connection method params with default setting from OCC.

   966     // We use trap to continue following operations even if leaving from 

   967     // FulfillConnnectionMethodL.

   968     TRAPD( errCode, FulfillConnnectionMethodL( cmManager, cm ) );

   969     LOG3( SIMPLE, "SATENGINE: CLaunchBrowserHandler::CreateAccessPointL \

   970           errCode=%d ad line %d", errCode, __LINE__ )

   971     // Set attributes of the connection method.

   972     cm.SetStringAttributeL( CMManager::ECmName, aApName );

   973     cm.SetIntAttributeL( CMManager::EPacketDataPDPType, aIPvType );

   974     cm.SetStringAttributeL( CMManager::ECmWapIPGatewayAddress, 

   975                             TPtrC( aProxyServerAddr ) );

   976     cm.SetStringAttributeL( CMManager::ECmProxyServerName, 

   977                             TPtrC( aProxyServerAddr ) );

   978     cm.SetIntAttributeL( CMManager::ECmProxyPortNumber, aProxyPortNumber );

   979         

   980     // Update the access point ID for use later.

   981     cm.UpdateL();

   982 

   983     TUint32 apId = cm.GetIntAttributeL( CMManager::ECmIapId );

   984     LOG2( SIMPLE, 

   985           "LAUNCHBROWSER: CLaunchBrowserHandler::CreateAccessPointL apId=%d",

   986           apId )

   987 

   988     CleanupStack::PopAndDestroy( &cm );

   989     CleanupStack::PopAndDestroy( &cmManager );

   990     

   991     LOG( SIMPLE, 

   992          "LAUNCHBROWSER: CLaunchBrowserHandler::CreateAccessPointL exiting" )

   993     

   994     return apId;

   995     }

   996 

   997 // --------------------------------------------------------------------------

   998 // Get a AP from the Connection Method Manager.

   999 // --------------------------------------------------------------------------

  1000 TUint32 CLaunchBrowserHandler::GetAccessPointByGatewayAddressL()

  1001     {

  1002     LOG( SIMPLE, "LAUNCHBROWSER: \

  1003         CLaunchBrowserHandler::GetAccessPointByGatewayAddressL calling" )

  1004     // Access Point ID.

  1005     TUint32 apId( 0 ); 

  1006     // Unknown IP address type.

  1007     TInt ipvType( 0 );

  1008     // Get the gateway address.

  1009     TPtrC gatewayAddrPtr( iLaunchBrowserData.iText );

  1010     // Get the bearer list.

  1011     TPtrC8 bearerListPtr( iLaunchBrowserData.iBearerList ); 

  1012 

  1013     // Proxy address.

  1014     HBufC* proxyAddress = NULL;

  1015     // Proxy port number.

  1016     TUint32 proxyPortNumber( 0 );

  1017     HBufC* pa = NULL;

  1018     TUint32 pn( 0 );

  1019 

  1020     // Used to exit the connection method go through loop

  1021     TBool exitConnectionMethodsLoop( EFalse );

  1022     

  1023     // SAT access point name.

  1024     TPtrC satAPN( KNullDesC );

  1025     

  1026     // Use SAT application name as SAT APN.

  1027     satAPN.Set( iUtils->SatAppName() );

  1028     // Use default SAT APN if SAT application name is not available.

  1029     if ( satAPN == KNullDesC )

  1030         {

  1031         LOG( SIMPLE, 

  1032              "CLaunchBrowserHandler::GetAccessPointByGatewayAddressL\

  1033              satAPN == KNullDesC" )

  1034         satAPN.Set( KSatAccessPointName );

  1035         }

  1036         

  1037     // Get the proxy address and port number

  1038     proxyAddress = HBufC::NewLC( gatewayAddrPtr.Length() );

  1039     TPtr proxyAddrPtr( proxyAddress->Des() );

  1040     SeparatePortNumberFromAddress( gatewayAddrPtr, proxyAddrPtr, 

  1041         proxyPortNumber );

  1042     proxyAddrPtr.TrimAll();

  1043     

  1044     // Check the launch browser package for gateway setting.

  1045     ipvType = ValidateGatewayAddress( proxyAddrPtr );

  1046     

  1047     if ( RPacketContext::EPdpTypeIPv4 == ipvType || \

  1048          RPacketContext::EPdpTypeIPv6 == ipvType )

  1049         {

  1050         LOG2( SIMPLE, 

  1051               "CLaunchBrowserHandler::GetAccessPointByGatewayAddressL \

  1052               gatewayAddrPtr.Length(): %d", gatewayAddrPtr.Length() )

  1053         // Check the launch browser package for bearer setting if the gateway

  1054         // address is valid.

  1055         LOG2( SIMPLE, 

  1056               "LAUNCHBROWSER: CLaunchBrowserHandler:: \

  1057               GetAccessPointByGatewayAddressL, IPvType is %d",

  1058               ipvType)

  1059         if ( gatewayAddrPtr.Length() )

  1060             {

  1061             // The bearer is GPRS.

  1062             if ( bearerListPtr != KNullDesC8 && bearerListPtr.Length() > 0 

  1063                     && RSat::KGprsBearer == bearerListPtr[0] )

  1064                 {

  1065                 

  1066                 // Go through the candidate connection methods to find 

  1067                 // the one matched the gateway address. If a matched one 

  1068                 // is found,using it as the access point for SIM service, 

  1069                 // else a new one is created.      

  1070                 RCmManager cmManager;

  1071                 cmManager.OpenLC();

  1072 

  1073                 // Get the Connection Methods does not belongs to 

  1074                 // any destination

  1075                 RArray<TUint32> array = RArray<TUint32>( 

  1076                                         KSatCMGranularity );

  1077                 CleanupClosePushL( array );

  1078 

  1079                 cmManager.ConnectionMethodL( array );

  1080 

  1081                 // Go through the Connection Method list to find 

  1082                 // if there is matched one

  1083                  

  1084                 for( TInt i = 0; 

  1085                      ( i < array.Count() ) && !exitConnectionMethodsLoop; 

  1086                      ++i )

  1087                     {

  1088                     RCmConnectionMethod cm = cmManager.ConnectionMethodL(

  1089                                                           array[i] );

  1090                     CleanupClosePushL( cm );

  1091                     

  1092                     // query the Gateway proxy address 

  1093                     // of the Connection Method

  1094                     pa = cm.GetStringAttributeL( 

  1095                          CMManager::ECmWapIPGatewayAddress );

  1096                     CleanupStack::PushL(pa);

  1097                     

  1098                     // query the Gateway proxy port number of the Connection 

  1099                     // Method

  1100                     pn = cm.GetIntAttributeL( 

  1101                             CMManager::ECmProxyPortNumber );

  1102                     

  1103                     if (( pn == proxyPortNumber ) && 

  1104                         ( *pa == *proxyAddress ))

  1105                         {

  1106                         // Find the matched connection method

  1107                         apId = cm.GetIntAttributeL( CMManager::ECmIapId );

  1108                         LOG2( SIMPLE, 

  1109                               "LAUNCHBROWSER: CLaunchBrowserHandler::\

  1110                               GetAccessPointByGatewayAddressL, apId=%d",

  1111                               apId )

  1112                         exitConnectionMethodsLoop = ETrue;

  1113                         }

  1114                         

  1115                     CleanupStack::PopAndDestroy( pa );

  1116                     CleanupStack::PopAndDestroy( &cm );

  1117                     }

  1118             

  1119                 CleanupStack::PopAndDestroy( &array );

  1120                 CleanupStack::PopAndDestroy( &cmManager );

  1121                 

  1122                 LOG2( SIMPLE, "LAUNCHBROWSER: CLaunchBrowserHandler:: \

  1123                       GetAccessPointByGatewayAddressL apId=%d", apId )

  1124                            

  1125                 if ( !apId )

  1126                     {

  1127                     // Create a new AP if there is not a matched one.

  1128                     apId = CreateAccessPointL( 

  1129                             satAPN,

  1130                             proxyAddrPtr,

  1131                             proxyPortNumber,

  1132                             static_cast<RPacketContext::TProtocolType>(

  1133                                                               ipvType ) );

  1134                     }