/*

* 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 CSisxUIHandler

*                class member functions.

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <barsread.h>

#include <eikenv.h>

#include <aknlistquerydialog.h>

#include <aknmessagequerydialog.h>

#include <aknnotewrappers.h>

#include <SisxUIData.rsg>

#include <SWInstCommonUI.rsg>

#include <SWInstDefs.h>

#include <featmgr.h>

#include <swi/sisinstallerrors.h>

#include <AknUtils.h>

#include <eikfrlb.h> //for the marquee effect

#include <eikfrlbd.h> //for the marquee effect

#include "SisxUIHandler.h"

#include "SisxUICertificateInfo.h"

#include "SisxUIAppInfo.h"

#include "SisxUISelectionCache.h"

#include "SisxUIResult.h"

#include "SisxUILangName.h"             // CLangName

#include "SisxUICleanupUtils.h"         // CleanupResetAndDestroyPushL

#include "CUIUtils.h"

#include "SWInstDebug.h"

using namespace SwiUI;

_LIT( KDetailedError,"%S (%d)" );

_LIT( KSwiTempFile,"c:\\temp\\swierrors.txt" );

_LIT( KNextLine, "\n" );

_LIT( KLeftParenthes, "(" );

//directional marks needed for Arabic language

_LIT( KLRE, "\x202A" );

_LIT( KPDF, "\x202C" );

const TInt KSpaceForErrorCode = 12;     // space for " (-12345678)"

// ============================ LOCAL FUNCTIONS ================================

TBool HasLangId( const TLanguage* aId, const CLangName& aLang )

    {

    return( *aId == aLang.Id() );

    }

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

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

// CSisxUIHandler::CSisxUIHandler

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

// might leave.

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

//

CSisxUIHandler::CSisxUIHandler( TInstallMode aMode, MSisxUICancelObserver* aCancelObserver )

    : iMode( aMode ), 

      iCancelObserver( aCancelObserver ), 

      iAllowUntrusted( ETrue )

    {    

    }

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

// CSisxUIHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSisxUIHandler::ConstructL()

    {

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

    iCache = CSisxUISelectionCache::NewL();

    if ( iMode == EModeInstall )

        {        

        iCommonDialogs->ShowWaitDialogL( R_SISXUI_PREPARING, this, R_AVKON_SOFTKEYS_EMPTY );

        }    

    }

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

// CSisxUIHandler::NewL

// Two-phased constructor.

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

//

CSisxUIHandler* CSisxUIHandler::NewL( TInstallMode aMode, MSisxUICancelObserver* aCancelObserver )

    {

    CSisxUIHandler* self = new( ELeave ) CSisxUIHandler( aMode, aCancelObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

// Destructor

CSisxUIHandler::~CSisxUIHandler()

    {

    // If wait dialog is showing close it.  	

    if ( iShowingWaitDialog )

        {        

        if ( iCommonDialogs )

            {

        	TRAP_IGNORE( iCommonDialogs->CloseWaitDialogL() );	

            }

        }    	    	

    delete iCommonDialogs;

    iCertificateArray.ResetAndDestroy();

    delete iCache;    

    iPackages.ResetAndDestroy();  

    iDrmFile.Close();

    }

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

// CSisxUIHandler::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 CSisxUIHandler::DisplayInstallL( 

#ifdef RD_COMBINE_INSTALLATION_QUERIES

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

#else

                              const Swi::CAppInfo& aAppInfo,

#endif //RD_COMBINE_INSTALLATION_QUERIES

                              const CApaMaskedBitmap* /*aLogo*/,

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

    {

#ifdef RD_COMBINE_INSTALLATION_QUERIES //with new dialog sequence

    TBool result( ETrue );

    // Mark the integrity as done

    iIntegrityCheckDone = ETrue;

    iShowingDialog = EFalse;

#else  // show using old dialog sequence 

    iShowingDialog = ETrue;

    // Close the preparing wait dialog

    iCommonDialogs->CloseWaitDialogL();

    TBool result( EFalse );

    HBufC* prompt = StringLoader::LoadLC( R_SISXUI_INSTALL_PROMPT, aAppInfo.AppName() );

    if ( iCommonDialogs->ShowConfirmationQueryL( *prompt, R_AVKON_SOFTKEYS_YES_NO__YES ) )

        {        

        result = ETrue;       

        }   

    else

        {

        iResult = TSisxUIResult( EUiResultCancelled );

        // Make sure no notes are shown after this        

        iShownFinalNote = ETrue;        

        }

    CleanupStack::PopAndDestroy( prompt );

    // Mark the integrity as done

    iIntegrityCheckDone = ETrue;

    iShowingDialog = EFalse;    

#endif //RD_COMBINE_INSTALLATION_QUERIES    

    return result;

    }

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

