/*

* Copyright (c) 2010 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:  Implementation of CSifUiPrivate class.

*

*/

#include "sifuiprivate.h"                       // CSifUiPrivate

#include "sifuicertificateinfo.h"               // CSifUiCertificateInfo

#include "sifuiappinfo.h"                       // CSifUiAppInfo

#include "sifuierrorinfo.h"                     // CSifUiErrorInfo

#include "sifuiinstallindicatordefinitions.h"   // indicator type label and parameter names

#include <hb/hbcore/hbsymbianvariant.h>         // CHbSymbianVariantMap

#include <hb/hbwidgets/hbdevicenotificationdialogsymbian.h> // CHbDeviceNotificationDialogSymbian

#include <apgicnfl.h>                           // CApaMaskedBitmap

#include <s32mem.h>                             // RDesReadStream

#include <e32property.h>                        // RProperty

const TInt KDriveLettersLen = 32;

const TInt KBufferGranularity = 1024;

const TInt KProgFull = 100;                     // 100%

const TUid KInstallIndicatorCategory = { 0x20022FC5 };

const TUint KInstallIndicatorStatus = 0x2002E690;

_LIT( KSifUiDefaultApplicationIcon, "qtg_large_application" );

// TODO: replace with proper logging

#ifdef _DEBUG

#define FLOG(x)         RDebug::Print(x);

#define FLOG_1(x,y)     RDebug::Print(x, y);

#define FLOG_2(x,y,z)   RDebug::Print(x, y, z);

#define FLOG_3(x,y,z,v) RDebug::Print(x, y, z, v);

#else

#define FLOG(x)

#define FLOG_1(x,y)

#define FLOG_2(x,y,z)

#define FLOG_3(x,y,z,v)

#endif

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

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

// CSifUiPrivate::NewL()

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

//

