/*

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

*

*/

#include "ncdinstalloperationimpl.h"

#include <s32mem.h>

#include <f32file.h>

#include <bautils.h>

#include "catalogsbasemessage.h"

#include "ncdnodemanager.h"

#include "ncdnodeimpl.h"

#include "ncdnodeidentifier.h"

#include "catalogsutils.h"

#include "catalogscontext.h"

#include "ncdproviderdefines.h"

#include "ncdnodeclassids.h"

#include "catalogsconstants.h"

#include "ncdinstallinfo.h"

#include "ncdfileinfo.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdutils.h"

#include "ncderrors.h"

#include "ncdoperationremovehandler.h"

#include "ncdnodeinstallimpl.h"

#include "ncdnodedownloadimpl.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodelink.h"

#include "ncdproviderutils.h"

#include "ncdpurchasehistoryutils.h"

#include "ncdinstallreportobserver.h"

#include "catalogsaccesspointmanager.h"

#include "catalogsconnectionmethod.h"

#include "catalogshttpconnectionmanager.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

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

// NewL

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

//

CNcdInstallOperation* CNcdInstallOperation::NewL(

    MNcdOperationRemoveHandler& aRemoveHandler,

    const CNcdNodeIdentifier& aNodeId,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdInstallReportObserver& aReportObserver,

    MCatalogsSession& aSession )

    {

    CNcdInstallOperation* self = new( ELeave ) CNcdInstallOperation( 

        aRemoveHandler,

        aGeneralManager,

        aHttpSession,        

        aReportObserver,

        aSession );

    CleanupClosePushL( *self );

    self->ConstructL( aNodeId );

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

CNcdInstallOperation::~CNcdInstallOperation()

    {

    DLTRACEIN((""));

    delete iNodeId;

    // Deletes the JAD from disk and also deletes iJadFile

    DeleteJad();

    DLTRACEOUT((""));

    }

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

// Node Id getter

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

//

const CNcdNodeIdentifier& CNcdInstallOperation::NodeIdentifier() const

    {

    return *iNodeId;

    }

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

// Cancel

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

//

void CNcdInstallOperation::Cancel() 

    {    

    DLTRACEIN(( "" ));

    // Nothing to do here. Most of the install operation

    // functionality is in proxy side.

    DLTRACEOUT(( "" ));

    }

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

// Receive message

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

//

void CNcdInstallOperation::ReceiveMessage( 

        MCatalogsBaseMessage* aMessage,

        TInt aFunctionNumber )

    {

    DLTRACEIN((""));

    DASSERT( aMessage );

    DLINFO(( "Handle: %i, aFunctionNumber=%d",

            aMessage->Handle(),

            aFunctionNumber));

    // Now, we can be sure that rest of the time iMessage exists.

    // This member variable is set for the CounterPartLost function.

    iMessage = aMessage;

    TRAPD( err, DoReceiveMessageL( aMessage, aFunctionNumber ) ); 

    if ( err != KErrNone ) 

        {

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

        CompleteMessage( iMessage, 

            ENCDOperationMessageCompletionError,

            err );

        }

    // Because the message should not be used after this, set it NULL.

    // So, CounterPartLost function will know that no messages are

    // waiting the response at the moment.

    iMessage = NULL;

    DLTRACEOUT((""));

    }

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

// Counter part lost

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

//

void CNcdInstallOperation::CounterPartLost( const MCatalogsSession& aSession )

    {

    DLTRACEIN((""));

    // This function may be called whenever -- when the message is waiting

    // response or when the message does not exist.

    // iMessage may be NULL here, because in the end of the

    // ReceiveMessage it is set to NULL. The life time of the message

    // ends shortly after CompleteAndRelease is called.

    if ( iMessage != NULL )

        {

        iMessage->CounterPartLost( aSession );

        }    

    DLTRACEOUT((""));    

    }

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

// RunOperation

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

//

TInt CNcdInstallOperation::RunOperation()

    {

    DLTRACEIN(( "Pending message: %X", iPendingMessage ));    

    DLTRACEOUT((""));

    return KErrNone;

    }

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

// Initializer

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

//

TInt CNcdInstallOperation::Initialize()

    {

    DLTRACEIN( ( "" ) );

    TRAPD( err,

        {

        DLTRACE(("Writing initialize response"));

        CBufBase* buf = CBufFlat::NewL( KBufExpandSize );

        CleanupStack::PushL( buf );

        RBufWriteStream stream( *buf );

        CleanupClosePushL( stream );

        // write completion code

        stream.WriteInt32L( ENCDOperationMessageCompletionInit );        

        // Get the file count from the node and return it to the proxy

        // Notice here that the node has to have some kind of metadata

        // in order the install operation to start.

        DLINFO(("Get the metadata of the node"));

        CNcdNode& node( iNodeManager->NodeL( *iNodeId ) );

        CNcdNodeMetaData& metaData( node.NodeMetaDataL() );

        DLINFO(("Get the install object of the metadata."));

        CNcdNodeInstall& install( metaData.InstallL() );        

        stream.WriteInt32L( install.DownloadedFiles().MdcaCount() );        

        CleanupStack::PopAndDestroy( &stream );        

        DLINFO(("Create report"));

        // Because everything has gone smoothly so far,

        // create the install report for the server reports.

        CreateReportL();        

        DLTRACE(("Response length: %i", buf->Size() ));

        iPendingMessage->CompleteAndReleaseL( buf->Ptr(0), KErrNone );

        iPendingMessage = NULL;

        CleanupStack::PopAndDestroy( buf );

        });

    if ( err != KErrNone ) 

        {

        DLTRACE( ( "Err: %d", err ) );

        iPendingMessage->CompleteAndRelease( err );

        iPendingMessage = NULL;

        }

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

    return err;    

    }

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

// Constructor

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

//

CNcdInstallOperation::CNcdInstallOperation( 

    MNcdOperationRemoveHandler& aRemoveHandler,    

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,    

    MNcdInstallReportObserver& aReportObserver,

    MCatalogsSession& aSession ) : 

    CNcdBaseOperation( aGeneralManager, &aRemoveHandler, EInstallOperation, aSession ),

    iHttpSession( aHttpSession ),

    iAccessPointManager( aGeneralManager.AccessPointManager() ),

    iReportObserver( aReportObserver ),

    iReportId( KNcdReportNotSupported )

    {

    }

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

// ConstructL

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

//

void CNcdInstallOperation::ConstructL( const CNcdNodeIdentifier& aNodeId )

    {

    DLTRACEIN( ( "" ) );

    // Call ConstructL for the base class

    CNcdBaseOperation::ConstructL();

    // copy the identifier

    iNodeId = CNcdNodeIdentifier::NewL( aNodeId );

    iInstallService = &CNcdProviderUtils::InstallationServiceL();

    DLTRACEOUT(( "" ));

    }    

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

// Gets info for an installable file from the node

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

//        

void CNcdInstallOperation::GetFileInfoL( MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    TInt nextFile = ReadFileIndexL( aMessage );

    CNcdNode& node( iNodeManager->NodeL( *iNodeId ) );

    // Notice that in order the node to start install, the

    // node has to have some kind of metadata

    CNcdNodeMetaData& metaData( node.NodeMetaDataL() );

    CNcdNodeDownload& nodeDl = metaData.DownloadL();

    CNcdNodeInstall& install( metaData.InstallL() );

    // Check that file index is in the valid range

    if ( nextFile < 0 || nextFile >= install.DownloadedFiles().MdcaCount() ) 

        {

        DLERROR(("Invalid index"));

        User::Leave( KErrArgument );

        }

    // Get item purpose        

    TUint completePurpose = 0;

    TPtrC contentMime;

    DeleteJad();

    TRAPD( error, 

        {

        const CNcdNodeContentInfo& contentInfo = 

            node.NodeMetaData()->ContentInfoL();

        completePurpose = contentInfo.Purpose();

        contentMime.Set( contentInfo.MimeType() );

        DLINFO(( _L("Content mime: %S"), &contentMime ));

        });

    LeaveIfNotErrorL( error, KErrNotFound );    

    // By default, use unknown purpose since installer

    // uses purpose for installing themes

    TNcdItemPurpose purpose = ENcdItemPurposeUnknown;

    // Check if the purpose includes theme or application

    if ( completePurpose & ENcdItemPurposeTheme ) 

        {

        DLTRACE(("Purpose: Theme"));

        purpose = ENcdItemPurposeTheme;

        }

    else if ( completePurpose & ENcdItemPurposeApplication 

        || completePurpose & ENcdItemPurposeGame 

        || completePurpose & ENcdItemPurposeScreensaver )

        {

        DLTRACE(("Purpose: Application"));

        purpose = ENcdItemPurposeApplication;

        }

    // Used to index downloadInfos.

    TInt downloadInfoIndex = nextFile;        

    // This check used to be for handling rights objects that were not really

    // rights objects, eg. a picture given in the rights uri but now it has

    // been removed

    if ( install.DownloadedFiles().MdcaCount() >

         nodeDl.DownloadInfo().Count() )

        {

        DLERROR(("Too many downloaded files, leaving with KErrCorrupt"));

        User::Leave( KErrCorrupt );

        }

    DLTRACE(("File index: %d, downloadInfoIndex: %d", nextFile, downloadInfoIndex ));

    CNcdFileInfo* fileInfo = NULL;

    // Use normal install by default

    CNcdInstallInfo::TNcdInstallType installType = 

        CNcdInstallInfo::ENcdInstallNormal;

    // Skip files that have not been downloaded or are already installed

    // Files that are downloaded are not skipped, doesn't matter 

    // if they are installed or not

    while( nextFile < install.DownloadedFiles().MdcaCount() &&

           ( !install.DownloadedFiles().MdcaPoint( nextFile ).Length() ||

           // Check if file is missing and is installed, if it's missing

           // and not installed, we give an error by failing the installation

           // on proxy side when the file is missing

            ( !BaflUtils::FileExists( CNcdProviderUtils::FileSession(), 

                install.DownloadedFiles().MdcaPoint( nextFile ) ) && (                    

            install.IsContentInstalledL( nextFile, EFalse ) >= ENcdApplicationInstalled ||

            // unless the file is launcher application which we can happily skip over

            IsOneOf( nodeDl.DownloadInfo()[ downloadInfoIndex ]->ContentUsage(),

                MNcdPurchaseDownloadInfo::ELauncher,                

                MNcdPurchaseDownloadInfo::ELauncherOpen,

                MNcdPurchaseDownloadInfo::EConsumable ) ) ) ) )

        {

        DLTRACE(("Skipping installed files or not downloaded files"));            

        nextFile++;    

        downloadInfoIndex++;

        }

    // We may have skipped over the last possible file so we have to 

    // complete the operation

    if ( nextFile == install.DownloadedFiles().MdcaCount() ) 

        {

        DLERROR(("Either nothing has been downloaded or everything is already installed"));

        HandleAllFilesInstalledL( nextFile, aMessage );

        DLTRACEOUT(("Operation complete because all files have been installed"));

        return;

        }

    // Shortcut to correct download info

    MNcdPurchaseDownloadInfo* downloadInfo( 

        nodeDl.DownloadInfo()[ downloadInfoIndex ] );       

    // Set dependency flag that we know not to update dependency/launcher

    iIsDependency = NcdPurchaseHistoryUtils::IsDependency( *downloadInfo );

    DLINFO(( _L("Descriptor type: %S"), &downloadInfo->DescriptorType() ));

    DLINFO(( _L("Descriptor name: %S"), &downloadInfo->DescriptorName() ));

    DLINFO(( _L("Descriptor URI: %S"), &downloadInfo->DescriptorUri() ));

    if ( downloadInfo->ContentMimeType().MatchF( 

            KMimeTypeMatch1JavaApplication ) != KErrNotFound ||

         downloadInfo->ContentMimeType().MatchF( 

            KMimeTypeMatch2JavaApplication ) != KErrNotFound ||

         contentMime.MatchF( 

            KMimeTypeMatch1JavaApplication ) != KErrNotFound ||

         contentMime.MatchF( 

            KMimeTypeMatch2JavaApplication ) != KErrNotFound )

        {

        if ( downloadInfo->DescriptorType().CompareF( 

            KDescriptorTypeJad ) == 0 )

            {

            DLINFO(("Java app with JAD"));

            purpose = ENcdItemPurposeApplication;

            installType = CNcdInstallInfo::ENcdInstallJad;                

            }

        else 

            {            

            DLINFO(("Java-application"));

            // Ensure that purpose is correct

            purpose = ENcdItemPurposeApplication;

            installType = CNcdInstallInfo::ENcdInstallJar;

            }

        }

    else if ( downloadInfo->ContentMimeType().MatchF(

            KMimeTypeMatchJad ) != KErrNotFound ||

        contentMime.MatchF( KMimeTypeMatchJad ) != KErrNotFound )

        {

        DLINFO(("Java app with JAD"));

        purpose = ENcdItemPurposeApplication;        

        installType = CNcdInstallInfo::ENcdInstallJad;                

        }

    DLTRACE(("Creating fileinfo"));

    // Create file info for proxy-side installer

    fileInfo = CNcdFileInfo::NewLC( 

        install.DownloadedFiles().MdcaPoint( nextFile ), 

        nodeDl.DownloadInfo()[ downloadInfoIndex ]->ContentMimeType(), 

        purpose );

    if ( installType == CNcdInstallInfo::ENcdInstallJad ) 

        {

        DLINFO(( _L("Descriptor type: %S"), &downloadInfo->DescriptorType() ));

        DLINFO(( _L("Descriptor name: %S"), &downloadInfo->DescriptorName() ));

        DLINFO(( _L("Descriptor URI: %S"), &downloadInfo->DescriptorUri() ));

        DLINFO(( "Descriptor Data: %S", &downloadInfo->DescriptorData() ));

        if ( downloadInfo->DescriptorData().Length() ) 

            {

            // This "if" is an ugly fix for embedded DD descriptors where

            // the .dm file is given in downloaddetails 

            if ( !(downloadInfo->DescriptorType() == KDescriptorTypeOdd &&

                downloadInfo->ContentUri().Length() ) )

                {

                // Writing JAD to file on this side because proxies can't

                // write to engine's private dir

                if ( iJadFile )

                {

                    DeletePtr( iJadFile );

                }

                iJadFile = 

                    CNcdProviderUtils::InstallationServiceL().WriteJadL(

                        fileInfo->FilePath(), downloadInfo->DescriptorData() );

                }

            }

        else 

            {

            DLINFO(("No descriptor for JAD install"));                        

            }

        // Ensure that mime is JAD

        fileInfo->SetMimeTypeL( KMimeTypeMatchJad );

        }

    CNcdInstallInfo* info = CNcdInstallInfo::NewL( fileInfo,

        installType );

    CleanupStack::Pop( fileInfo );

    CleanupStack::PushL( info );

    info->SetIndex( nextFile );    

    MCatalogsBaseMessage* message = &aMessage;

    // Send the info back

    TInt err = CompleteMessage( 

        message, 

        ENCDOperationMessageCompletionComplete,

        *info, 

        KErrNone );

    CleanupStack::PopAndDestroy( info );

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

    }

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

// Completes the message correctly when all files have already been installed

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

//        

void CNcdInstallOperation::HandleAllFilesInstalledL( 

    TInt aFinalIndex, MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    CNcdInstallInfo* info = CNcdInstallInfo::NewL( NULL,

        CNcdInstallInfo::ENcdInstallNormal );            

    CleanupStack::PushL( info );

    info->SetIndex( aFinalIndex );    

    MCatalogsBaseMessage* message = &aMessage;

    // Send the info back

    TInt err = CompleteMessage( 

        message, 

        ENCDOperationMessageCompletionComplete,

        *info, 

        KErrNone );

    CleanupStack::PopAndDestroy( info );

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

    }