/*

* Copyright (c) 2002-2006 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 file contains the implementation of CSisxUISilentHandler

*                class member functions.

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include <apgtask.h>

#include <SWInstDefs.h>

#include "SisxUISilentHandler.h"

#include "SisxUICertificateInfo.h"

#include "SisxUIAppInfo.h"

#include "SisxUISelectionCache.h"

#include "SisxUIResult.h"

using namespace SwiUI;

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

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

// CSisxUISilentHandler::CSisxUISilentHandler

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

// might leave.

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

//

CSisxUISilentHandler::CSisxUISilentHandler( const TInstallOptions &aOptions, 

                                            MSisxUICancelObserver* aCancelObserver )

    : CSisxUIHandler( EModeInstall, aCancelObserver), iOptions( aOptions )

    {    

    }

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

// CSisxUISilentHandler::CSisxUISilentHandler

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

// might leave.

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

//

CSisxUISilentHandler::CSisxUISilentHandler( const TUninstallOptions &aOptions, 

                                            MSisxUICancelObserver* aCancelObserver )

    : CSisxUIHandler( EModeUninstall, aCancelObserver ), iUninstallOptions( aOptions )

    {    

    }

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

// CSisxUISilentHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSisxUISilentHandler::ConstructL()

    {

    iCache = CSisxUISelectionCache::NewL();

    // created just to load resources

    iCommonDialogs = CommonUI::CCUIDialogs::NewL();

    }

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

// CSisxUISilentHandler::NewL

// Two-phased constructor.

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

//

CSisxUISilentHandler* CSisxUISilentHandler::NewL( const TInstallOptions &aOptions, 

                                                  MSisxUICancelObserver* aCancelObserver )

    {

    CSisxUISilentHandler* self = new( ELeave ) CSisxUISilentHandler( aOptions, aCancelObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

CSisxUISilentHandler* CSisxUISilentHandler::NewL( const TUninstallOptions &aOptions, 

                                                  MSisxUICancelObserver* aCancelObserver )

    {

    CSisxUISilentHandler* self = new( ELeave ) CSisxUISilentHandler( aOptions, aCancelObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

// Destructor

CSisxUISilentHandler::~CSisxUISilentHandler()

    {

    }

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

// CSisxUISilentHandler::DisplayInstallL

// Displays a dialog at the beginning of an installation with details about the 

// SISX package being installed. This dialog must be shown in TrustedUI mode.

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

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

//

TBool CSisxUISilentHandler::DisplayInstallL( 

    const Swi::CAppInfo& /*aAppInfo*/,

    const CApaMaskedBitmap* /*aLogo*/,

    const RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/ )  

    {

    // Mark the integrity as done

    iIntegrityCheckDone = ETrue;    

    TBool result( ETrue );

    return result;

    }

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

// CSisxUISilentHandler::DisplayGrantCapabilitiesL

// displays a dialog requesting that the user grants these capabilities to the 

// SISX package being installed. This dialog must be shown in TrustedUI mode.

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

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

//

TBool CSisxUISilentHandler::DisplayGrantCapabilitiesL( const Swi::CAppInfo& /*aAppInfo*/, 

                                                       const TCapabilitySet& /*aCapabilitySet*/ ) 

    {

    TBool result( EFalse );

    switch ( iOptions.iCapabilities )

        {

        case EPolicyAllowed:

            {

            result = ETrue;

            break;	

            }

        case EPolicyUserConfirm:

    	default:

            iResult = TSisxUIResult( EUiResultCapabilitiesCannotBeGranted );

            break;

        }

    return result;       

    }

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

// CSisxUISilentHandler::DisplayLanguageL

// requests preferred language and dialect information from the UI.

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

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

//

TInt CSisxUISilentHandler::DisplayLanguageL( const Swi::CAppInfo& /*aAppInfo*/, 

                                             const RArray<TLanguage>& aLanguages ) 

    {

    TInt languageIndex( -1 );

    TInt index( 0 ) ;

    if ( iOptions.iUsePhoneLang )

    	{

    	TLanguage phoneLanguage( User::Language() );    

        // If phones default language is available in the file, do not query the user

        for ( index = 0; index < aLanguages.Count(); index++ )

            {

            // Check if this matches the phone language        

            if( aLanguages[ index ] == phoneLanguage )

                {

                return index;

                }

            // Check if user has already selected this language during installation        

            if( iCache->LanguageCached() && aLanguages[index] == iCache->Language() )

                {

                // Do not query user, we have a cached language    

                return index;            

                }        

            }

    	}

    if ( iOptions.iLang == ELangNone )

    	{

    	// Don't bother to see if there's ELangNone in language list

    	if ( aLanguages.Count() > 0 )

            {

            languageIndex = 0;

            }

    	}

    else

    	{

        for ( index = 0; index < aLanguages.Count(); index++ )

            {

            // Check if this matches the language defined by silent install options

            if( aLanguages[ index ] == iOptions.iLang)

                {

                languageIndex = index;

                break;

                }

            // Check if user has already selected this language during installation        

            if( iCache->LanguageCached() && aLanguages[index] == iCache->Language() )

                {

                // Do not query user, we have a cached language    

                languageIndex = index;            

                break;

                }        

            }

        if ( languageIndex == -1 )

            {

            if ( aLanguages.Count() > 0 )

            	{

            	languageIndex = 0;

            	}

            else

            	{

            	iResult = TSisxUIResult( EUiResultCancelled ); 	

            	}	

            }

        else

            {

            // Cache only if no previous cache is found

            if( !iCache->LanguageCached() )

                {

                iCache->SetLanguage( aLanguages[languageIndex] );

                }     

            }

    	}

    return languageIndex;

    }

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