// CSisxUIHandler::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 CSisxUIHandler::DisplayGrantCapabilitiesL( const Swi::CAppInfo& /*aAppInfo*/, 

                                                 const TCapabilitySet& aCapabilitySet ) 

    {

    iShowingDialog = ETrue;

    TBool result( ETrue );

    // Add the text heading

    HBufC* messageString = StringLoader::LoadLC( R_SISXUI_CAPAB_HEADING );

    if ( aCapabilitySet.HasCapability( ECapabilityLocalServices ) )

        {

        AddCapabilityL( messageString, R_SISXUI_CAPAB_LOCAL );

        }

    if ( aCapabilitySet.HasCapability( ECapabilityReadUserData ) )

        {

        AddCapabilityL( messageString, R_SISXUI_CAPAB_READ_USER );

        }

    if ( aCapabilitySet.HasCapability( ECapabilityWriteUserData ) )

        {

        AddCapabilityL( messageString, R_SISXUI_CAPAB_WRITE_USER );

        }

    if ( aCapabilitySet.HasCapability( ECapabilityUserEnvironment ) )

        {

        AddCapabilityL( messageString, R_SISXUI_CAPAB_USERENV );

        }

    if ( aCapabilitySet.HasCapability( ECapabilityNetworkServices ) )

        {

        AddCapabilityL( messageString, R_SISXUI_CAPAB_NETWORK );

        }

    if ( aCapabilitySet.HasCapability( ECapabilityLocation ) )

        {

        AddCapabilityL( messageString, R_SISXUI_CAPAB_LOCATION );

        }

    HBufC* linkText = NULL;    

    if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

        {        

        linkText = StringLoader::LoadLC( R_SISXUI_CAPAB_MORE_INFO );

        }

    else

        {

        linkText = KNullDesC().AllocLC();        

        }

    HBufC* finalMessage = HBufC::NewLC( messageString->Length() + linkText->Length() + 1);

    TPtr msgPtr( finalMessage->Des() );

    msgPtr += *messageString;

    msgPtr += KNextLine;

    msgPtr += *linkText;    

    // Show the dialog

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

    dlg->PrepareLC( R_SISXUI_CAPAB_DIALOG );

    if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

        {        

        dlg->SetLinkTextL( *linkText );

        TCallBack callback( ShowCapabilitiesHelp, this );    

        dlg->SetLink( callback );

        }    

    if ( !dlg->RunLD() )

        {

        // User cancelled

        iResult = TSisxUIResult( EUiResultCancelled );

        result = EFalse;        

        }    

    CleanupStack::PopAndDestroy( 3, messageString ); // finalMessage, linkText, messageString

    iShowingDialog = EFalse;    

    return result;       

    }

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

// CSisxUIHandler::DisplayLanguageL

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

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

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

//

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

                                       const RArray<TLanguage>& aLanguages ) 

    {

    TInt languageIndex( 0 );

    TInt index( 0 );

    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 there is only one language in the list, do not query the user

    if( aLanguages.Count() == 1 )

        {

        return 0;        

        }

    iShowingDialog = ETrue;

    // Prepare for showing the language selection dialog

    CDesCArray *itemArray = new( ELeave ) CDesCArrayFlat(4);

    CleanupStack::PushL( itemArray );

    // construct the array of available languages

    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, R_SISXUI_LANGUAGES_ARRAY );

    RPointerArray<CLangName> langNameArray;

    CleanupResetAndDestroyPushL( langNameArray );

    TInt count = reader.ReadInt16();

    while( --count >= 0 )

        {

        CLangName* langName = CLangName::NewL( reader );

        langNameArray.AppendL( langName );

        }

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

        {

        TLanguage language = aLanguages[ index ];

        TInt nameIndex = langNameArray.Find( language, HasLangId );

        if ( nameIndex == KErrNotFound ) 

            {

            nameIndex = TLanguage( 0 );     // produces qtn_swins_lqi_unknow

            }

        itemArray->AppendL( langNameArray[ nameIndex ]->Name() );

        }

    // show list query

    CAknListQueryDialog* dlg = new ( ELeave ) CAknListQueryDialog( &languageIndex );

    dlg->PrepareLC( R_SISXUI_LANGUAGE_QUERY );

    dlg->SetItemTextArray( itemArray );

    dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );

    if( languageIndex != 0 )

        {

        dlg->ListBox()->SetCurrentItemIndex( languageIndex );

        }

    TInt queryOk = dlg->RunLD();

    CleanupStack::PopAndDestroy( 3, itemArray ); // langNameArray, reader, itemArray

    if ( !queryOk )

        {        

        languageIndex = -1;

        iResult = TSisxUIResult( EUiResultCancelled );       

        }

    // Cache only if no previous cache is found

    if( languageIndex != -1 && !iCache->LanguageCached() )

        {

        iCache->SetLanguage( aLanguages[languageIndex] );

        }     

    iShowingDialog = EFalse;

    return languageIndex;

    }

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

// CSisxUIHandler::DisplayDriveL

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

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

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

