1 /*

     2 * Copyright (c) 2004 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 the License "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:  Implementation of class CCodAppUi.

    15 *

    16 */

    17 

    18 

    19 #include <avkon.hrh>

    20 #include <eikbtgpc.h>

    21 #include <eikapp.h>

    22 #include <apgcli.h>

    23 #include <CodUi.rsg>

    24 #include <avkon.rsg>

    25 #include <AknQueryDialog.h>

    26 #include <ErrorUi.h>

    27 #include <TextResolver.h>

    28 #include <AiwGenericParam.h>

    29 #include <DocumentHandler.h>

    30 #include <DcfRep.h>

    31 #include <RoapDef.h>

    32 #include <DRMCommon.h>

    33 #include <StringLoader.h>

    34 #include <CodEng.h>

    35 #include <CodData.h>

    36 #include <CodError.h>

    37 #include <CodStatus.h>

    38 #include <CodUtil.h>

    39 #include <RoapData.h>

    40 #include "CodAppUi.h"

    41 #include "CodView.h" 

    42 #include "CodDocument.h" 

    43 #include "CodWaitDialog.h" 

    44 #include "CodUi.hrh"

    45 #include "CodUiPanic.h"

    46 #include "RequestCompleteCallback.h"

    47 #include "CodUiResource.h"

    48 #include "CodLogger.h"

    49 #include "CodDialog.h"

    50 

    51 // ================= CONSTANTS =======================

    52 

    53 /// UID of Wml Browser.

    54 LOCAL_D const TInt KCodWmlBrowserUid = 0x10008D39;

    55 

    56 /// Message prefix, to launch browser with URL.

    57 _LIT( KCodMsgLaunchBrowserWithUrl, "4 " );

    58 

    59 /// Reserved word "local".

    60 _LIT8( KCodReservedWordLocal, "local" );

    61 

    62 /// Reserved word "back".

    63 _LIT8( KCodReservedWordBack, "back" );

    64 

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

    66 

    67 // ----------------------------------------------------------

    68 // CCodAppUi::CodDocument()

    69 // ----------------------------------------------------------

    70 //

    71 CCodDocument* CCodAppUi::CodDocument()

    72     {

    73     // Inline method must be defined before it is used.

    74     return STATIC_CAST( CCodDocument*, Document() );

    75     }

    76 

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

    78 // CCodAppUi::CCodAppUi()

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

    80 //

    81 CCodAppUi::CCodAppUi( TBool aCod )

    82 : iCod( aCod ),

    83   iCurrentCba( R_AVKON_SOFTKEYS_BACK ),

    84   iError( KErrNone ),

    85   iSilentMode( EFalse ),

    86   iSuppressNextUrl( EFalse ),

    87   iSuppressLaunch( EFalse ),

    88   iRoap( EFalse )

    89     {

    90     CLOG(( 2, _L("*** CCodAppUi::CCodAppUi") ));

    91     }

    92 

    93 // ----------------------------------------------------------

    94 // CCodAppUi::ConstructL()

    95 // ----------------------------------------------------------

    96 //

    97 void CCodAppUi::ConstructL()

    98     {

    99     iCodResource = CCodUiResource::NewL( *iEikonEnv );

   100     BaseConstructL( EAknEnableMSK );

   101     CodDocument()->Model().SetObserver( this );    

   102     iView = new (ELeave) CCodView;

   103     iView->SetMopParent( this );

   104     iView->ConstructL();

   105     iView->SetRect( ClientRect() );

   106     iView->ActivateL();

   107     iCallback = new ( ELeave ) CRequestCompleteCallback();

   108     iErrorUi = CErrorUI::NewL( *iCoeEnv );

   109     HandleModelChangeL();   // Initialize view with data.

   110     }

   111 

   112 // ----------------------------------------------------------

   113 // CCodAppUi::~CCodAppUi()

   114 // ----------------------------------------------------------

   115 //

   116 CCodAppUi::~CCodAppUi()

   117     {

   118     CLOG(( 2, _L("*** -> CCodAppUi::~CCodAppUi") ));

   119     delete iDocHandler;

   120     delete iDocParams;

   121     // First of all NULL out observer to avoid further callbacks.

   122     CodDocument()->Model().SetObserver( NULL );

   123     // We must Cancel the model before deleting the callback.

   124     CodDocument()->Model().Cancel();

   125     delete iCallback;

   126     delete iErrorUi;

   127     delete iWaitNote;

   128     delete iView;

   129     if ( iDoorObserver )

   130         {

   131         iDoorObserver->NotifyExit( MApaEmbeddedDocObserver::ENoChanges );

   132         }

   133     delete iCodResource;

   134     iFs.Close();

   135     CLOG(( 2, _L("<- CCodAppUi::~CCodAppUi") ));

   136     }

   137 

   138 // ----------------------------------------------------------

   139 // CCodAppUi::OpenFileDone()

   140 // ----------------------------------------------------------

   141 //

   142 void CCodAppUi::OpenFileDone( TInt aError )

   143     {

   144     CLOG(( 2, _L("-> CCodAppUi::OpenFileDone aError(%d)"), aError ));

   145     iError = aError;

   146     TRAPD( err, OpenFileDoneL() );

   147     if ( err )

   148         {

   149         RunAppShutter();

   150         }

   151     CLOG(( 2, _L("<- CCodAppUi::OpenFileDone") ));

   152     }

   153 

   154 // ----------------------------------------------------------

   155 // CCodAppUi::SetServiceFlow()

   156 // ----------------------------------------------------------

   157 //

   158 void CCodAppUi::SetServiceFlow

   159         (

   160         TBool aSilentMode,

   161         TBool aSuppressNextUrl,

   162         TBool aSuppressLaunch

   163         )

   164     {

   165     CLOG(( 2, \

   166         _L("CCodAppUi::SetServiceFlow silent(%d) noUrl(%d) noLaunch(%d)"), \

   167         aSilentMode, aSuppressNextUrl, aSuppressLaunch ));

   168     iSilentMode = aSilentMode;

   169     iSuppressNextUrl = aSuppressNextUrl;

   170     iSuppressLaunch = aSuppressLaunch;

   171     }

   172 

   173 // ----------------------------------------------------------

   174 // CCodAppUi::HandleModelChangeL()

   175 // ----------------------------------------------------------

   176 //

   177 void CCodAppUi::HandleModelChangeL()

   178     {

   179     CLOG(( 2, _L("-> CCodAppUi::HandleModelChangeL") ));

   180     TInt commandSet( R_AVKON_SOFTKEYS_BACK );

   181     const CCodData& data = CodDocument()->Model().Data();

   182     if ( data.IsValid() )

   183         {

   184         // Valid data: show details, show buttons "Accept" / "Reject".

   185         iView->SetDataL( data, iCod );

   186         commandSet = R_COD_UI_CBA_ACCEPT_REJECT;

   187         }

   188     else

   189         {

   190         // Invalid data: don't show details, show button "Back".

   191         iView->Clear();

   192         commandSet = R_AVKON_SOFTKEYS_BACK;

   193         }

   194     SetCbaL( commandSet );

   195     CLOG(( 2, _L("<- CCodAppUi::HandleModelChangeL") ));

   196     }

   197 

   198 // ----------------------------------------------------------

   199 // CCodAppUi::OpenFileL()

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

   201 //

   202 void CCodAppUi::OpenFileL( const TDesC& aFileName )

   203     {

   204     CLOG(( 2, _L("-> CCodAppUi::OpenFileL aFileName<%S>"), &aFileName ));

   205     Document()->OpenFileL( ETrue, aFileName, iCoeEnv->FsSession() );

   206     CLOG(( 2, _L("<- CCodAppUi::OpenFileL") ));

   207     }

   208 

   209 // ----------------------------------------------------------

   210 // CCodAppUi::HandleCommandL()

   211 // ----------------------------------------------------------

   212 //

   213 void CCodAppUi::HandleCommandL( TInt aCommand )

   214     {

   215     CLOG(( 2, _L("-> CCodAppUi::HandleCommandL aCommand(%d)"), \

   216         aCommand ));

   217     switch ( aCommand )

   218         {

   219         // From blank screen show during startup (incl. parsing).

   220         case EAknSoftkeyBack:

   221         // CAknShutter generated command.

   222         case EEikCmdExit:

   223             {

   224             Exit();

   225             break;

   226             }

   227 

   228         case EAknSoftkeyEmpty:

   229             {

   230             break;

   231             }

   232 

   233         case ECodUiCmdAccept:

   234             {

   235             // Safety code: ignore commands until completion of previous.

   236             // Quite unlikely to happen as we don't have this CBA.

   237             if( !CodDocument()->Model().IsActive() )

   238                 {

   239                 SetCbaL( R_AVKON_SOFTKEYS_EMPTY );

   240                 CodDocument()->Model().Accept( &iCallback->iStatus );

   241                 // Exit after processing is done.

   242                 iCallback->CallbackOnCompletion

   243                     ( TCallBack( StaticLoadDone, this ) );

   244                 }

   245             break;

   246             }

   247 

   248         case ECodUiCmdReject:

   249             {

   250             // Safety code: ignore commands until completion of previous.

   251             // Quite unlikely to happen as we don't have this CBA.

   252             if( !CodDocument()->Model().IsActive() )

   253                 {

   254                 SetCbaL( R_AVKON_SOFTKEYS_EMPTY );

   255                 CodDocument()->Model().Reject( &iCallback->iStatus );

   256                 iCallback->CallbackOnCompletion

   257                     ( TCallBack( StaticLoadDone, this ) );

   258                 }

   259             break;

   260             }

   261 

   262         case ECodUiCmdCancel:

   263             {

   264             CodDocument()->Model().Stop();

   265             break;

   266             }

   267 

   268         default:

   269             {

   270             CLOG(( 0, _L("  unknown command") ));

   271             __ASSERT_DEBUG

   272                 ( EFalse, CodUiPanic( ECodUiUnknownCommand ) );

   273             break;

   274             }

   275         }

   276     CLOG(( 2, _L("<- CCodAppUi::HandleCommandL") ));

   277     }

   278 

   279 // ----------------------------------------------------------

   280 // CCodAppUi::ProcessCommandParametersL()

   281 // ----------------------------------------------------------

   282 //

   283 TBool CCodAppUi::ProcessCommandParametersL

   284 ( TApaCommand aCommand, TFileName& /*aDocumentName*/, const TDesC8& /*aTail*/ )

   285     {

   286     if ( aCommand == EApaCommandOpen )

   287         {

   288         CLOG(( 2, _L("CCodAppUi::ProcessCommandParametersL: EApaCommandOpen - noop") ));

   289         // Do not handle this here - CAiwGenericParamList not ready

   290         //OpenFileL( aDocumentName );

   291         }

   292     return EFalse;

   293     }

   294 

   295 // ----------------------------------------------------------

   296 // CCodAppUi::HandleKeyEventL()

   297 // ----------------------------------------------------------

   298 //

   299 TKeyResponse CCodAppUi::HandleKeyEventL

   300 ( const TKeyEvent& aKeyEvent, TEventCode aType )

   301     {

   302     CLOG(( 2, _L("-> CCodAppUi::HandleKeyEventL") ));

   303     CLOG(( 3, _L("  aKeyEvent.iCode(%d)"), aKeyEvent.iCode ));

   304     CLOG(( 3, _L("  aKeyEvent.iScanCode(%d)"), aKeyEvent.iScanCode ));

   305     CLOG(( 3, _L("  aKeyEvent.iModifiers(%d)"), aKeyEvent.iModifiers ));

   306     CLOG(( 3, _L("  aKeyEvent.iRepeats(%d)"), aKeyEvent.iRepeats ));

   307     CLOG(( 3, _L("  aType(%d)"), aType ));

   308     TKeyResponse result = EKeyWasNotConsumed;

   309     if (

   310         ( aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter ) &&

   311         ( !(aKeyEvent.iModifiers & EModifierShift) ) &&

   312         ( iCurrentCba == R_COD_UI_CBA_ACCEPT_REJECT )

   313        )

   314         {

   315         // Selection key press is same as Accept softkey (provided we have

   316         // the Accept softkey).

   317         HandleCommandL( ECodUiCmdAccept );

   318         result = EKeyWasConsumed;

   319         }

   320     else if ( aKeyEvent.iCode == EKeyPhoneEnd &&

   321               iCurrentCba == R_COD_UI_CBA_ACCEPT_REJECT )

   322         {

   323         // Red key press -> Reject.

   324         HandleCommandL( ECodUiCmdReject );

   325         result = EKeyWasConsumed;

   326         }

   327     else

   328         {

   329         result = iView->OfferKeyEventL( aKeyEvent, aType );

   330         }

   331     CLOG(( 2, _L("<- CCodAppUi::HandleKeyEventL returns (0x%x)"), \

   332                                                                     result ));

   333     return result;

   334     }

   335 

   336 // ----------------------------------------------------------

   337 // CCodAppUi::HandleResourceChangeL()

   338 // ----------------------------------------------------------

   339 //

   340 void CCodAppUi::HandleResourceChangeL( TInt aType )

   341     {

   342     CAknAppUi::HandleResourceChangeL( aType );

   343     if ( aType == KEikDynamicLayoutVariantSwitch )

   344         {

   345         iView->SetRect( ClientRect() );

   346         }

   347     iView->HandleResourceChange( aType );

   348     }

   349 

   350 // ----------------------------------------------------------

   351 // CCodAppUi::GetRootPathL()

   352 // ----------------------------------------------------------

   353 //

   354 void CCodAppUi::GetRootPathL( TDes& aRootPath )

   355     {

   356     CLOG(( 2, _L("CCodAppUi::GetRootPathL") ));

   357     CodDialog::GetRootPathL( aRootPath );

   358     }

   359 

   360 // ----------------------------------------------------------

   361 // CCodAppUi::StartLoadL()

   362 // ----------------------------------------------------------

   363 //

   364 void CCodAppUi::StartLoadL( TInt aStatusCode )

   365     {

   366     CLOG(( 2, _L("-> CCodAppUi::StartLoadL aStatusCode(%d)"), \

   367         aStatusCode ));

   368     __ASSERT_DEBUG( !iWaitNote, CodUiPanic( ECodUiInternal ) );

   369 

   370     TInt resId = R_QTN_CD_WAIT_PLEASE_WAIT;

   371     if ( aStatusCode == KHttp900Success )

   372         {

   373         resId = R_QTN_CD_WAIT_DOWNLOADING;

   374         }

   375     else if ( aStatusCode == KHttp921UserAborted )

   376         {

   377         resId = R_QTN_CD_WAIT_REJECT;

   378         }

   379     iWaitNote = new (ELeave) CCodWaitDialog

   380         ( REINTERPRET_CAST( CEikDialog**, &iWaitNote ), *this );

   381     iWaitNote->PrepareLC( R_COD_UI_WAIT_NOTE );

   382     iWaitNote->SetTextL( resId );

   383     iWaitNote->RunLD();

   384     CLOG(( 2, _L("<- CCodAppUi::StartLoadL") ));

   385     }

   386 

   387 // ----------------------------------------------------------

   388 // CCodAppUi::StartCancelL()

   389 // ----------------------------------------------------------

   390 //

   391 void CCodAppUi::StartCancelL()

   392     {

   393     CLOG(( 2, _L("-> CCodAppUi::StartCancelL") ));

   394     __ASSERT_DEBUG( iWaitNote, CodUiPanic( ECodUiInternal ) );

   395     iWaitNote->SetTextL( R_QTN_CD_WAIT_REJECT );

   396     CLOG(( 2, _L("<- CCodAppUi::StartCancelL") ));

   397     }

   398 

   399 // ----------------------------------------------------------

   400 // CCodAppUi::ProgressL()

   401 // ----------------------------------------------------------

   402 //

   403 void CCodAppUi::ProgressL( TInt /*aFinalValue*/, TInt /*aCurrentValue*/ )

   404     {

   405     // TODO

   406     }

   407 

   408 // ----------------------------------------------------------

   409 // CCodAppUi::Done()

   410 // ----------------------------------------------------------

   411 //

   412 void CCodAppUi::Done( TInt LOG_ONLY( aStatusCode ), TInt LOG_ONLY( aError ) )

   413     {

   414     CLOG(( 2, _L("-> CCodAppUi::Done aStatusCode(%d) aError(%d)"), \

   415         aStatusCode, aError ));

   416     delete iWaitNote;

   417     iWaitNote = NULL;

   418     CLOG(( 2, _L("<- CCodAppUi::Done") ));

   419     }

   420 

   421 // ----------------------------------------------------------

   422 // CCodAppUi::ConfirmConnectL()

   423 // ----------------------------------------------------------

   424 //

   425 TBool CCodAppUi::ConfirmConnectL()

   426     {

   427     CLOG(( 2, _L("CCodAppUi::ConfirmConnectL") ));

   428     return CodDialog::ConfirmConnectL();

   429     }

   430 

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

   432 // CCodAppUi::StartConnect()

   433 // ----------------------------------------------------------

   434 //

   435 void CCodAppUi::StartConnect( TUint32 LOG_ONLY( aIap ) )

   436     {

   437     CLOG(( 2, _L("CCodAppUi::StartConnect aIap(%d)"), aIap ));

   438     }

   439 

   440 // ----------------------------------------------------------

   441 // CCodAppUi::EndConnect()

   442 // ----------------------------------------------------------

   443 //

   444 void CCodAppUi::EndConnect()

   445     {

   446     CLOG(( 2, _L("CCodAppUi::EndConnect") ));

   447     }

   448 

   449 // ----------------------------------------------------------

   450 // CCodAppUi::WaitForLicenseL()

   451 // ----------------------------------------------------------

   452 //

   453 void CCodAppUi::WaitForLicenseL()

   454     {

   455     CLOG(( 2, _L("CCodAppUi::WaitForLicenseL") ));

   456     }

   457 

   458 

   459 // ----------------------------------------------------------

   460 // CCodAppUi::UserAuthL()

   461 // ----------------------------------------------------------

   462 //

   463 TBool CCodAppUi::UserAuthL

   464         (

   465         const TDesC& LOG_ONLY( aHost ),

   466         const TDesC& LOG_ONLY( aRealm ),

   467         TBool LOG_ONLY( aProxyAuth ),

   468         TDes& aUsername,

   469         TDes& aPassword

   470         )

   471     {

   472     CLOG(( 2, _L("CCodAppUi::UserAuthL") ));

   473     CLOG(( 3, _L("  aHost<%S>"), &aHost ));

   474     CLOG(( 3, _L("  aRealm<%S>"), &aRealm ));

   475     CLOG(( 3, _L("  aProxyAuth(0x%x)"), aProxyAuth ));

   476     // Feature dropped - empty implementation.

   477     aUsername.Zero();

   478     aPassword.Zero();

   479     return ETrue;

   480     }

   481 

   482 // ----------------------------------------------------------

   483 // CCodAppUi::RoapTriggerParsedL()

   484 // ----------------------------------------------------------

   485 //

   486 void CCodAppUi::RoapTriggerParsedL( const CRoapData& aData )

   487     {

   488     CLOG(( 2, _L("-> CCodAppUi::RoapTriggerParsedL") ));

   489     iRoap = ETrue;

   490     if ( aData.iContextStatus == Roap::EInvalidContext )

   491         {

   492         // No valid RI context, ROAP will involve device registration.

   493         // User must confirm.

   494         CLOG(( 4, _L("  invalid context") ));

   495         CAknQueryDialog* dialog = CAknQueryDialog::NewL();

   496         dialog->PrepareLC( R_COD_UI_CONFIRM_NOTE );

   497         HBufC* prompt;

   498         if ( aData.iRiAlias )

   499             {

   500             // "Registration with %U needed. Register phone?"

   501             HBufC* riAlias16 = CodUtil::ConvertLC( *aData.iRiAlias );

   502             prompt = StringLoader::LoadL

   503                 ( R_QTN_DRM_QUERY_REGISTER_WITH_U, *riAlias16, iCoeEnv );

   504             CleanupStack::PopAndDestroy( riAlias16 );

   505             CleanupStack::PushL( prompt );

   506             }

   507         else

   508             {

   509             // "Registration with content provider needed. Register phone?"

   510             prompt = StringLoader::LoadLC

   511                 ( R_QTN_DRM_QUERY_REGISTER_WITH_CP, iCoeEnv );

   512             }

   513         dialog->SetPromptL( *prompt );

   514         CleanupStack::PopAndDestroy( prompt );

   515         if ( !dialog->RunLD() ) 

   516             {

   517             CLOG(( 4, _L("  cancelled") ));

   518             User::Leave( KErrCancel );

   519             }

   520         }

   521     // Update the wait note with ROAP-specific text.

   522     TInt resId = 0;

   523     switch ( aData.iType )

   524         {

   525         case Roap::ERegistrationTrigger:

   526             {

   527             resId = R_QTN_DRM_WAIT_REGISTERING_DEVICE;

   528             break;

   529             }

   530         case Roap::ERoAcquisitionTrigger:

   531             {

   532             resId = R_QTN_DRM_WAIT_GETTING_KEY;

   533             break;

   534             }

   535         case Roap::EJoinDomainTrigger:

   536             {

   537             if ( aData.iDomainOperation == Roap::EJoinDomainOperation )

   538                 {

   539                 resId = R_QTN_DRM_WAIT_JOINING_DOMAIN;

   540                 }

   541             else

   542                 {

   543                 resId = R_QTN_DRM_WAIT_UPDATING_ACCOUNT;

   544                 }

   545             break;

   546             }

   547         case Roap::ELeaveDomainTrigger:

   548             {

   549             resId = R_QTN_DRM_WAIT_REMOVE_FR_ACCOUNT;

   550             break;

   551             }

   552         default:

   553             {

   554             User::Leave( KErrNotSupported );

   555             break;

   556             }

   557         }

   558     __ASSERT_DEBUG( resId, CodUiPanic( ECodUiInternal ) );

   559     TBool newNote( EFalse );

   560     if ( !iWaitNote )

   561         {

   562         iWaitNote = new (ELeave) CCodWaitDialog

   563             ( REINTERPRET_CAST( CEikDialog**, &iWaitNote ), *this );

   564         iWaitNote->PrepareLC( R_COD_UI_WAIT_NOTE );

   565         }

   566     iWaitNote->SetTextL( resId );

   567     if ( newNote )

   568         {

   569         iWaitNote->RunLD();

   570         }

   571     CLOG(( 2, _L("<- CCodAppUi::RoapTriggerParsedL") ));

   572     }

   573 

   574 // ----------------------------------------------------------

   575 // CCodAppUi::HandleDialogCommandL()

   576 // ----------------------------------------------------------

   577 //

   578 void CCodAppUi::HandleDialogCommandL( TInt aCommand )

   579     {

   580     CLOG(( 2, _L("-> CCodAppUi::HandleDialogCommandL aCommand(%d)"), \

   581         aCommand ));

   582     HandleCommandL( aCommand );

   583     CLOG(( 2, _L("<- CCodAppUi::HandleDialogCommandL") ));

   584     }

   585 

   586 // ----------------------------------------------------------

   587 // CCodAppUi::HandleServerAppExit()

   588 // ----------------------------------------------------------

   589 //

   590 void CCodAppUi::HandleServerAppExit( TInt /*aReason*/ )

   591     {

   592     CLOG(( 2, _L("-> CCodAppUi::HandleServerAppExit") ));

   593     TRAP_IGNORE( ActivateNextUrlL() );

   594     RunAppShutter();

   595     CLOG(( 2, _L("<- CCodAppUi::HandleServerAppExit") ));

   596     }

   597 

   598 // ----------------------------------------------------------

   599 // CCodAppUi::OpenFileDoneL()

   600 // ----------------------------------------------------------

   601 //

   602 void CCodAppUi::OpenFileDoneL()

   603     {

   604     CLOG(( 2, _L("-> CCodAppUi::OpenFileDoneL") ));

   605     if ( iError )

   606         {

   607         LoadDoneL();

   608         }

   609     else

   610         {

   611         HandleModelChangeL();

   612         }

   613     CLOG(( 2, _L("<- CCodAppUi::OpenFileDoneL") ));

   614     }

   615 

   616 // ----------------------------------------------------------

   617 // CCodAppUi::StaticLoadDone()

   618 // ----------------------------------------------------------

   619 //

   620 TInt CCodAppUi::StaticLoadDone( TAny* aPtr )

   621     {

   622     STATIC_CAST( CCodAppUi*, aPtr )->LoadDone();

   623     return EFalse;  // TCallback should return EFalse as TInt.

   624     }

   625 

   626 // ----------------------------------------------------------

   627 // CCodAppUi::LoadDone()

   628 // ----------------------------------------------------------

   629 //

   630 void CCodAppUi::LoadDone()

   631     {

   632     CLOG(( 2, _L("-> CCodAppUi::LoadDone") ));

   633     iError = iCallback->iStatus.Int();

   634     TRAPD( err, LoadDoneL() );

   635     if ( err )

   636         {

   637         RunAppShutter();

   638         }

   639     CLOG(( 2, _L("<- CCodAppUi::LoadDone") ));

   640     }

   641 

   642 // ----------------------------------------------------------

   643 // CCodAppUi::LoadDoneL()

   644 // ----------------------------------------------------------

   645 //

   646 void CCodAppUi::LoadDoneL()

   647     {

   648     CLOG(( 2, _L("-> CCodAppUi::LoadDoneL iError(%d)"), iError ));

   649     TBool exitApp( ETrue );

   650     if ( CodDocument()->Model().GetPath().Length() )

   651         {

   652         // ROAP involved loading a file, treat as download and not as ROAP.

   653         iRoap = EFalse;

   654         }

   655     // No service flow for Cancel or Reject.

   656     if ( iError != KErrCancel && iError != KErrAbort )

   657         {

   658         if ( iRoap )

   659             {

   660             if ( iError )

   661                 {

   662                 exitApp = RoapFailedL();

   663                 }

   664             else

   665                 {

   666                 exitApp = RoapOkL();

   667                 }

   668             }

   669         else

   670             {

   671             if ( iError )

   672                 {

   673                 exitApp = LoadFailedL();

   674                 }

   675             else

   676                 {

   677                 exitApp = LoadOkL();

   678                 }

   679             }

   680         if ( exitApp )

   681             {

   682             ActivateNextUrlL();

   683             }

   684         }

   685     if ( exitApp )

   686         {

   687         RunAppShutter();

   688         }

   689     CLOG(( 2, _L("<- CCodAppUi::LoadDoneL") ));

   690     }

   691 

   692 // ----------------------------------------------------------

   693 // CCodAppUi::LoadOkL()

   694 // ----------------------------------------------------------

   695 //

   696 TBool CCodAppUi::LoadOkL()

   697     {

   698     CLOG(( 2, _L("-> CCodAppUi::LoadOkL") ));

   699     __ASSERT_DEBUG( !iRoap, CodUiPanic( ECodUiInternal ) );

   700     __ASSERT_DEBUG( !iError, CodUiPanic( ECodUiInternal ) );

   701     TBool exitApp( ETrue ); // Exit by default.

   702     // Show "File saved to..." note.

   703     TUid handler = CodDocument()->Model().GetHandler();

   704     RApaLsSession apaLsSess;

   705     User::LeaveIfError( apaLsSess.Connect() );

   706     CleanupClosePushL<RApaLsSession>( apaLsSess );

   707     TApaAppInfo appInfo;

   708     User::LeaveIfError( apaLsSess.GetAppInfo( appInfo, handler ) );

   709     CleanupStack::PopAndDestroy();  // apaLsSess 

   710     HBufC* prompt = StringLoader::LoadLC

   711         ( R_QTN_FLDR_FILE_SAVED_TO, appInfo.iCaption, iCoeEnv );

   712     CodDialog::ConfNoteL( *prompt );

   713     CleanupStack::PopAndDestroy( prompt );

   714     // Launch content, if applicable (DD or 'local' COD).

   715     if ( !iCod || !CodDocument()->Model().Data().NextUrl().Compare

   716                                             ( KCodReservedWordLocal ) )

   717         {

   718         exitApp = LaunchContentL( CodDocument()->Model().GetPath(),

   719                                 CodDocument()->Model().GetType().Des8() );

   720         }

   721     CLOG(( 2, _L("<- CCodAppUi::LoadOkL (%d)"), exitApp ));

   722     return exitApp;

   723     }

   724 

   725 // ----------------------------------------------------------

   726 // CCodAppUi::LoadFailedL()

   727 // ----------------------------------------------------------

   728 //

   729 TBool CCodAppUi::LoadFailedL()

   730     {

   731     CLOG(( 2, _L("-> CCodAppUi::LoadFailedL") ));

   732     __ASSERT_DEBUG( !iRoap, CodUiPanic( ECodUiInternal ) );

   733     __ASSERT_DEBUG( iError, CodUiPanic( ECodUiInternal ) );

   734     TInt resId = 0;

   735     if ( iError == KErrCodNoAccessPoint )

   736         {

   737         // "No access point" error has the same status code as all connection

   738         // related errors, but needs different note.

   739         resId = R_QTN_CD_INFO_NO_VALID_AP;

   740         }

   741     else

   742         {

   743         // Investigating status code (which carries less information than the

   744         // error code) is generally enough to get the correct note.

   745         switch( CodDocument()->Model().GetStatusCode() )

   746             {

   747             case KHttp900Success:

   748             case KHttp902UserCancelled:

   749             case KHttp921UserAborted:

   750                 {

   751                 // No error note shown for user cancel.

   752                 // (Sanity code, we never get here for user Cancel.)

   753                 iError = KErrNone;

   754                 break;

   755                 }

   756                 

   757             case KHttp910NoMemory:

   758             case KHttp901InsufficientMemory:

   759                 {

   760                 resId = R_QTN_CD_INFO_NOT_ENOUGH_MEM;

   761                 break;

   762                 }

   763 

   764             case KHttp903LossOfService:

   765                 {

   766                 // User Text Resolver to get "Connection timeout".

   767                 iError = KErrCodHttpNoResponse;

   768                 break;

   769                 }

   770 

   771             case KHttp906InvalidDescriptor:

   772                 {

   773                 resId = R_QTN_CD_INFO_SYNTAX_ERR;

   774                 break;

   775                 }

   776 

   777             case KHttp922DeviceAborted:

   778             case KHttp952DeviceAborted:

   779                 {

   780                 resId = R_QTN_CD_INFO_UNKNOWN_TYPE;

   781                 break;

   782                 }

   783 

   784             case KHttp905AttributeMismatch:

   785             case KHttp923NonAcceptableContent:

   786             case KHttp953NonAcceptableContent:

   787                 {

   788                 resId = R_QTN_CD_INFO_UNSUPP_MIME_TYPE;

   789                 break;

   790                 }

   791 

   792             case KHttp924LoaderError:

   793             case KHttp954LoaderError:

   794             case KHttp951InvalidDdVersion:

   795                 {

   796                 resId = R_QTN_CD_INFO_GENERIC_ERROR;

   797                 break;

   798                 }

   799 

   800             default:

   801                 {

   802                 __ASSERT_DEBUG

   803                     ( EFalse, CodUiPanic( ECodUiUnknownStatus ) );

   804                 break;

   805                 }

   806             }

   807         }

   808 

   809     if ( resId )

   810         {

   811         CodDialog::InfoNoteL( resId, *iCoeEnv );

   812         }

   813     else if ( iError )

   814         {

   815         TPtrC msg( iErrorUi->TextResolver().ResolveErrorString( iError ) );

   816         CodDialog::InfoNoteL( msg );

   817         }

   818     CLOG(( 2, _L("<- CCodAppUi::LoadFailedL") ));

   819     return ETrue;

   820     }

   821 

   822 // ----------------------------------------------------------

   823 // CCodAppUi::RoapOkL()

   824 // ----------------------------------------------------------

   825 //

   826 TBool CCodAppUi::RoapOkL()

   827     {

   828     CLOG(( 2, _L("-> CCodAppUi::RoapOkL") ));

   829     __ASSERT_DEBUG( iRoap, CodUiPanic( ECodUiInternal ) );

   830     __ASSERT_DEBUG( !iError, CodUiPanic( ECodUiInternal ) );

   831     TBool exitApp( ETrue );

   832     const CRoapData* roapData = CodDocument()->Model().GetRoapData();

   833     if ( roapData ) // Safety code.

   834         {

   835         switch( roapData->iType )

   836             {

   837             case Roap::ERegistrationTrigger:

   838                 {

   839                 CodDialog::ConfNoteL

   840                     ( R_QTN_DRM_CONF_DEVICE_REGISTERED, *iCoeEnv );

   841                 break;

   842                 }

   843             case Roap::ERoAcquisitionTrigger:

   844                 {

   845                 exitApp = RoAcqOkL();

   846                 break;

   847                 }

   848             case Roap::EJoinDomainTrigger:

   849                 {

   850                 if ( roapData->iDomainOperation == Roap::EJoinDomainOperation )

   851                     {

   852                     CodDialog::ConfNoteL

   853                         ( R_QTN_DRM_CONF_JOINED_TO_DOMAIN, *iCoeEnv );

   854                     }

   855                 else

   856                     {

   857                     CodDialog::ConfNoteL

   858                         ( R_QTN_DRM_CONF_ACCOUNT_UPDATED, *iCoeEnv );

   859                     }

   860                 break;

   861                 }

   862             case Roap::ELeaveDomainTrigger:

   863                 {

   864                 CodDialog::ConfNoteL

   865                     ( R_QTN_DRM_INFO_REMOVE_FR_ACCOUNT, *iCoeEnv );

   866                 break;

   867                 }

   868             default:

   869                 {

   870                 // We should never get here.

   871                 __ASSERT_DEBUG( EFalse, CodUiPanic( ECodUiInternal ) );

   872                 }

   873             }

   874         }

   875     CLOG(( 2, _L("<- CCodAppUi::RoapOkL returns(%d)"), exitApp ));

   876     return exitApp;

   877     }

   878 

   879 // ----------------------------------------------------------

   880 // CCodAppUi::RoAcqOkL()

   881 // ----------------------------------------------------------

   882 //

   883 TBool CCodAppUi::RoAcqOkL()

   884     {

   885     CLOG(( 2, _L("-> CCodAppUi::RoAcqOkL") ));

   886     const CRoapData* roapData = CodDocument()->Model().GetRoapData();

   887     __ASSERT_DEBUG ( roapData, CodUiPanic( ECodUiInternal ) );

   888     __ASSERT_DEBUG ( roapData->iType == \

   889         Roap::ERoAcquisitionTrigger, CodUiPanic( ECodUiInternal ) );

   890 

   891     TFileName name;    // Note, filename and extension only! Not full path.

   892     TDataType type;

   893     TUid appUid( TUid::Null() );

   894     RFile f;

   895     CleanupClosePushL<RFile>( f );

   896     if ( !iSilentMode && !iSuppressLaunch && roapData->iContentIdList.Count() )

   897         {

   898         __ASSERT_DEBUG( !iFs.Handle(), CodUiPanic( ECodUiInternal ) );

   899         User::LeaveIfError( iFs.Connect() );

   900         User::LeaveIfError( iFs.ShareProtected() );

   901         CDcfRep* dcfRep = CDcfRep::NewL();

   902         CleanupStack::PushL( dcfRep );

   903         // It is not specified what to do if we have more content ids.

   904         // Best guess: open the first.

   905         TPtrC8 cid( *(roapData->iContentIdList[0]) );

   906         TRAPD( err, dcfRep->GetFileHandleL ( cid, f, iFs ) );

   907         if ( !err && CodUtil::CanOpenL( f ) )

   908             {

   909             User::LeaveIfError( f.Name( name ) );

   910             RApaLsSession apaLs;

   911             User::LeaveIfError( apaLs.Connect() );

   912             CleanupClosePushL<RApaLsSession>( apaLs );

   913             User::LeaveIfError( apaLs.AppForDocument( f, appUid, type ) );

   914             CleanupStack::PopAndDestroy();  // apaLs

   915             }

   916         CleanupStack::PopAndDestroy( dcfRep );

   917         }

   918 

   919     TBool exitApp( ETrue );

   920     if ( appUid.iUid )

   921         {

   922         // MO (related to the received RO) is already here and is supported

   923         // by the system. Ask user if he wants to open it now.

   924         __ASSERT_DEBUG( iFs.Handle(), CodUiPanic( ECodUiInternal ) );

   925         __ASSERT_DEBUG( f.SubSessionHandle(), CodUiPanic( ECodUiInternal ) );

   926         __ASSERT_DEBUG( name.Length(), CodUiPanic( ECodUiInternal ) );

   927         CAknQueryDialog* dialog = CAknQueryDialog::NewL();

   928         dialog->PrepareLC( R_COD_UI_CONFIRM_NOTE );

   929         HBufC* prompt = StringLoader::LoadLC

   930             ( R_QTN_DRM_QUERY_KEY_RECEIVED_OPEN, name, iEikonEnv );

   931         dialog->SetPromptL( *prompt );

   932         CleanupStack::PopAndDestroy( prompt );

   933         if ( dialog->RunLD() ) 

   934             {

   935             __ASSERT_DEBUG( !iDocHandler, CodUiPanic( ECodUiInternal ) );

   936             __ASSERT_DEBUG( !iDocParams, CodUiPanic( ECodUiInternal ) );

   937             iDocHandler = CDocumentHandler::NewL();

   938             iDocHandler->SetExitObserver( this );

   939             iDocParams = CAiwGenericParamList::NewL();

   940             User::LeaveIfError

   941                 ( iDocHandler->OpenFileEmbeddedL( f, type, *iDocParams ) );

   942             exitApp = EFalse;

   943             }

   944         }

   945     else

   946         {

   947         CodDialog::ConfNoteL( R_QTN_DRM_INFO_ACT_KEY_RECEIVED, *iCoeEnv );

   948         }

   949     CleanupStack::PopAndDestroy( &f );

   950     CLOG(( 2, _L("<- CCodAppUi::RoAcqOkL returns(%d)"), exitApp ));

   951     return exitApp;

   952     }

   953 

   954 // ----------------------------------------------------------

   955 // CCodAppUi::RoapFailedL()

   956 // ----------------------------------------------------------

   957 //

   958 TBool CCodAppUi::RoapFailedL()

   959     {

   960     CLOG(( 2, _L("-> CCodAppUi::RoapFailedL iError(%d)"), iError ));

   961     __ASSERT_DEBUG( iRoap, CodUiPanic( ECodUiInternal ) );

   962     __ASSERT_DEBUG( iError, CodUiPanic( ECodUiInternal ) );

   963     TBool exitApp( ETrue );

   964     TInt resId = 0;

   965     const CRoapData* roapData = CodDocument()->Model().GetRoapData();

   966     if ( roapData ) // Safety code

   967         {

   968         // Some errors need specific message.

   969         switch ( iError )

   970             {

   971             case KErrRoapDomainFull:

   972                 {

   973                 resId = R_QTN_DRM_INFO_ACCOUNT_IS_FULL;

   974                 break;

   975                 }

   976             case KErrRoapInvalidDomain:

   977                 {

   978                 resId = R_QTN_DRM_ACCOUNT_NOT_RECOGNISED;

   979                 break;

   980                 }

   981             case KErrRoapServer:

   982                 {

   983                 // Temporary server error. For RoAcq, offer retry; for other

   984                 // ROAP-s, fall through to default handling (plain error note).

   985                 if ( roapData->iType == Roap::ERoAcquisitionTrigger )

   986                     {

   987                     CAknQueryDialog* dialog = CAknQueryDialog::NewL();

   988                     dialog->PrepareLC( R_COD_UI_CONFIRM_NOTE );

   989                     HBufC* prompt = StringLoader::LoadLC

   990                         ( R_QTN_DRM_GET_KEY_FAILED_RETRY, iEikonEnv );

   991                     dialog->SetPromptL( *prompt );

   992                     CleanupStack::PopAndDestroy( prompt );

   993                     if ( dialog->RunLD() ) 

   994                         {

   995                         HandleCommandL( ECodUiCmdAccept );

   996                         exitApp = EFalse;

   997                         }

   998                     break;

   999                     }

  1000                 // Not RoAcq: fall through to default (error note).

  1001                 }

  1002             default:

  1003                 {

  1004                 // Default error message is based on trigger type.

  1005                 switch ( roapData->iType )

  1006                     {

  1007                     case Roap::ERegistrationTrigger:

  1008                         {

  1009                         resId = R_QTN_DRM_INFO_DEVICE_REGIST_FAIL;

  1010                         break;

  1011                         }

  1012                     case Roap::ERoAcquisitionTrigger:

  1013                         {

  1014                         resId = R_QTN_DRM_INFO_GETTING_KEY_FAILED;

  1015                         break;

  1016                         }

  1017                     case Roap::EJoinDomainTrigger:

  1018                         {

  1019                         if ( roapData->iDomainOperation ==

  1020                              Roap::EJoinDomainOperation )

  1021                             {

  1022                             resId = R_QTN_DRM_INFO_REGISTRATION_FAILED;

  1023                             }

  1024                         else

  1025                             {

  1026                             resId = R_QTN_DRM_INFO_UPDATE_DOMAIN_FAIL;

  1027                             }

  1028                         break;

  1029                         }

  1030                     case Roap::ELeaveDomainTrigger:

  1031                         {

  1032                         resId = R_QTN_DRM_REMOVE_FR_ACCOUNT_FAIL;

  1033                         break;

  1034                         }

  1035                     default:

  1036                         {

  1037                         __ASSERT_DEBUG( EFalse, \

  1038                             CodUiPanic( ECodUiInternal ) );

  1039                         }

  1040                     }

  1041                 break;

  1042                 }

  1043             }

  1044         if( resId )

  1045             {

  1046             CodDialog::InfoNoteL( resId, *iCoeEnv );

  1047             }

  1048         }

  1049     CLOG(( 2, _L("<- CCodAppUi::RoapFailedL returns(%d)"), exitApp ));

  1050     return exitApp;

  1051     }

  1052 

  1053 // ----------------------------------------------------------

  1054 // CCodAppUi::LaunchContentL()

  1055 // ----------------------------------------------------------

  1056 //

  1057 TBool CCodAppUi::LaunchContentL( const TDesC& aFname, const TDesC8& aType )

  1058     {

  1059     CLOG(( 2, _L("-> CCodAppUi::LaunchContentL") ));

  1060     CLOG(( 3, _L("  aFile==<%S>"), &aFname ));

  1061     CLOG(( 3, _L8("  aType==<%S>"), &aType ));

  1062     TBool exitApp( ETrue ); // Exit by default.

  1063     if ( !iSilentMode &&

  1064          !iSuppressLaunch &&

  1065          aFname.Length() &&

  1066          CodUtil::CanOpenL( aFname )

  1067        )

  1068         {

  1069         __ASSERT_DEBUG( !iDocHandler, CodUiPanic( ECodUiInternal ) );

  1070         __ASSERT_DEBUG( !iDocParams, CodUiPanic( ECodUiInternal ) );

  1071         iDocHandler = CDocumentHandler::NewL();

  1072         iDocHandler->SetExitObserver( this );

  1073         iDocParams = CAiwGenericParamList::NewL();

  1074         // Need to copy argument; DocHandler takes non-const TDataType :-(

  1075         TDataType type( aType );

  1076         __ASSERT_DEBUG( !iFs.Handle(), CodUiPanic( ECodUiInternal ) );

  1077         User::LeaveIfError( iFs.Connect() );

  1078         User::LeaveIfError( iFs.ShareProtected() );

  1079         RFile f;

  1080         CleanupClosePushL<RFile>( f );

  1081         User::LeaveIfError( f.Open( iFs, aFname, EFileShareReadersOnly ) );

  1082         User::LeaveIfError

  1083             ( iDocHandler->OpenFileEmbeddedL( f, type, *iDocParams ) );

  1084         CleanupStack::PopAndDestroy( &f );

  1085         exitApp = EFalse;

  1086         }

  1087     CLOG(( 2, _L("<- CCodAppUi::LaunchContentL (%d)"), exitApp ));

  1088     return exitApp;

  1089     }

  1090 

  1091 // ----------------------------------------------------------

  1092 // CCodAppUi::ActivateNextUrlL()

  1093 // ----------------------------------------------------------

  1094 //

  1095 void CCodAppUi::ActivateNextUrlL()

  1096     {

  1097     CLOG(( 2, _L("-> CCodAppUi::ActivateNextUrlL") ));

  1098     TPtrC8 url;

  1099     TBool back( EFalse );

  1100 

  1101     if ( iSilentMode || iSuppressNextUrl )

  1102         {

  1103         CLOG(( 2, _L("<- CCodAppUi::ActivateNextUrlL (off)") ));

  1104         return;

  1105         }

  1106 

  1107     const CCodData& data = CodDocument()->Model().Data();

  1108     

  1109     if( iCod )

  1110         {

  1111         // This is a COD: choose between Next-URL or Next_URLatError.

  1112         if ( CodDocument()->Model().GetStatusCode() == KHttp900Success )

  1113             {

  1114             url.Set( data.NextUrl() );

  1115             }

  1116         else

  1117             {

  1118             url.Set( data.NextUrlAtError() );

  1119             }

  1120         // Recognize 'back' or 'local'.

  1121         if ( url.Length() )

  1122             {

  1123             if ( !url.Compare( KCodReservedWordLocal ) )

  1124                 {

  1125                 // 'local' -> no URL to launch.

  1126                 url.Set( KNullDesC8 );

  1127                 }

  1128             else if ( !url.Compare( KCodReservedWordBack ) )

  1129                 {

  1130                 // 'back' -> no URL to launch.

  1131                 url.Set( KNullDesC8 );

  1132                 back = ETrue;

  1133                 }

  1134             }