// CSisxUISilentHandler::DisplayDriveL

// Requests the drive to install the package on, from the UI.

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

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

//

TInt CSisxUISilentHandler::DisplayDriveL( const Swi::CAppInfo& /*aAppInfo*/, 

                                          TInt64 aSize,

                                          const RArray<TChar>& aDriveLetters,

                                          const RArray<TInt64>& aDriveSpaces ) 

    {

    TInt selection( -1 );    

    if ( aDriveLetters.Count() <= 0 )

        {

        iResult = TSisxUIResult( EUiResultInsufficientMemory );    

        }    

    else

        {

        // Find the drive specified in options

        for ( TInt index( aDriveLetters.Count() - 1 ); index >= 0; index-- )

            {

            TChar givenDrive( aDriveLetters[index] );

            givenDrive.Fold();

            TChar optionsDrive( iOptions.iDrive );

            optionsDrive.Fold();

            if ( givenDrive == optionsDrive || optionsDrive == KUserConfirmDrive )

                {

                if ( aDriveSpaces[index] > aSize )

                    {

                    selection = index;

                    break;

                    }

                else

                    {

                    iResult = TSisxUIResult( EUiResultInsufficientMemory );

                    break;

                    }

                }

            }

       	if ( selection == -1 )

            {

            iResult = TSisxUIResult( EUiResultDiskNotPresent );

            }

        }

    return selection;    

    }

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

// CSisxUISilentHandler::DisplayUpgradeL

// Displays a dialog asking whether we want to upgrade an application present 

// on the device.

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

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

//

TBool CSisxUISilentHandler::DisplayUpgradeL( const Swi::CAppInfo& /*aAppInfo*/, 

                                             const Swi::CAppInfo& /*aExistingAppInfo*/ ) 

    {

    TBool result( EFalse );

    if ( iOptions.iUpgrade == EPolicyAllowed )

    	{

    	result = ETrue;

    	}

    else

    	{

    	iResult = TSisxUIResult( EUiResultCancelled );

    	}

    return result;

    }

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

// CSisxUISilentHandler::DisplayOptionsL

// Displays a dialog box asking which options the user wishes to install.

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

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

//

TBool CSisxUISilentHandler::DisplayOptionsL( const Swi::CAppInfo& /*aAppInfo*/,

                                             const RPointerArray<TDesC>& aOptions,

                                             RArray<TBool>& aSelections ) 

    {

    TBool response ( ETrue );

    if ( aOptions.Count() < 1 )

        {

        User::Leave( KErrArgument );        

        }

    TBool allow( iOptions.iOptionalItems == EPolicyAllowed );

    // set all to 

    for( TInt index( 0 ); index < aSelections.Count(); index++ )

        {

        aSelections[index] = allow ;

        }

    if ( !allow )

        {

        iResult = TSisxUIResult( EUiResultCancelled );

        }

    return response;

    }

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

// CSisxUISilentHandler::HandleInstallEventL

// Informs the UI of events occurring during installation.

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

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

//

TBool CSisxUISilentHandler::HandleInstallEventL( const Swi::CAppInfo& aAppInfo,

                                                 Swi::TInstallEvent aEvent, 

                                                 TInt /*aValue*/, 

                                                 const TDesC& /*aDesC*/ )

    {

    switch ( aEvent )

        {

        case Swi::EEventSetProgressBarFinalValue:

            // Here we need to update the name and vendor of the main package.

            // They might have changed when a language has been selected.

            if ( iPackages.Count() > 0 )

                {                  

                iPackages[0]->SetNameL( aAppInfo.AppName() );

                iPackages[0]->SetVendorL( aAppInfo.AppVendor() );

                }

            break;

        case Swi::EEventOcspCheckEnd:

            iOcspInProgress = EFalse;            

            break;

        default:

            break;       

        }

    return ETrue;

    }

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

// CSisxUISilentHandler::HandleCancellableInstallEventL

// Informs the UI of cancellable events occurring during installation.  

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

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

//

void CSisxUISilentHandler::HandleCancellableInstallEventL( const Swi::CAppInfo& /*aAppInfo*/,

                                                           Swi::TInstallCancellableEvent /*aEvent*/, 

                                                           Swi::MCancelHandler& /*aCancelHandler*/,

                                                           TInt /*aValue*/, 

                                                           const TDesC& /*aDes*/ )

    {

    // Empty

    }

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

