/*

* 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 <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 KProgFull = 100;                     // 100%

const TUid KInstallIndicatorCategory = { 0x20022FC5 };

const TUint KInstallIndicatorStatus = 0x2002E690;

_LIT( KSifUiDefaultApplicationIcon, "qtg_large_application" );

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

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

// CSifUiPrivate::NewL()

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

//

CSifUiPrivate* CSifUiPrivate::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSifUiPrivate::~CSifUiPrivate()

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

//

CSifUiPrivate::~CSifUiPrivate()

    {

    Cancel();

    delete iWait;

    delete iDeviceDialog;

    delete iVariantMap;

    delete iIndicator;

    delete iAppInfo;

    delete iSelectableDrives;

    delete iCertificateBuffer;

    }

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

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

//

    {

    }

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

// CSifUiPrivate::SetMemorySelectionL()

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

//

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

    {

    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 );

            if( !err )

                {

                driveList.Append( driveLetter );

                driveList.Append( KComma );

                }

            }

        iSelectableDrives = driveList.AllocL();

        }

    }

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

// CSifUiPrivate::SetCertificateInfoL()

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

//

void CSifUiPrivate::SetCertificateInfoL(

        const RPointerArray<CSifUiCertificateInfo>& aCertificates )

    {

    if( iCertificateBuffer )

        {

        delete iCertificateBuffer;

        iCertificateBuffer = NULL;

        }

    if( aCertificates.Count() )

        {

        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::ShowProgressL()

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

//

void CSifUiPrivate::ShowProgressL( const CSifUiAppInfo& aAppInfo,

        TInt aProgressBarFinalValue, CSifUi::TInstallingPhase aPhase )

    {

    ChangeNoteTypeL( ESifUiProgressNote );

    AddParamsAppInfoL( aAppInfo );

    AddParamL( KSifUiProgressNoteFinalValue, aProgressBarFinalValue );

    iProgressBarFinalValue = aProgressBarFinalValue;

    AddParamL( KSifUiProgressNotePhase, aPhase );

    iInstallingPhase = aPhase;

    AddParamsHiddenButtonsL();

    UpdateDialogOrIndicatorWithoutWaitingL();

    }

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

// CSifUiPrivate::IncreaseProgressBarValueL()

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

//

void CSifUiPrivate::IncreaseProgressBarValueL( TInt aNewValue )

    {

    ChangeNoteTypeL( ESifUiProgressNote );

    AddParamL( KSifUiProgressNoteValue, aNewValue );

    iProgressBarCurrentValue += aNewValue;

    AddParamsHiddenButtonsL();

    UpdateDialogOrIndicatorWithoutWaitingL();

    }

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

// CSifUiPrivate::IsCancelled()

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

//

TBool CSifUiPrivate::IsCancelled()

    {

    return( iDialogReturnValue == KErrCancel );

    }

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

// CSifUiPrivate::SetButtonVisible()

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

//

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

    {

    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::DoCancel()

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

//

void CSifUiPrivate::DoCancel()

    {

    if( iWait && iWait->IsStarted() && iWait->CanStopNow() )

        {

        iWaitCompletionCode = KErrCancel;

        iWait->AsyncStop();

        }

    }

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

// CSifUiPrivate::RunL()

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

//

void CSifUiPrivate::RunL()

    {

    if( iWait )

        {

        iWait->AsyncStop();

        }

    }

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

// CSifUiPrivate::DataReceived()

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

//

void CSifUiPrivate::DataReceived( CHbSymbianVariantMap& aData )

    {

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

    if( selectedDriveVariant )

        {

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

        iSelectedDriveSet = ETrue;

        }

    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 )

    {

    iIsDisplayingDialog = EFalse;

    WaitedResponseReceived( aCompletionCode );

    }

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

// CSifUiPrivate::IndicatorUserActivated()

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

//

void CSifUiPrivate::IndicatorUserActivated( const TDesC& aType,

        CHbSymbianVariantMap& /*aData*/ )

    {

    if( aType == KSifUiInstallIndicatorType )

        {

        CloseInstallIndicator();

        iIsFirstTimeToDisplay = ETrue;

        TRAP_IGNORE( DisplayDeviceDialogL() );

        }

    }

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

// CSifUiPrivate::CSifUiPrivate()

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

//

CSifUiPrivate::CSifUiPrivate() : CActive( CActive::EPriorityStandard ),

        iIsFirstTimeToDisplay( ETrue )

    {

    CActiveScheduler::Add( this );

    }

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

// CSifUiPrivate::ConstructL()

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

//

void CSifUiPrivate::ConstructL()

    {

    iWait = new( ELeave ) CActiveSchedulerWait;

    // iDeviceDialog is created later, in the first call of DisplayDeviceDialogL()

    // iIndicator is also created later, in the first call of ActivateInstallIndicator()

    }

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

// CSifUiPrivate::ClearParams()

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

//

void CSifUiPrivate::ClearParams()

    {

    if( iVariantMap )

        {

        delete iVariantMap;

        iVariantMap = NULL;

        }

    }