/*

* Copyright (c) 2006-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:   Definition of CNcdInstallationService

*

*/

#include "ncdinstallationserviceimpl.h"

#include <apmstd.h>

#include <apmrec.h>

#include <bautils.h>

#include <swi/sisregistrypackage.h>

#include <caf/caf.h>

#include <caf/supplier.h> 

#include <caf/importfile.h>

#include <Oma2Agent.h>

#include <s32file.h>

#include <e32property.h>

#include <sacls.h>

#include "ncdinstallationserviceobserver.h"

#include "ncdactiveoperationobserver.h"

#include "ncdsilentinstallactiveobserver.h"

#include "ncderrors.h"

#include "catalogsutils.h"

#include "catalogsconstants.h"

#include "catalogsdebug.h"

_LIT( KJadFileExtension, ".jad" );

const TInt KDelayWhenAppListInvalid = 500000;

const TUint KFileOpenFlags = EFileShareReadersOrWriters;

//const TInt KWidgetBundleIdLength = KMaxFileName + 1; 

// ======== CALLBACK FUNCTION ========

static TInt InstallationCompleteCallback( TAny* aData )

    {

    DLTRACEIN((""));

    TRAPD( err,

        {

        CNcdInstallationService* service = 

            reinterpret_cast<CNcdInstallationService*>( aData );

        DASSERT( service );

        service->NotifyObserverL();

        } );

    DLTRACEOUT((""));

    return err;

    }

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

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

// Constructor.

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

//

