/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   This module contains the implementation of CSisxUIOperationWatcher 

*                class member functions.

*

*/

// INCLUDE FILES

#include <swi/asynclauncher.h>

#include <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <swi/sisregistrypackage.h>

#include <centralrepository.h>

#include <SWInstallerInternalCRKeys.h>

#include <pathinfo.h>

#include <zipfilemember.h>

#include <DRMLicenseManager.h>

#include <SisxUIData.rsg>

#include <SWInstTaskManager.h>

#include <SWInstTask.h>

#include <SWInstDefs.h>

#include <featmgr.h>

#include <SWInstFileTaskParam.h>

#include <e32property.h>

#include <SWInstallerInternalPSKeys.h>

#include <Oma2Agent.h>              // KOmaDrm2AgentName

#include <syslangutil.h>

#include <caf/manager.h>            // ContentAccess::CManager

#include <caf/agent.h>              // ContentAccess::TAgent

#include <DcfEntry.h> // JPAA-7GEB7P 

#include <DcfRep.h> // JPAA-7GEB7P

#include "SisxUIOperationWatcher.h"

#include "SisxUIHandler.h"

#include "SisxUIResult.h"

#include "SisxUIAppInfo.h"

#include "SisxUIStartupFile.h"

#include "SWInstDebug.h"

#include "SisxUISilentHandler.h"

#include "SisxUICleanupUtils.h" // JPAA-7GEB7P

_LIT( KTempDir, "piptemp\\" );

_LIT( KPipFileMatch, "*" );

const TUint KSisxFileUidPosition = 8;

const TUint KDot = 0x2E; // Dot

_LIT(KSisString, "sis");

_LIT( KSkinExtension, "*.skn" ); // JPAA-7GEB7P

using namespace SwiUI;

using namespace ContentAccess;

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

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

// CSisxUIOperationWatcher::CSisxUIOperationWatcher

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

// might leave.

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

//

CSisxUIOperationWatcher::CSisxUIOperationWatcher() 

    : CActive( CActive::EPriorityStandard ),

      iIsSilent( EFalse ),

      iDoSilentOcsp( EFalse )

    {

    CActiveScheduler::Add( this );    

    }

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

// CSisxUIOperationWatcher::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSisxUIOperationWatcher::ConstructL()

    {

    iTaskManager = CTaskManager::NewL();

    User::LeaveIfError( iRfs.Connect() );    

    iRfs.ShareProtected();

    FeatureManager::InitializeLibL(); 

    iLauncher = Swi::CAsyncLauncher::NewL();

    }

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

// CSisxUIOperationWatcher::NewL

// Two-phased constructor.

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

//