//

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

                                    TInt64 aSize,

                                    const RArray<TChar>& aDriveLetters,

                                    const RArray<TInt64>& aDriveSpaces ) 

    {

    if ( aDriveLetters.Count() <= 0 )

        {

        iResult = TSisxUIResult( EUiResultInsufficientMemory );

        return -1;        

        }    

    iShowingDialog = ETrue;

    RArray<TDriveUnit> driveUnits;

    CleanupClosePushL( driveUnits );

    TInt index( 0 );

    // Convert drive letters to TDriveUnits

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

        {

        TBuf<2> tmp;

        tmp.Append( aDriveLetters[index] );

        driveUnits.Append( TDriveUnit( tmp ) );

        }

    TInt selection( -1 );

    TInt dlgResult( KErrNone );    

    // See if the selection has been cached

    if ( iCache->DriveCached() )

        {

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

            {

            if ( (TInt)iCache->Drive() == (TInt)driveUnits[index] )

                {

                // Make sure, we have enough size in the cached drive

                if ( aSize < aDriveSpaces[index] )

                    {

                    selection = index;

                    break;                    

                    }  

                else

                    {

                    // Cached drive has insufficient memory, ask user again

                    dlgResult = iCommonDialogs->ShowDriveSelectionDialogL( aSize, 

                                                                           driveUnits, 

                                                                           aDriveSpaces, 

                                                                           selection );

                    break;

                    }                

                }

            }        

        }

    // Not cached

    else

        {

        dlgResult = iCommonDialogs->ShowDriveSelectionDialogL( aSize, 

                                                               driveUnits, 

                                                               aDriveSpaces, 

                                                               selection );

        }

    if ( dlgResult == KErrNoMemory )

        {                       

        // No memory

        iResult = TSisxUIResult( EUiResultInsufficientMemory );

        selection = -1;                        

        }  

    else if ( dlgResult == KErrCancel )

        {

        // User cancelled

        iResult = TSisxUIResult( EUiResultCancelled );

        selection = -1;                        

        }    

    // If the result is valid, put it to the cache

    else if ( selection >= 0 )

        {            

        iCache->SetDrive( driveUnits[selection] );

        }

    CleanupStack::PopAndDestroy(); // driveUnits

    iShowingDialog = EFalse;

    return selection;    

    }

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

// CSisxUIHandler::DisplayUpgradeL

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

// on the device.

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

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

//

TBool CSisxUIHandler::DisplayUpgradeL( const Swi::CAppInfo& aAppInfo, 

                                       const Swi::CAppInfo& aExistingAppInfo ) 

    {

    iShowingDialog = ETrue;

    TBool result( EFalse );

    TVersion newVersion = aAppInfo.AppVersion();

    TVersion oldVersion = aExistingAppInfo.AppVersion();

    // Display "Replace?" confirmation query only if the new version is older

    // than the currently installed old version (i.e. when downgrading). See

    // also User::QueryVersionSupported() although it has bit different meaning.

    TBool downgrading = ( newVersion.iMajor < oldVersion.iMajor ||

    if( !downgrading )

        {

        iShowingDialog = EFalse;

        return ETrue;

        }

    // Create strings from the version numbers

    //

    HBufC* tempBuf = 

        CommonUI::CUIUtils::ConstructVersionStringLC( oldVersion.iMajor, 

                                                      oldVersion.iMinor, 

                                                      oldVersion.iBuild );

    HBufC* oldVersionBuf = HBufC::NewLC( KLRE().Length() + tempBuf->Length() + KPDF().Length() ); 

    TInt position = tempBuf->Find( KLeftParenthes() );

    if ( position >= 0 )

        {

        oldVersionBuf->Des() = tempBuf->Mid( 0, position );

        oldVersionBuf->Des() += KLRE();

        oldVersionBuf->Des() += tempBuf->Mid( position, tempBuf->Length() - position );

        oldVersionBuf->Des() += KPDF();

        }

    else

        {

        oldVersionBuf->Des() = *tempBuf;	

        }

    CleanupStack::Pop( oldVersionBuf );    

    CleanupStack::PopAndDestroy( tempBuf );

    CleanupStack::PushL( oldVersionBuf );

    tempBuf = NULL;

    tempBuf = CommonUI::CUIUtils::ConstructVersionStringLC( newVersion.iMajor, 

                                                            newVersion.iMinor, 

                                                            newVersion.iBuild );

    HBufC* newVersionBuf = HBufC::NewLC( KLRE().Length() + tempBuf->Length() + KPDF().Length() );

    position = tempBuf->Find( KLeftParenthes() );

    if ( position >= 0 )

        {

        newVersionBuf->Des() = tempBuf->Mid( 0, position );

        newVersionBuf->Des() += KLRE();

        newVersionBuf->Des() += tempBuf->Mid( position, tempBuf->Length() - position );

        newVersionBuf->Des() += KPDF();

        }