/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*      Implementation of class CRoapAppUi.   

*      

*

*/

#include <avkon.hrh>

#include <eikbtgpc.h>

#include <eikapp.h>

#include <apgcli.h>

#include <RoapApp.rsg>

#include <avkon.rsg>

#include <AknNoteWrappers.h>

#include <AknQueryDialog.h>

#include <StringLoader.h>

#include <DocumentHandler.h>

#include <DcfRep.h>

#include <caf/caf.h>

#include <DRMCommon.h>

#include <aknmessagequerydialog.h>

#include <AknNoteDialog.h>                  

#include <FeatMgr.h>                    

#include <hlplch.h>             

#include <RoapDef.h>

#include "RoapAppUi.h"

#include "RoapAppView.h" 

#include "RoapAppDocument.h" 

#include "RoapAppData.h" 

#include "RoapAppWaitDialog.h" 

#include "RoapApp.hrh"

#include "RoapAppPanic.h"

#include "RequestCompleteCallback.h"

#include "RoapAppLogger.h"

#include <HttpDownloadMgrCommon.h>

#ifdef __SERIES60_HELP

// Context-Sensitve Help File

#include <csxhelp/drm.hlp.hrh>

#endif // __SERIES60_HELP

// ================= CONSTANTS =======================

/// Temp file directory:

_LIT( KRoapTempFilePath, "c:\\system\\temp\\" );

/// Next Line

_LIT( KNextLine, "\n" );

// ROAP App UID

LOCAL_D const TUid KROAPAppUid = { 0x10008d64 };

// BrowserNG UID

LOCAL_D const TUid KCRUidBrowser   = {0x10008D39};

// KBrowserDefaultAccessPoint

LOCAL_D const TInt KBrowserDefaultAccessPoint = 0x0E;

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

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

// CRoapAppUi::CRoapAppUi()

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

//

CRoapAppUi::CRoapAppUi()

    {

    CLOG(( 2, _L("*** CRoapAppUi::CRoapAppUi") ));

    }

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

// CRoapAppUi::ConstructL()

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

//

void CRoapAppUi::ConstructL()

    {

    BaseConstructL( EAknEnableMSK | EAknEnableSkin );

    iView = CRoapAppView::NewL( ClientRect(), this );

    iCallback = new ( ELeave ) CRequestCompleteCallback();

    TRAPD( err, iDownloadMgr.ConnectL( KROAPAppUid, *this, EFalse ) );

	User::LeaveIfError(err);

#ifndef __WINSCW__

    CRepository *repository = CRepository::NewL( KCRUidBrowser );

    TInt retVal(0);

    repository->Get(KBrowserDefaultAccessPoint, retVal);

    delete repository;

    repository = NULL;

    CLOG(( 2, _L("   KBrowserDefaultAccessPoint: %d"), retVal ));

    iDownloadMgr.SetIntAttribute(EDlMgrIap, retVal );

#endif

    iPostResponseURLDownLoad = EFalse;	

    }

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

// CRoapAppUi::~CRoapAppUi()

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

//

CRoapAppUi::~CRoapAppUi()

    {

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

    if( iDownloadMgr.Handle() )

 	    {

 	    iDownloadMgr.DeleteAll();

 	    iDownloadMgr.Close();

 	    }

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

    RoapDocument()->Engine().Cancel();

    delete iCallback;

    delete iDocHandler;

    delete iWaitNote;

    delete iView;

    if ( iDoorObserver )

        {

        iDoorObserver->NotifyExit( MApaEmbeddedDocObserver::ENoChanges );

        }

    iFile.Close();

    iFs.Close();

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

    }

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

// CRoapAppUi::OpenFileL()

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

//

void CRoapAppUi::OpenFileL( const TDesC& aFileName )

    {

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

    iPostResponseURLDownLoad = EFalse;	

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

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

    }

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

// CRoapAppUi::HandleCommandL()

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

//

void CRoapAppUi::HandleCommandL( TInt aCommand )

    {

    CLOG(( 2, _L("-> CRoapAppUi::HandleCommandL aCommand(0x%x)"), \

        aCommand ));

    switch ( aCommand )

        {

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

        case EAknSoftkeyBack:

        // CAknShutter generated command.

        case EEikCmdExit:

            {

            Exit();

            break;

            }

        case EAknSoftkeyEmpty:

            {

            break;

            }

        case ERoapAppCmdCancel:

            {

            CancelRoap();

            break;

            }

        default:

            {

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

            __ASSERT_DEBUG

                ( EFalse, RoapAppPanic( ERoapAppUnknownCommand ) );

            break;

            }

        }

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

    }

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

// CRoapAppUi::ProcessCommandParametersL()

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

//

TBool CRoapAppUi::ProcessCommandParametersL

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

    {

    CLOG(( 2, _L("-> CRoapAppUi::ProcessCommandParametersL") ));

    CLOG(( 2, _L("   CRoapAppUi: aCommand: %d / aDocumentName: %S"), aCommand, &aDocumentName ));

    if ( aCommand == EApaCommandOpen )

        {

        OpenFileL( aDocumentName );

        }

    CLOG(( 2, _L("<- CRoapAppUi::ProcessCommandParametersL") ));

    return EFalse;

    }

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