// CSisxUISilentHandler::DisplaySecurityWarningL

// Displays a dialog indicating that the package is unsigned, or that signature 

// validation has failed.

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

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

//

TBool CSisxUISilentHandler::DisplaySecurityWarningL( const Swi::CAppInfo& aAppInfo,

                                                     Swi::TSignatureValidationResult aSigValidationResult,

                                                     RPointerArray<CPKIXValidationResultBase>& /*aPkixResults*/,

                                                     RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/,

                                                     TBool aInstallAnyway )

    {

    TBool result( EFalse );

    switch ( aSigValidationResult )

        {

        case Swi::EValidationSucceeded:       

            {

            result = ETrue;

            CSisxUIAppInfo* appInfo = CSisxUIAppInfo::NewL( aAppInfo, ETrue );

            iPackages.Append( appInfo );

            break;

            }       

            // Non fatals

        case Swi::ESignatureSelfSigned:

        case Swi::ESignatureNotPresent:

        case Swi::ENoCertificate:

        case Swi::ECertificateValidationError:

        case Swi::ENoCodeSigningExtension:

        case Swi::ENoSupportedPolicyExtension:

            // Fatals with aInstallAnyway set as EFalse

        case Swi::ESignatureCouldNotBeValidated:

        case Swi::EMandatorySignatureMissing:

            {

            // Check if we are allowed to continue installation

            if ( aInstallAnyway && iAllowUntrusted )

                {          

                if ( iOptions.iUntrusted == EPolicyAllowed )

                    {

                    result = ETrue;

                    CSisxUIAppInfo* appInfo = CSisxUIAppInfo::NewL( aAppInfo, ETrue );

                    iPackages.Append( appInfo );

                    }

                else

                    {

                    iResult = TSisxUIResult( aSigValidationResult );

                    }

                }

            else

                {

                // Fatal error, not allowed to continue

                iResult = TSisxUIResult( aSigValidationResult );

                }            

            break;

            }

        default:

            iResult = TSisxUIResult( aSigValidationResult );

            break;            

        }

    return result;    

    }

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

// CSisxUISilentHandler::DisplayOcspResultL

// Displays a dialog indicating that there was an error carrying out online 

// certificate status checking.

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

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

//

TBool CSisxUISilentHandler::DisplayOcspResultL( const Swi::CAppInfo& /*aAppInfo*/,

                                                Swi::TRevocationDialogMessage aMessage, 

                                                RPointerArray<TOCSPOutcome>& /*aOutcomes*/, 

                                                RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/,

                                                TBool aWarningOnly )

    {

    TBool result( ETrue );

    // This will be treated as warning if engine says it's a warning and

    // ocsp setting is on. In case it's must, we abort the installation.

    if ( aWarningOnly && iOcspProc == ESisxUIOcspProcOn )

        {

        switch ( iOptions.iIgnoreOCSPWarnings )

            {

            case EPolicyAllowed:

                {

                result = ETrue;

                break;

                }

            case EPolicyUserConfirm:

            default:

                {

                result = EFalse;

                break;			

                }

            }

        if ( !result )

            {

            iResult = TSisxUIResult( EUiResultCancelled );

            }                

        }

    // error or ocsp is set to must

    else

        {

        iResult = TSisxUIResult( aMessage );

        result = EFalse; 

        }            

    return result;    

    }

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

// CSisxUISilentHandler::DisplayCannotOverwriteFileL

// Used to inform the user the installation they are attempting is trying to 

// overwrite a file that does not belong to it. Following this message 

// installation is aborted.

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

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

//

void CSisxUISilentHandler::DisplayCannotOverwriteFileL( const Swi::CAppInfo& /*aAppInfo*/,

                                                        const Swi::CAppInfo& /*aInstalledAppInfo*/,

                                                        const TDesC& /*aFileName*/ )

    {

    iResult = TSisxUIResult( EUiResultUnableToOverwrite );

    }

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

// CSisxUISilentHandler::DisplayMissingDependencyL

// Used to inform the user of a missing dependency needed to install the 

// current package. It is up to the UI implementors and/or the user whether

// or not this warning can be overridden.

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

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

//

TBool CSisxUISilentHandler::DisplayMissingDependencyL( const Swi::CAppInfo& /*aAppInfo*/,

                                                       const TDesC& /*aDependencyName*/,

                                                       TVersion /*aWantedVersionFrom*/,

                                                       TVersion /*aWantedVersionTo*/,

                                                       TVersion /*aInstalledVersion*/ )

    {

    TBool result( EFalse );

    iResult = TSisxUIResult( EUiResultMissingDependency );

    return result;

    }

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

// CSisxUISilentHandler::DisplayUninstallL

// Displays a dialog at the start of the uninstallation with information about 

// the application to be uninstalled. The user may cancel the uninstallation at 

// this stage. This dialog must be shown in TrustedUI mode.