CSisxUIOperationWatcher* CSisxUIOperationWatcher::NewL()

    {

    CSisxUIOperationWatcher* self = new( ELeave ) CSisxUIOperationWatcher();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

// Destructor

CSisxUIOperationWatcher::~CSisxUIOperationWatcher()

    {

    iDeletionOngoing = ETrue;

    if ( iCanceller )

        {

        iCanceller->Cancel();

        delete iCanceller;

        }    

    delete iLauncher;

    iLauncher = NULL;

    CActive::Cancel();

    iSupportedLanguages.Close();

    delete iUIHandler;

    delete iTaskManager;

    delete iMIME;    

    NotifyEndUninstall();

    iInstalledFiles.ResetAndDestroy();

    iAugmentations.ResetAndDestroy();    

    iTempFile.Close();

    iRfs.Close();    

    FeatureManager::UnInitializeLib();

    }

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

// CSisxUIOperationWatcher::InstallL

// Handle install request.

// (other items were commented in a header).

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

//    

void CSisxUIOperationWatcher::InstallL( RFile& aFile, 

                                        const TDesC8& aMIME, 

                                        TBool aIsDRM, 

                                        TRequestStatus& aRequestStatus )

    {

    // Set client request to pending state

    iRequestStatus = &aRequestStatus;    

    *iRequestStatus = KRequestPending; 

    iSourceFile = aFile;

    iMIME = aMIME.AllocL();    

    // Create the ui

    iUIHandler = CSisxUIHandler::NewL( CSisxUIHandler::EModeInstall, this );   

    if ( aIsDRM )

        {

        // We need to pass the handle to ui handler, so that it can shown

        // details of drm

        iUIHandler->SetFileForDrm( aFile );        

        }    

    iPreparing = ETrue;    

    // Kick off the RunL

    TRequestStatus* stat = &iStatus;

    User::RequestComplete( stat, KErrNone );

    SetActive();  

    }

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

// CSisxUIOperationWatcher::SilentInstallL

// Handle silentinstall request.

// (other items were commented in a header).

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

//    

void CSisxUIOperationWatcher::SilentInstallL( RFile& aFile, 

                                              const TDesC8& aMIME, 

                                              TBool aIsDRM,

                                              TInstallOptions& aOptions, 

                                              TRequestStatus& aRequestStatus )

    {

    // Set client request to pending state

    iRequestStatus = &aRequestStatus;    

    *iRequestStatus = KRequestPending;

    iIsSilent = ETrue;      

    iSourceFile = aFile;

    iMIME = aMIME.AllocL();    

    if ( aOptions.iOCSP == EPolicyAllowed )

        {

        iDoSilentOcsp = ETrue;        

        }    

    // Create the ui

    iUIHandler = CSisxUISilentHandler::NewL( aOptions, this );   

    if ( aIsDRM )

        {

        // We need to pass the handle to ui handler, so that it can shown

        // details of drm

        iUIHandler->SetFileForDrm( aFile );        

        }    

    iPreparing = ETrue;    

    // Kick off the RunL

    TRequestStatus* stat = &iStatus;

    User::RequestComplete( stat, KErrNone );

    SetActive();  

    }        

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

// CSisxUIOperationWatcher::UninstallL

// Handle uninstall request.

// (other items were commented in a header).

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

//      

void CSisxUIOperationWatcher::UninstallL( const TUid& aUid, TRequestStatus& aRequestStatus ) 

    {

    // Set client request to pending state

    iRequestStatus = &aRequestStatus;    

    *iRequestStatus = KRequestPending; 

    iUninstalledUid = aUid;    

    TRAP_IGNORE( NotifyStartUninstallL(aUid ) );

    iUIHandler = CSisxUIHandler::NewL( CSisxUIHandler::EModeUninstall, this );

    iLauncher->UninstallL( *iUIHandler, aUid, iStatus );

    SetActive();    

    }

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

// CSisxUIOperationWatcher::UninstallL

// Handle uninstall request.

// (other items were commented in a header).

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

//      

void CSisxUIOperationWatcher::SilentUninstallL( const TUid& aUid, 

                                                TUninstallOptions& aOptions, 

                                                TRequestStatus& aRequestStatus ) 

    {

    // Set client request to pending state

    iRequestStatus = &aRequestStatus;    

    *iRequestStatus = KRequestPending; 

    iIsSilent = ETrue;    

    iUninstalledUid = aUid;    

    iUIHandler = CSisxUISilentHandler::NewL( aOptions, this );

    TRAP_IGNORE( NotifyStartUninstallL(aUid ) );

    iLauncher->UninstallL( *iUIHandler, aUid, iStatus );

    SetActive();    

    }

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

// CSisxUIOperationWatcher::UninstallAugmentationL

// Uninstalls only a specific augmentation (sispatch)

// (other items were commented in a header).

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

//

void CSisxUIOperationWatcher::UninstallAugmentationL( const TUid& aUid, 

                                                      TInt aIndex, 

                                                      TRequestStatus& aRequestStatus )

    {

    // Set client request to pending state

    iRequestStatus = &aRequestStatus;    

    *iRequestStatus = KRequestPending; 

    iUninstalledUid = aUid;    

    TRAP_IGNORE( NotifyStartUninstallL(aUid ) );

    iUIHandler = CSisxUIHandler::NewL( CSisxUIHandler::EModeUninstall, this );

    DoUninstallAugmentationL( aUid, aIndex );    

    }

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

// CSisxUIOperationWatcher::SilentUninstallAugmentationL

// Uninstalls only a specific augmentation (sispatch)

// (other items were commented in a header).

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

//

void CSisxUIOperationWatcher::SilentUninstallAugmentationL( const TUid& aUid, 

                                                            TUninstallOptions& aOptions,

                                                            TInt aIndex, 

                                                            TRequestStatus& aRequestStatus )

    {

    // Set client request to pending state

    iRequestStatus = &aRequestStatus;    

    *iRequestStatus = KRequestPending; 

    iIsSilent = ETrue;    

    iUninstalledUid = aUid;    

    TRAP_IGNORE( NotifyStartUninstallL(aUid ) );

    iUIHandler = CSisxUISilentHandler::NewL( aOptions, this );

    DoUninstallAugmentationL( aUid, aIndex );    

    }

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

// CSisxUIOperationWatcher::FinalCompleteL

// Informs the UI, about final completion.

// (other items were commented in a header).

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

// 

void CSisxUIOperationWatcher::FinalCompleteL()

    {

    iTempFile.Close();

    if ( iUIHandler )

        {

        iUIHandler->ShowFinalNoteL();        

        }    

    }

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

// CSisxUIOperationWatcher::Cancel

// Override of CActive::Cancel

// (other items were commented in a header).

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

//    

void CSisxUIOperationWatcher::Cancel()

    {

    if ( !iCancelOngoing )

        {        

        iUIHandler->ProcessResult( KSWInstErrUserCancel );

        if ( iPreparing )

            {

            CActive::Cancel();            

            iUIHandler->DoNotShowFinalNote();            

            // Just complete the client request

            CompleteRequest( KSWInstErrUserCancel ); 

            }        

        else

            {            

            // If we are installing/uninstalling we may have a dialog waiting

            // for user input. We need to use this special method to cancel

            // the operation.

            TRAPD( err,

                   iCanceller = CommonUI::CCUICancelTimer::NewL( this );

                   iCanceller->StartCancelling();            

                );

            if ( err != KErrNone )

                {

                // Complete the original request from client

                CompleteRequest( KSWInstErrUserCancel );           

                }            

            }        

        iCancelOngoing = ETrue;        

        }    

    }

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

// CSisxUIOperationWatcher::RunL

// Called by framework when request is finished.

// (other items were commented in a header).

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

//    

void CSisxUIOperationWatcher::RunL()

    {

    FLOG_1( _L("SisxUI: RunL() status: %d"), iStatus.Int() );

    // If we got here, we don't need the canceller anymore

    if ( iCanceller )

        {

        iCanceller->Cancel();

        delete iCanceller;

        iCanceller = NULL;        

        }    

    if ( iPreparing )

        {

        // Do all the necessary preparations

        PrepareInstallL();

        return;        

        }

    // Let the UI know about the result

    iUIHandler->ProcessResult( iStatus.Int() );    

    if ( iUIHandler->GetResult().iResult == EUiResultOk )

        {

        // Install case    

        if ( iUIHandler->InstallMode() == CSisxUIHandler::EModeInstall )

            {

            TRAP_IGNORE( CompleteInstallationL() );            

            }

        // Uninstall case

        else 

            {

            TRAP_IGNORE( CompleteUninstallationL() );

            }       

        }

    CompleteRequest( iUIHandler->GetResult().CommonResult() );          

    }

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

// CSisxUIOperationWatcher::DoCancelL

// Called by framework when request is cancelled.

// (other items were commented in a header).

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

// 

void CSisxUIOperationWatcher::DoCancel()

    {        

    // This function is usually not used because of overridden Cancel().

    // Usually CActive::Cancel() followed by CompleteRequest() is used to

    // cancel active CSisxUIOperationWatcher. However, when active operation

    // watcher is deleted, this function must complete the client request

    // (to avoid deadlock when client calls CActive::Cancel() later).

    if( iDeletionOngoing && iRequestStatus )

        {

        CompleteRequest( KErrCancel );

        }

    }

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

// CSisxUIOperationWatcher::DoCancelL

// Handles a leave occurring in the request completion event handler RunL().

// (other items were commented in a header).

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

// 

TInt CSisxUIOperationWatcher::RunError( TInt aError )

    {

    // Report the error to the UI

    iUIHandler->ProcessResult( aError );    

    // Complete client request

    CompleteRequest( aError );

    return KErrNone;    

    }

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

// CSisxUIOperationWatcher::UserCancelL

// Called when user has cancelled the operation.

// (other items were commented in a header).

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

// 

void CSisxUIOperationWatcher::UserCancelL( TBool aCancelImmediately )

    {

    iIsUserCancel = ETrue;

    if ( !aCancelImmediately )

        {        

        Cancel();

        }

    else

        {

        CancelEngine();

        }    

    }

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

// CSisxUIOperationWatcher::IsShowingDialog

// Indicates if a modal dialog is currently shown.

// (other items were commented in a header).

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

// 

TBool CSisxUIOperationWatcher::IsShowingDialog()

    {

    return iUIHandler->IsShowingDialog();    

    }

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

// CSisxUIOperationWatcher::CancelEngine

// Cancels the installation engine.

// (other items were commented in a header).

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

//

void CSisxUIOperationWatcher::CancelEngine()

    {

    if ( iLauncher )

        {

        iLauncher->CancelOperation();   

        }              

    }

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

// CSisxUIOperationWatcher::ForceCancel

// Called when nothing else has worked.

// (other items were commented in a header).

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

//

void CSisxUIOperationWatcher::ForceCancel()

    {

    // We need to make a dirty cancel

    // Kill the async launcher

    delete iLauncher;

    iLauncher = NULL;

    // We can cancel the AO, launcher has completed the request

    CActive::Cancel();

    // Complete the client request

    CompleteRequest( KSWInstErrUserCancel );

    }

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

// CSisxUIOperationWatcher::StartedCancellingL

// Called to indicate that the cancelling progress has been started.

// (other items were commented in a header).

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

//

void CSisxUIOperationWatcher::StartedCancellingL()

    {

    // Show the dialog only if this is user initiated cancel.

    if ( iIsUserCancel )

        {        

        iUIHandler->ShowCancellingL();    

        }    

    }

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

// CSisxUIOperationWatcher::DoCancelL

// Completes the pending request.

// (other items were commented in a header).

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

// 

void CSisxUIOperationWatcher::CompleteRequest( TInt aResult )

    {

    iTempFile.Close();

    if ( iRequestStatus )