// CRoapAppUi::HandleResourceChangeL()

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

//

void CRoapAppUi::HandleResourceChangeL( TInt aType )

    {

    CAknAppUi::HandleResourceChangeL( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        iView->SetRect( ClientRect() );

        }

    iView->HandleResourceChange( aType );

    }

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

// CRoapAppUi::ConnectionConfL()

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

//

TBool CRoapAppUi::ConnectionConfL()

    {

    // TODO ask user.

    return ETrue;

    }

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

// CRoapAppUi::ContactRiConfL()

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

//

TBool CRoapAppUi::ContactRiConfL()

    {

    // TODO ask user.

    return ETrue;

    }

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

// CRoapAppUi::TransIdConfL()

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

//

TBool CRoapAppUi::TransIdConfL()

    {

    return EFalse;

    }

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

// CRoapAppUi::RightsObjectDetailsL()

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

//

void CRoapAppUi::RightsObjectDetailsL

( const RPointerArray<CDRMRights>& /*aRightsList*/ )

    {

    // TODO

    }

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

// CRoapAppUi::ContentDownloadInfoL()

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

//

void CRoapAppUi::ContentDownloadInfoL

( TPath& aTempFolder, TFileName& aContentName, TInt& aMaxSize )

    {

    aTempFolder = KRoapTempFilePath;

    aContentName = KNullDesC;

    aMaxSize = -1;  // -1 == 'unknown'.

    }

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

// CRoapAppUi::ContentDetailsL()

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

//

void CRoapAppUi::ContentDetailsL

( const TDesC& /*aPath*/, const TDesC8& /*aType*/, const TUid& /*aAppUid*/ )

    {

    // TODO

    }

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

// CRoapAppUi::HandleDCFPartL()

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

//

void CRoapAppUi::HandleDCFPartL( const TDesC8& /*aFilename*/ )

    {

    // DRM Engine does not support multipart ROAP response yet.

    // This method will never be called.

    User::Leave( KErrNotSupported );

    }

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

// CRoapAppUi::RoapProgressInfoL()

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

//

void CRoapAppUi::RoapProgressInfoL( const TInt /*aProgressInfo*/ )

    {

    }

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

// CRoapAppUi::ErrorUrlL()

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

//

void CRoapAppUi::ErrorUrlL( const TDesC8& /* aErrorUrl */)

{	

}

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

// CRoapAppUi::PostResponseUrlL()

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

//

void CRoapAppUi::PostResponseUrlL( const TDesC8& aPrUrl )

{

    CLOG(( 2, _L("-> CRoapAppUi::PostResponseUrlL(\n    %S)"), &aPrUrl ));

    TBool retVal( ETrue );    

    //RoapApp is made as client of DownloadMgr. A new download session is created with PostResponse URL,

    //which handles the response like in any other download

    RHttpDownload& download = iDownloadMgr.CreateDownloadL(aPrUrl, retVal );

    download.SetBoolAttribute( EDlAttrNoContentTypeCheck, ETrue );

    //set the Download status of PostResponse URL 

    iPostResponseURLDownLoad = ETrue;

    User::LeaveIfError( download.Start());

}

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

// CRoapAppUi::HandleServerAppExit()

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

//

void CRoapAppUi::HandleServerAppExit( TInt /*aReason*/ )

    {

    RunAppShutter();

    }

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

// CRoapAppUi::LaunchHelpL()

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

//

void CRoapAppUi::LaunchHelpL( const TDesC& aContext )

    {

    CArrayFix<TCoeHelpContext>* contexts = 

        new(ELeave) CArrayFixFlat<TCoeHelpContext>( 1 );

    CleanupStack::PushL( contexts );

    TCoeHelpContext context;

    context.iMajor = KDRMHelperUid;

    context.iContext = aContext;

    contexts->AppendL( context );

    CleanupStack::Pop(); // contexts

    #ifdef __SERIES60_HELP

    HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), contexts );

    #endif // __SERIES60_HELP

    }

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

// CRoapAppUi::ShowRoapCallback(TAny* aPtr)

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

//

TInt CRoapAppUi::ShowRoapCallback( TAny* aPtr )

{

    TInt err( KErrNone );    

    CRoapAppUi* self = static_cast<CRoapAppUi*>(aPtr);

    TRAP( err, self->LaunchHelpL( KDRM_HLP_REGISTRATION ) );

    return err;        

}

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

// CRoapAppUi::HandleTriggerParsedL()

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

//