CNcdInstallationService* CNcdInstallationService::NewL()

    {

    CNcdInstallationService* self = NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// Constructor.

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

//

CNcdInstallationService* CNcdInstallationService::NewLC()

    {

    CNcdInstallationService* self =

        new (ELeave) CNcdInstallationService();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor.

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

//

CNcdInstallationService::~CNcdInstallationService()

    {

    DLTRACEIN((""));

    delete iSilentInstallActiveObserver;

    iSilentInstallActiveObserver = NULL;

    iRegistrySession.Close();

    iFs.Close();

    iAknsSrv.Close();

    delete iInstallationCompleteCallback;

    delete iJadFileName;

    delete iRecognizedMime;

    delete iResults;

    delete iArguments;

    iApaLs.Close();

    if( iThemes )

        {

        iThemes->ResetAndDestroy();

        delete iThemes;        

        }

    // Deletes iInstallStatusObserver and closes iInstaller

    CancelInstall(); 

    iRomUids.Close();

    iScrSession.Close();

    iInstalledWidgetsInfos.ResetAndDestroy();

    }

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

// Constructor.

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

//

CNcdInstallationService::CNcdInstallationService()

    {

    }

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

// Constructor.

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

//

void CNcdInstallationService::ConstructL()

    {

    DLTRACEIN((""));

    iResults = 0;

    iArguments = 0;

    User::LeaveIfError( iFs.Connect() );

    User::LeaveIfError( iFs.ShareProtected() );

    User::LeaveIfError( iRegistrySession.Connect() );

    User::LeaveIfError( iAknsSrv.Connect() );

    User::LeaveIfError( iScrSession.Connect());

    iInstallationCompleteCallback = new(ELeave) CAsyncCallBack( 

        TCallBack( InstallationCompleteCallback, this ),

        CActive::EPriorityStandard );  

    InitializeRomApplicationListL();

    }

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

// Installs all kinds of files.

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

//

void CNcdInstallationService::InstallL( const TDesC& aFileName,

                                        const TDesC& aMimeType,

                                        const TNcdItemPurpose& aPurpose )

    {

    DLTRACEIN((""));

    RFile file;

    CleanupClosePushL( file );

    User::LeaveIfError( file.Open( FileServerSession(), aFileName, KFileOpenFlags ) ); 

    InstallL( file, aMimeType, aPurpose, NULL );

    CleanupStack::PopAndDestroy( &file );

    DLTRACEOUT((""));        

    }

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

// Installs all kinds of files.

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

//

void CNcdInstallationService::InstallL( RFile& aFile,

                                        const TDesC& aMimeType,

                                        const TNcdItemPurpose& aPurpose )

    {

    DLTRACEIN((""));

    InstallL( aFile, aMimeType, aPurpose, NULL );

    DLTRACEOUT((""));        

    }

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

// Installs java files.

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

//

void CNcdInstallationService::InstallJavaL( const TDesC& aFileName,

                                            const TDesC& aMimeType,

                                            const TDesC8& aDescriptorData )

    {

    DLTRACEIN((""));

    RFile file;

    CleanupClosePushL( file );

    User::LeaveIfError( file.Open( FileServerSession(), aFileName, KFileOpenFlags ) );     

    InstallJavaL( file, aMimeType, aDescriptorData, NULL );

    CleanupStack::PopAndDestroy( &file );

    DLTRACEOUT((""));

    }

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

// Installs java files.

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

//

void CNcdInstallationService::InstallJavaL( RFile& aFile,

                                            const TDesC& aMimeType,

                                            const TDesC8& aDescriptorData )

    {

    DLTRACEIN((""));    

    InstallJavaL( aFile, aMimeType, aDescriptorData, NULL );    

    DLTRACEOUT((""));

    }

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

// Installs all kinds of files silently.

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

//

void CNcdInstallationService::SilentInstallL( RFile& aFile,

                                        const TDesC& aMimeType,

                                        const TNcdItemPurpose& aPurpose,

                                        const Usif::COpaqueNamedParams* aInstallOptionsPckg )

    {

    DLTRACEIN((""));

    if ( iSilentInstallActiveObserver == NULL )

        {

        DLINFO(("Create active observer for silent install"));

        iSilentInstallActiveObserver = CNcdSilentInstallActiveObserver::NewL( *this );        

        }

    InstallL( aFile, aMimeType, aPurpose, aInstallOptionsPckg );

    DLTRACEOUT(("")); 

    }

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

// Installs java files silently.

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

//

void CNcdInstallationService::SilentInstallJavaL( RFile& aFile,

                                            const TDesC& aMimeType,

                                            const TDesC8& aDescriptorData,

                                            const Usif::COpaqueNamedParams* aInstallOptionsPckg )

    {

    DLTRACEIN((""));

    if ( iSilentInstallActiveObserver == NULL )

        {

        DLINFO(("Create active observer for silent install"));

        iSilentInstallActiveObserver = CNcdSilentInstallActiveObserver::NewL( *this );        

        }

    InstallJavaL( aFile, aMimeType, aDescriptorData, aInstallOptionsPckg );

    DLTRACEOUT((""));

    }

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

// Installs widget silently.

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

//

void CNcdInstallationService::SilentInstallWidgetL( RFile& aFile,

                                                    const Usif::COpaqueNamedParams* aInstallOptionsPckg )

    {

    DLTRACEIN((""));

    if ( iSilentInstallActiveObserver == NULL )

        {

        DLINFO(("Create active observer for silent install"));

        iSilentInstallActiveObserver = CNcdSilentInstallActiveObserver::NewL( *this );        

        }

    InstallWidgetL( aFile, aInstallOptionsPckg );

    DLTRACEOUT((""));

    }

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

// Cancell silent install.

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

//

void CNcdInstallationService::CancelSilentInstall( HBufC*& aFileName,

                                                   TUid& aAppUid,

                                                   TInt& aError )

    {

    DLTRACEIN((""));

    // Silent install can only be cancelled if silent is allowed.

    // The capability check makes sure of this.

    // Set intial values for the reference parameters.

    delete aFileName;

    aFileName = NULL;

    aAppUid = KNullUid;

    aError = KErrCancel;

    if ( iBusy )

        {

        DLINFO(("Install operation was busy"));

        // Some operation is on. Here we expect that it is silent.

        // Inform the installer that the asynchronous silent install request 

        // needs to be cancelled. 

        // Because we use a dummy active object to observe

        // completion of installation and that dummy object uses call backs

        // to inform completion to observer, we have to cancel the operation

        // by using the dummy object here.

        aError = iSilentInstallActiveObserver->CancelAsyncOperation();

        if ( aError == KErrNone )

            {

            DLINFO(("Installation was success even if cancel was issued."))

            // The installation was finished after all.

            TRAPD( trapError, 

                   HandleSilentInstallSuccessAfterCancelL( aFileName,

                                                           aAppUid,

                                                           aError ) );

            if ( trapError != KErrNone )

                {

                DLERROR(("Install success handling leave."));

                aError = trapError;

                }

            }

        // Do cleaning if necessary.

        if( iJadFileName != NULL )

            {

            // Delete tmp JAD file that was created in the beginning of

            // the install operation. It will be recreated in new install operation

            // if needed.

            BaflUtils::DeleteFile( iFs, *iJadFileName ); // NOTE, error ignored

            delete iJadFileName;

            iJadFileName = NULL;

            }

        // Reset information flags.            

        InstallationFinishedSetup( aError );

        }

    }

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

// Sets observer for installation services.

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

//

void CNcdInstallationService::SetObserver(

                            MNcdInstallationServiceObserver& aObserver )

    {

    iObserver = &aObserver;

    }

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

// Gets version of installed application by using its UID.

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

//

TInt CNcdInstallationService::ApplicationVersion( const TUid& aUid,

                                                  TCatalogsVersion& aVersion )

    {

    DLTRACEIN(("Uid=%X",aUid.iUid));

    // First case: see if the uid is directly in the sis registry.

    Swi::RSisRegistryEntry entry;

    TVersion version;

    TRAPD( err, 

        {

        SisRegistryEntryLC( entry, aUid );         

        // Get version number

        version = entry.VersionL();

        CleanupStack::PopAndDestroy( &entry );

        });

    if ( err != KErrNone ) 

        {

        DLTRACEOUT(("Error: %d", err));

        return err;

        }

    aVersion.iMajor = version.iMajor;

    aVersion.iMinor = version.iMinor;

    aVersion.iBuild = version.iBuild;        

    DLTRACEOUT(("err=%d",err));

    return err;

    }

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

// Checks whether an application is installed on the device.

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

//

TBool CNcdInstallationService::IsApplicationInstalledL( const TUid& aUid )

    {

    DLTRACEIN(("uid=%X",aUid.iUid));

    TBool result = EFalse;

    Swi::RSisRegistryEntry entry;

    // First case: See if the UID is directly in the SIS Registry.

    TRAPD( err, 

        {

        SisRegistryEntryLC( entry, aUid ); 

        DLTRACE(("Check that entry is present"));

        result = entry.IsPresentL();

        CleanupStack::PopAndDestroy( &entry );

        });

    LeaveIfNotErrorL( err, KErrNotFound );    

    // Third case: see if the UID is mapped to the Java Registry or is a Widget

    if ( !result )

        {

        result = ( JavaAppExistsL( aUid ) || 

                   WidgetExistsL( aUid ) );

        }

    // Check if the app is ROM only

    if ( !result ) 

        {

        result = IsRomApplication( aUid );

        }

    DLTRACEOUT(("result=%d",result));

    return result;

    }

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

// Opens SIS registry entry

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

//

void CNcdInstallationService::SisRegistryEntryLC( 

    Swi::RSisRegistryEntry& aEntry,

    const TUid& aUid )

    {

    DLTRACEIN((""));    

    CleanupClosePushL( aEntry );

    if ( aEntry.Open( iRegistrySession, aUid ) == KErrNone )

        {

        DLTRACEOUT(("Entry opened"));

        return;

        }

    // Second case: See if the UID is mapped to a package/entry

    // in the registry ( -> APP UID that differs from SIS UID ).

    Swi::CSisRegistryPackage* sisRegistryPackage =

        iRegistrySession.SidToPackageL( aUid );

    CleanupStack::PushL( sisRegistryPackage );

    TInt err = aEntry.OpenL( iRegistrySession, *sisRegistryPackage );

    User::LeaveIfError( err );

    CleanupStack::PopAndDestroy( sisRegistryPackage );

    DLTRACEOUT(("Entry opened"));    

    }

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

// Open java suite entry

//

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

//

TBool CNcdInstallationService::JavaAppExistsL( 

    const TUid& aUid )

    {

    DLTRACEIN((""));

    TBool retVal = EFalse;

    Usif::TComponentId compId = 0;

    // Get component id

    TRAPD( ret, compId = iScrSession.GetComponentIdForAppL( aUid ) ); 

    if ( ret == KErrNotFound )

        {

        return EFalse;

        }

    else if  (ret != KErrNone )

        {

        User::Leave( ret );

        }

    Usif::CComponentEntry* entry = Usif::CComponentEntry::NewLC();

    TRAPD(err, iScrSession.GetComponentL(compId, *entry));

    if ( err == KErrNotFound )

        {

        retVal = EFalse;

        }

    else if  (err != KErrNone )

        {

        User::Leave( err );

        }

    else

        {

        // type == Java ?

        if ( entry->SoftwareType().Compare( Usif::KSoftwareTypeJava ) == 0 )

            {

            retVal = ETrue;

            }

        else

            {

            retVal = EFalse;

            }

        }

    CleanupStack::PopAndDestroy(entry);

    return retVal;