CSifUiPrivate* CSifUiPrivate::NewL()

    {

    FLOG( _L("CSifUiPrivate::NewL") );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSifUiPrivate::~CSifUiPrivate()

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

//

CSifUiPrivate::~CSifUiPrivate()

    {

    FLOG( _L("CSifUiPrivate::~CSifUiPrivate") );

    Cancel();

    delete iWait;

    delete iDeviceDialog;

    delete iVariantMap;

    delete iIndicator;

    delete iAppInfo;

    delete iSelectableDrives;

    delete iCertificateBuffer;

    }

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

// CSifUiPrivate::ShowPreparingL()

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

//

void CSifUiPrivate::ShowPreparingL()

    {

    // TODO: implement

    }

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

// CSifUiPrivate::SetMemorySelectionL()

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

//

void CSifUiPrivate::SetMemorySelectionL( const RArray<TInt>& aDriveNumbers )

    {

    FLOG( _L("CSifUiPrivate::SetMemorySelectionL") );

    if( iSelectableDrives )

        {

        delete iSelectableDrives;

        iSelectableDrives = NULL;

        }

    TInt driveCount = aDriveNumbers.Count();

    if( driveCount > 0 )

        {

        const TChar KComma = ',';

        TBuf<KDriveLettersLen> driveList;

        for( TInt index = 0; index < driveCount; ++index )

            {

            TChar driveLetter;

            TInt err = RFs::DriveToChar( aDriveNumbers[ index ], driveLetter );

            FLOG_3( _L("CSifUiPrivate::SetMemorySelectionL, index %d, drive %d, err %d"),

                    index, aDriveNumbers[ index ], err );

            if( !err )

                {

                driveList.Append( driveLetter );

                driveList.Append( KComma );

                }

            }

        iSelectableDrives = driveList.AllocL();

        }

    FLOG_1( _L("CSifUiPrivate::SetMemorySelectionL, iSelectableDrives=%S"), iSelectableDrives );

    }

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

// CSifUiPrivate::SetCertificateInfoL()

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

//

void CSifUiPrivate::SetCertificateInfoL(

        const RPointerArray<CSifUiCertificateInfo>& aCertificates )

    {

    FLOG( _L("CSifUiPrivate::SetCertificateInfoL") );

    if( iCertificateBuffer )

        {

        delete iCertificateBuffer;

        iCertificateBuffer = NULL;

        }

    if( aCertificates.Count() )

        {

        iCertificateBuffer = CBufFlat::NewL( KBufferGranularity );

        RBufWriteStream writeStream( *iCertificateBuffer );

        CleanupClosePushL( writeStream );

        TInt32 count = aCertificates.Count();

        writeStream.WriteInt32L( count );

        for( TInt index = 0; index < count; ++index )

           {

           aCertificates[ index ]->ExternalizeL( writeStream );

           }

        CleanupStack::PopAndDestroy( &writeStream );

        }

    }

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

// CSifUiPrivate::ShowConfirmationL()

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

//

TBool CSifUiPrivate::ShowConfirmationL( const CSifUiAppInfo& aAppInfo )

    {

    FLOG( _L("CSifUiPrivate::ShowConfirmationL") );

    ChangeNoteTypeL( ESifUiConfirmationQuery );

    AddParamsAppInfoL( aAppInfo );

    if( iSelectableDrives )

        {

        AddParamL( KSifUiMemorySelection, *iSelectableDrives );

        }

    AddParamsCertificatesL();

    UpdateDialogAndWaitForResponseL();

    return( iDialogReturnValue == KErrNone );

    }

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

// CSifUiPrivate::SelectedDrive()

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

//

TInt CSifUiPrivate::SelectedDrive( TInt& aDriveNumber )

    {

    FLOG( _L("CSifUiPrivate::SelectedDrive") );

    if( iSelectedDriveSet )

        {

        TInt err = RFs::CharToDrive( iSelectedDrive, aDriveNumber );

        FLOG_2( _L("CSifUiPrivate::SelectedDrive, aDriveNumber=%d, err=%d"), aDriveNumber, err );

        return err;

        }

    FLOG( _L("CSifUiPrivate::SelectedDrive, KErrNotFound") );

    return KErrNotFound;

    }

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

// CSifUiPrivate::ShowProgressL()

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

//

void CSifUiPrivate::ShowProgressL( const CSifUiAppInfo& aAppInfo,

        TInt aProgressBarFinalValue, CSifUi::TInstallingPhase aPhase )

    {

    FLOG( _L("CSifUiPrivate::ShowProgressL") );

    ChangeNoteTypeL( ESifUiProgressNote );

    AddParamsAppInfoL( aAppInfo );

    AddParamL( KSifUiProgressNoteFinalValue, aProgressBarFinalValue );

    iProgressBarFinalValue = aProgressBarFinalValue;

    AddParamL( KSifUiProgressNotePhase, aPhase );

    iInstallingPhase = aPhase;

    AddParamsHiddenButtonsL();

    UpdateDialogOrIndicatorWithoutWaitingL();

    }

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

// CSifUiPrivate::IncreaseProgressBarValueL()

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

//

void CSifUiPrivate::IncreaseProgressBarValueL( TInt aNewValue )

    {

    FLOG_1( _L("CSifUiPrivate::IncreaseProgressBarValueL, aNewValue=%d"), aNewValue );

    ChangeNoteTypeL( ESifUiProgressNote );

    AddParamL( KSifUiProgressNoteValue, aNewValue );

    iProgressBarCurrentValue += aNewValue;

    AddParamsHiddenButtonsL();

    UpdateDialogOrIndicatorWithoutWaitingL();

    }

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

// CSifUiPrivate::IsCancelled()

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

//

TBool CSifUiPrivate::IsCancelled()

    {

    return( iDialogReturnValue == KErrCancel );

    }

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

// CSifUiPrivate::ShowCompleteL()

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

//

void CSifUiPrivate::ShowCompleteL()

    {

    FLOG( _L("CSifUiPrivate::ShowCompleteL") );

    ChangeNoteTypeL( ESifUiCompleteNote );

    AddParamsHiddenButtonsL();

    CompleteDialogOrIndicatorAndWaitForResponseL( KErrNone );

    }

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

// CSifUiPrivate::ShowFailedL()

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

//

void CSifUiPrivate::ShowFailedL( const CSifUiErrorInfo& aErrorInfo )

    {

    FLOG_1( _L("CSifUiPrivate::ShowFailedL, aErrorCode=%d"), aErrorInfo.ErrorCode() );

    ChangeNoteTypeL( ESifUiErrorNote );

    AddParamL( KSifUiErrorCategory, aErrorInfo.ErrorCategory() );

    AddParamL( KSifUiErrorCode, aErrorInfo.ErrorCode() );

    AddParamL( KSifUiErrorCodeExtended, aErrorInfo.ExtendedErrorCode() );

    AddParamL( KSifUiErrorMessage, aErrorInfo.ErrorMessage() );

    AddParamL( KSifUiErrorDetails, aErrorInfo.ErrorMessageDetails() );

    AddParamsHiddenButtonsL();

    CompleteDialogOrIndicatorAndWaitForResponseL( aErrorInfo.ErrorCode() );

    }

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

// CSifUiPrivate::SetButtonVisible()

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

//

void CSifUiPrivate::SetButtonVisible( CSifUi::TOptionalButton aButton, TBool aIsVisible )

    {

    FLOG( _L("CSifUiPrivate::SetButtonVisible") );

    switch( aButton )

        {

        case CSifUi::EHideProgressButton:

            iNoHideProgressButton = !aIsVisible;

            break;

        case CSifUi::ECancelProgressButton:

            iNoCancelProgressButton = !aIsVisible;

            break;

        case CSifUi::EShowInAppLibButton:

            iNoShowInAppLibButton = !aIsVisible;

            break;

        case CSifUi::EErrorDetailsButton:

            iNoErrorDetailsButton = !aIsVisible;

            break;

        default:

            break;

        }

    }

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

// CSifUiPrivate::ShowGrantCapabilitiesL()

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

//

TBool CSifUiPrivate::ShowGrantCapabilitiesL( const TCapabilitySet& aCapabilities )

    {

    CBufFlat* buffer = CBufFlat::NewL( KBufferGranularity );

    CleanupStack::PushL( buffer );

    RBufWriteStream writeStream( *buffer );

    CleanupClosePushL( writeStream );

    writeStream.CommitL();

    CleanupStack::PopAndDestroy( &writeStream );

    UpdateDialogAndWaitForResponseL();

    }

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

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

//

    {

    }

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

// CSifUiPrivate::DoCancel()

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

//

void CSifUiPrivate::DoCancel()

    {

    FLOG( _L("CSifUiPrivate::DoCancel") );

        {

        iWait->AsyncStop();

        }

    }

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

// CSifUiPrivate::RunL()

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

//

void CSifUiPrivate::RunL()

    {

    FLOG_1( _L("CSifUiPrivate::RunL, iStatus.Int()=%d"), iStatus.Int() );

        {

        iWait->AsyncStop();

        }

    }

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

// CSifUiPrivate::DataReceived()

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

//

void CSifUiPrivate::DataReceived( CHbSymbianVariantMap& aData )

    {

    FLOG( _L("CSifUiPrivate::DataReceived") );

    const CHbSymbianVariant* selectedDriveVariant = aData.Get( KSifUiSelectedMemory );

    if( selectedDriveVariant )

        {

        iSelectedDrive = *( selectedDriveVariant->Value<TChar>() );

        iSelectedDriveSet = ETrue;

        FLOG_1( _L("CSifUiPrivate::DataReceived, iSelectedDrive=%d"), (TUint)iSelectedDrive );

        }

    const CHbSymbianVariant* variant = aData.Get( KSifUiQueryReturnValue );

    if( variant )

        {

        TInt* value = variant->Value<TInt>();

        if( value )

            {

            TSifUiDeviceDialogReturnValue returnValue =

                    static_cast<TSifUiDeviceDialogReturnValue>( *value );

            switch( returnValue )

                {

                case ESifUiContinue:

                    iDialogReturnValue = KErrNone;

                    WaitedResponseReceived( KErrNone );

                    break;

                case ESifUiCancel:

                    iDialogReturnValue = KErrCancel;

                    WaitedResponseReceived( KErrNone );

                    break;

                case ESifUiIndicator:

                    ActivateInstallIndicatorL();

                    break;

                default:

                    __ASSERT_DEBUG( EFalse, User::Invariant() );

                    break;

                }

            }

        else

            {

            __ASSERT_DEBUG( EFalse, User::Invariant() );

            }

        }

    }

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

// CSifUiPrivate::DeviceDialogClosed()

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

//

void CSifUiPrivate::DeviceDialogClosed( TInt aCompletionCode )

    {

    FLOG_1( _L("CSifUiPrivate::DeviceDialogClosed, aCompletionCode=%d"), aCompletionCode );

    iIsDisplayingDialog = EFalse;

    WaitedResponseReceived( aCompletionCode );

    }

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

// CSifUiPrivate::IndicatorUserActivated()

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

//

void CSifUiPrivate::IndicatorUserActivated( const TDesC& aType,

        CHbSymbianVariantMap& /*aData*/ )

    {

    FLOG( _L("CSifUiPrivate::IndicatorUserActivated") );