void CRoapAppUi::HandleTriggerParsedL()

    {

    CLOG(( 2, _L("-> CRoapAppUi::HandleTriggerParsedL") ));

    TBool doRoap( ETrue );

    const CRoapAppData& data( RoapDocument()->Data() );

    if ( data.iContextStatus == Roap::EInvalidContext )

        {

#ifdef RD_DRM_SILENT_RIGHTS_ACQUISITION

        HBufC* header = StringLoader::LoadLC( R_QTN_DRM_MSQ_QRY_TITLE_REGISTRAT ); 

        HBufC* regtxt = StringLoader::LoadLC( R_QTN_DRM_MSQ_QUERY_REGISTRATION );

        HBufC* moreinfo = NULL; 

        TBool helpFeature = FeatureManager::FeatureSupported( KFeatureIdHelp );

        if ( helpFeature )

            {        

            moreinfo = StringLoader::LoadLC( R_QTN_DRM_MSQ_QUERY_LINK_MORE_INF  );

            }

        else 

            {

            moreinfo = KNullDesC().AllocLC();

            }

        HBufC* regtxt_moreinfo = HBufC::NewLC(regtxt->Length() + moreinfo->Length() + 1 );

        TPtr regPtr( regtxt_moreinfo->Des() );

        regPtr += *regtxt;

        regPtr += KNextLine; 

        regPtr += *moreinfo; 

        CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *regtxt_moreinfo );

        dlg->PrepareLC( R_ROAP_REGISTERCANCEL_QUERY  );

        CAknPopupHeadingPane* hPane = dlg->QueryHeading();

        if ( hPane )                                         

            {

            hPane->SetTextL( *header );

            }

        if ( helpFeature )

            {        

            // set link 

            dlg->SetLinkTextL(*moreinfo);

            TCallBack callback(ShowRoapCallback, this); 

            dlg->SetLink(callback);             

            } 

        TInt ret = dlg->RunLD();

        if( ret != EAknSoftkeyYes ) 

            {

            doRoap = EFalse; 

            }            

         CleanupStack::PopAndDestroy(4); // header, regtxt, moreinfo, regtxt_moreinfo    

#else  // for RD_DRM_SILENT_RIGHTS_ACQUISITION

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

        // User must confirm.

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

        CAknQueryDialog* dialog = CAknQueryDialog::NewL();

        dialog->PrepareLC( R_ROAP_APP_CONFIRM_QUERY );

        HBufC* prompt;

        if ( data.iRiAlias )

            {

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

            HBufC* riAlias16 = HBufC::NewLC( data.iRiAlias->Length() );

            riAlias16->Des().Copy( *data.iRiAlias );

            prompt = StringLoader::LoadL

                ( R_QTN_DRM_QUERY_REGISTER_WITH_U, *riAlias16, iCoeEnv );

            CleanupStack::PopAndDestroy( riAlias16 );

            CleanupStack::PushL( prompt );

            }

        else

            {

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

            prompt = StringLoader::LoadLC

                ( R_QTN_DRM_QUERY_REGISTER_WITH_CP, iCoeEnv );

            }

        dialog->SetPromptL( *prompt );

        CleanupStack::PopAndDestroy( prompt );

        if ( !dialog->RunLD() ) 

            {

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

            doRoap = EFalse;    // User cancelled registration.

            }

#endif // for RD_DRM_SILENT_RIGHTS_ACQUISITION

    }

    if ( doRoap )

        {

        StartRoapL();

        }

    else

        {

          CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog

              (CAknNoteDialog::EConfirmationTone,CAknNoteDialog::EUndefinedTimeout);

          dialog->PrepareLC( R_ROAP_REGISTER_CANCEL_OK_INFO );

          HBufC* infoPrompt = StringLoader::LoadLC

              ( R_QTN_DRM_INFO_PHONE_NOT_REGISTER, iCoeEnv );

          dialog->SetTextL( *infoPrompt); 

		  CleanupStack::PopAndDestroy( infoPrompt ); 

          if ( !dialog->RunLD() )

		      {

              CLOG(( 2, _L("Select Cancel") ));

			  }

		  RunAppShutter();    

        }

    CLOG(( 2, _L("<- CRoapAppUi::HandleTriggerParsedL") ));

    }

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

// CRoapAppUi::StartRoapL()

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

//

void CRoapAppUi::StartRoapL()

    {

    CLOG(( 2, _L("-> CRoapAppUi::StartRoapL") ));

    __ASSERT_DEBUG( !iWaitNote, RoapAppPanic( ERoapAppInternal ) );

    TInt resId = 0;

    switch ( RoapDocument()->Data().iType )

        {

        case Roap::ERegistrationTrigger:

            {

            resId = R_QTN_DRM_WAIT_REGISTERING_DEVICE;

            break;

            }

        case Roap::ERoAcquisitionTrigger:

            {

            resId = R_QTN_DRM_WAIT_GETTING_KEY;

            break;

            }

        case Roap::EJoinDomainTrigger:

            {

            if ( RoapDocument()->Data().iDomainOperation ==

                 Roap::EJoinDomainOperation )

                {

                resId = R_QTN_DRM_WAIT_JOINING_DOMAIN;

                }

            else

                {

                resId = R_QTN_DRM_WAIT_UPDATING_ACCOUNT;

                }

            break;

            }

        case Roap::ELeaveDomainTrigger:

            {