/*

* Copyright (c) 2008-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:   SisxPackageInfo implementation

*

*/

#include "appmngr2sisxpackageinfo.h"    // CAppMngr2SisxPackageInfo

#include "appmngr2sisxruntime.h"        // KAppMngr2SisxUid

#include "appmngr2sisxinfoiterator.h"   // CAppMngr2SisxInfoIterator

#include "appmngr2sisxunknownlist.h"    // CAppMngr2SisxUnknownList

#include "appmngr2sisx.hrh"             // Icon IDs

#include <appmngr2driveutils.h>         // TAppMngr2DriveUtils

#include <appmngr2debugutils.h>         // FLOG macros

#include <appmngr2common.hrh>           // Command IDs

#include <appmngr2.rsg>                 // Resource IDs

#include <eikenv.h>                     // CEikonEnv

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

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

// CAppMngr2SisxPackageInfo::NewL()

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

//

CAppMngr2SisxPackageInfo* CAppMngr2SisxPackageInfo::NewL(

        CAppMngr2Runtime& aRuntime, const TDesC& aFileName, RFs& aFs )

    {

    CAppMngr2SisxPackageInfo* self = new (ELeave) CAppMngr2SisxPackageInfo(

            aRuntime, aFs );

    CleanupStack::PushL( self );

    self->ConstructL( aFileName );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAppMngr2SisxPackageInfo::~CAppMngr2SisxPackageInfo()

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

//

CAppMngr2SisxPackageInfo::~CAppMngr2SisxPackageInfo()

    {

    CancelCommand();

    delete iName;

    delete iDetails;

    delete iFileName;

    }

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

// CAppMngr2SisxPackageInfo::IconIndex()

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

//

TInt CAppMngr2SisxPackageInfo::IconIndex() const

    {

    return EQgnMenuAmSis;

    }

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

// CAppMngr2SisxPackageInfo::Name()

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

//

const TDesC& CAppMngr2SisxPackageInfo::Name() const

    {

    if( iName )

        {

        return *iName;

        }

    return KNullDesC;

    }

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

// CAppMngr2SisxPackageInfo::Details()

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

//

const TDesC& CAppMngr2SisxPackageInfo::Details() const

    {

    if( iDetails )

        {

        return *iDetails;

        }

    return KNullDesC;

    }

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

// CAppMngr2SisxPackageInfo::IndicatorIconIndex()

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

//

TInt CAppMngr2SisxPackageInfo::IndicatorIconIndex() const

    {

    if( IsShowOnTop() )

        {

        return EQgnIndiAmInstNoAdd;

        }

    return CAppMngr2InfoBase::IndicatorIconIndex();

    }

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

// CAppMngr2SisxPackageInfo::SupportsGenericCommand()

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

//

TBool CAppMngr2SisxPackageInfo::SupportsGenericCommand( TInt /*aCmdId*/ )

    {

    return ETrue;

    }

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

// CAppMngr2SisxPackageInfo::HandleCommandL()

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

//

void CAppMngr2SisxPackageInfo::HandleCommandL( TInt aCommandId, TRequestStatus& aStatus )

    {

    FLOG( "CAppMngr2SisxPackageInfo::HandleCommandL( %d )", aCommandId );

    switch( aCommandId )

        {

        case EAppMngr2CmdViewDetails:

            ShowDetailsL();

            break;

        case EAppMngr2CmdInstall:

            if( !iSWInstLauncher )

                {

                SwiUI::RSWInstLauncher* swInstLauncher = new (ELeave) SwiUI::RSWInstLauncher;

                CleanupStack::PushL( swInstLauncher );

                User::LeaveIfError( swInstLauncher->Connect() );

                CleanupStack::Pop( swInstLauncher );

                iSWInstLauncher = swInstLauncher;

                }

            iSWInstLauncher->Install( aStatus, *iFileName );

            return;     // async operation started

        case EAppMngr2CmdRemove:

            if( ShowDeleteConfirmationQueryL() )

                {

                HandleDeleteL();

                }

            else

                {

                User::Leave( KErrCancel );

                }

            break;

        default:

            break;

        }

    // sync operation done, complete aStatus

    TRequestStatus* statusPtr = &aStatus;

    User::RequestComplete( statusPtr, KErrNone );

    }

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

// CAppMngr2SisxPackageInfo::HandleCommandResultL()

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

//

void CAppMngr2SisxPackageInfo::HandleCommandResultL( TInt aStatus )

    {

    FLOG( "CAppMngr2SisxPackageInfo::HandleCommandResultL( %d )", aStatus );

    if( iSWInstLauncher )

        {

        iSWInstLauncher->Close();

        delete iSWInstLauncher;

        iSWInstLauncher = NULL;

        }

    if( aStatus != SwiUI::KSWInstErrUserCancel && aStatus != KErrCancel )

        {

        User::LeaveIfError( aStatus );

        }

    }

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

// CAppMngr2SisxPackageInfo::CancelCommand()

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

//

void CAppMngr2SisxPackageInfo::CancelCommand()

    {

    FLOG( "CAppMngr2SisxPackageInfo::CancelCommand()" );

    if( iSWInstLauncher )

        {

        iSWInstLauncher->CancelAsyncRequest( SwiUI::ERequestUninstall );

        iSWInstLauncher->Close();

        delete iSWInstLauncher;

        iSWInstLauncher = NULL;

        }

    }

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

// CAppMngr2SisxPackageInfo::CAppMngr2SisxPackageInfo()

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

//

CAppMngr2SisxPackageInfo::CAppMngr2SisxPackageInfo( CAppMngr2Runtime& aRuntime,

        RFs& aFs ) : CAppMngr2PackageInfo( aRuntime, aFs )

    {

    }

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

// CAppMngr2SisxPackageInfo::ConstructL()

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

//

void CAppMngr2SisxPackageInfo::ConstructL( const TDesC& aFileName )

    {

    FLOG( "CAppMngr2SisxPackageInfo::ConstructL( %S )", &aFileName );

    CAppMngr2PackageInfo::ConstructL();    // base class

    TEntry fileEntry;

    User::LeaveIfError( iFs.Entry( aFileName, fileEntry ) );

    if( aFileName.Find( KAppMngr2DaemonPrivateFolder ) != KErrNotFound )

        {

        // untrusted application, display on top of others

        iShowOnTop = ETrue;

        // Installer generates untrusted app SISX files using UID names

        // (e.g. "20001234.SIS"). Get the real package name and use it

        // as the name of the untrusted application SISX item in UI.

        TInt drive;

        User::LeaveIfError( RFs::CharToDrive( aFileName[ 0 ], drive ) );

        CAppMngr2SisxUnknownList* unknownList = CAppMngr2SisxUnknownList::NewLC( drive );

        TInt index = unknownList->FindPkgWithUIDName( fileEntry.iName );

        if( index > 0 && index < unknownList->PkgCount() )

            {

            // display package name instead of UID name

            Swi::CUninstalledPackageEntry& pkgEntry = unknownList->PkgEntry( index );

            iName = pkgEntry.Name().AllocL();

            }

        else

            {

            // package name not found, display file name anyway

            iName = fileEntry.iName.AllocL();

            }

        CleanupStack::PopAndDestroy( unknownList );

        iDetails = Runtime().EikonEnv().AllocReadResourceL( R_SWINS_UNIT_UNTRUSTED );

        }

    else

        {

        // normal SIS file, use file name

        iName = fileEntry.iName.AllocL();

        iDetails = SizeStringWithUnitsL( fileEntry.iSize );

        }

    FLOG( "CAppMngr2SisxPackageInfo::ConstructL, iName = %S", iName );

    FLOG( "CAppMngr2SisxPackageInfo::ConstructL, iDetails = %S", iDetails );

    iFileName = aFileName.AllocL();

    iLocation = TAppMngr2DriveUtils::LocationFromFileNameL( aFileName, iFs );

    iLocationDrive = TDriveUnit( aFileName );

    }

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

// CAppMngr2SisxPackageInfo::HandleDeleteL()

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

//

void CAppMngr2SisxPackageInfo::HandleDeleteL()

    {

    FLOG( "CAppMngr2SisxPackageInfo::HandleDeleteL()" );

    // CAppMngr2SisxUnknownList must be used to delete pre-installed SISX files,

    // which are located in SWI daemon's private folder and that are listed in

    // the CAppMngr2SisxUnknownList (i.e. in the Swi::UninstalledSisPackages).

    // These SISX files are applications that have been installed in memory

    // card (using some other device), and that were not installed in this device

    // when the memory card was inserted (e.g. because of security reasons).

    if( iFileName )

        {

        if( iFileName->Find( KAppMngr2PreInstalledPath ) != KErrNotFound )

            {

            TParsePtrC parser( *iFileName );

            TInt drive;

            User::LeaveIfError( RFs::CharToDrive( parser.Drive()[ 0 ], drive ) );

            CAppMngr2SisxUnknownList* unknownList = CAppMngr2SisxUnknownList::NewLC( drive );

            TInt index = unknownList->FindPkgWithUIDName( parser.NameAndExt() );

            if( index >= 0 && index < unknownList->PkgCount() )

                {

                // found in "unknown" list, remove using Swi::UninstalledSisPackages

                unknownList->RemovePkgL( index );

                }

            else 

                {

                // some other sisx package, try to delete using RFs

                User::LeaveIfError( iFs.Delete( *iFileName ) );

                }

            CleanupStack::PopAndDestroy( unknownList );

            }

        else

            {

            // normal sisx package, delete using RFs

            User::LeaveIfError( iFs.Delete( *iFileName ) );

            }

        }

    }

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

// CAppMngr2SisxPackageInfo::ShowDetailsL()

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

//

void CAppMngr2SisxPackageInfo::ShowDetailsL()

    {

    FLOG( "CAppMngr2SisxPackageInfo::ShowDetailsL()" );

    CAppMngr2SisxInfoIterator* iterator = CAppMngr2SisxInfoIterator::NewL(

            *this, EAppMngr2StatusNotInstalled );

    CleanupStack::PushL( iterator );

    SwiUI::CommonUI::CCUIDetailsDialog* details = SwiUI::CommonUI::CCUIDetailsDialog::NewL();

    details->ExecuteLD( *iterator );

    CleanupStack::PopAndDestroy( iterator );

    }