/*

* 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:   Implements CNcdNodeInstall class

*

*/

#include "ncdnodeinstallimpl.h"

#include <f32file.h>

#include <s32mem.h>

#include <bautils.h>

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "catalogsconstants.h"

#include "ncd_pp_dataentity.h"

#include "ncd_cp_query.h"

#include "catalogsutils.h"

#include "ncdutils.h"

#include "ncdpurchaseinstallinfo.h"

#include "ncdpurchasedetails.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdinstallinfo.h"

#include "ncdfileinfo.h"

#include "ncdextendedinstallinfo.h"

#include "ncdproviderutils.h"

#include "ncdinstallationservice.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncdpanics.h"

#include "ncdpurchasehistoryutils.h"

#include "ncdproviderdefines.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncdnodemanager.h"

#include "ncdnodeidentifier.h"

#include "catalogsdebug.h"

// Maximum number of content file opening attempts if the first

// one fails with KErrInUse

const TInt KMaxRetries = 3;

// Delay between content file opening attempts if the first

// one fails with KErrInUse

const TInt KOpenDelay = 500000;

static TInt CallBackOpenFile( TAny* aObject )

    {

    DLTRACEIN((""));

    static_cast<CNcdNodeInstall*>( aObject )->OpenContentFileRunner();

    return KErrNone;

    }

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

// CNcdNodeInstall

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

//  

CNcdNodeInstall::CNcdNodeInstall( NcdNodeClassIds::TNcdNodeClassId aClassId,

    const CNcdNodeMetaData& aMetadata )

: CCatalogsCommunicable(),

  iClassId( aClassId ),

  iMetadata( aMetadata )

    {

    }

void CNcdNodeInstall::ConstructL()

    {

    DLTRACEIN((""));    

    iDownloadedFiles = new(ELeave) CDesCArrayFlat( KListGranularity );

    DLTRACEOUT((""));

    }

CNcdNodeInstall* CNcdNodeInstall::NewL( const CNcdNodeMetaData& aMetadata )

    {

    CNcdNodeInstall* self =   

        CNcdNodeInstall::NewLC( aMetadata );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdNodeInstall* CNcdNodeInstall::NewLC( const CNcdNodeMetaData& aMetadata )

    {

    CNcdNodeInstall* self = 

        new( ELeave ) CNcdNodeInstall( 

            NcdNodeClassIds::ENcdNodeInstallClassId, aMetadata );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;        

    }

CNcdNodeInstall::~CNcdNodeInstall()

    {

    DLTRACEIN((""));

    // Delete member variables here

    iInstallInfos.ResetAndDestroy();

    delete iDownloadedFiles;

    delete iInstalledContent;

    delete iPeriodic;

    DLTRACEOUT((""));

    }        

NcdNodeClassIds::TNcdNodeClassId CNcdNodeInstall::ClassId() const

    {

    return iClassId;

    }

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

// Set node data from purchase details

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

//  

TBool CNcdNodeInstall::InternalizeL( const MNcdPurchaseDetails& aDetails )

    {

    DLTRACEIN(("this-ptr: %X", this));

    if ( !aDetails.DownloadInfoL().Count() ) 

        {

        DLTRACEOUT(("No downloadinfos so there's nothing to install"));

        return EFalse;

        }

    DLTRACE(("Copying paths of downloaded files"));

    CDesCArray* tempDownloads = new(ELeave) CDesCArrayFlat( KListGranularity );

    CleanupStack::PushL( tempDownloads );

    TBool atLeastOneFile = EFalse;

    // Get names of downloaded files

    for ( TInt i = 0; i < aDetails.DownloadedFiles().MdcaCount(); ++i ) 

        {

        const TDesC& filepath( aDetails.DownloadedFiles().MdcaPoint( i ) );

        atLeastOneFile = atLeastOneFile || filepath.Length();

        // append even empty descriptors so that the arrays stay identical

        tempDownloads->AppendL( filepath );

        DLINFO(( _L("Downloaded: %S"), 

            &aDetails.DownloadedFiles().MdcaPoint( i ) ));

        }

    TArray<MNcdPurchaseInstallInfo*> info ( aDetails.InstallInfoL() );

    // Check download status

    if ( !atLeastOneFile && !info.Count() ) 

        {

        CleanupStack::PopAndDestroy( tempDownloads );

        DLINFO(("Nothing has been downloaded or installed"));

        return EFalse;

        }

    TArray<MNcdPurchaseDownloadInfo*> dlInfo ( aDetails.DownloadInfoL() );               

    DLTRACE(("Internalizing install infos, count: %d", info.Count() ));

    RPointerArray<CNcdExtendedInstallInfo> tempInfos;

    CleanupResetAndDestroyPushL( tempInfos );

    tempInfos.ReserveL( info.Count() );

    iLaunchable = EFalse;        

    CNcdExtendedInstallInfo* tempInstall = NULL;

    TBool launchable = EFalse;

    TBool atLeastOneLauncher = EFalse;

    TBool atLeastOneLaunchableLauncher = EFalse;

    TBool atLeastOneLauncherOpen = EFalse;

    // If there are more install infos than download infos we assume that

    // the first install infos are for rights files

    TInt dlIndex = dlInfo.Count() - info.Count();

    if ( dlIndex > 0 ) 

        {

        dlIndex = 0;

        }

    // Internalize infos

    for ( TInt i = 0; i < info.Count(); ++i, ++dlIndex )

        {

        const MNcdPurchaseInstallInfo& install( *info[i] );

        if ( dlIndex >= 0 ) 

            {            

            const MNcdPurchaseDownloadInfo& download( *dlInfo[dlIndex] );

            launchable = download.IsLaunchable();

            DLTRACE(("Launchable from purchase history: %d", launchable ));

            TBool isLauncher = IsOneOf( download.ContentUsage(), 

                       MNcdPurchaseDownloadInfo::ELauncher,

                       MNcdPurchaseDownloadInfo::ELauncherOpen );

            // Themes are not launchable. This also checks for reinstalled themes            

            if ( install.ThemeName() != KNullDesC || 

                 ( install.ThemeName() == KNullDesC &&

                   install.ApplicationUid() == TUid::Null() &&

                   install.Filename() == KNullDesC ) )

                {

                launchable = EFalse;

                }

            // check launcher apps

            else if ( isLauncher )

                {

                atLeastOneLauncher = ETrue;

                // Can't use IsContentInstalledL since it uses iInstallInfos-array

                // which is generated here

                if ( CNcdProviderUtils::IsApplicationInstalledL(

                        install.ApplicationUid(), 

                        install.ApplicationVersion() ) <= ENcdApplicationNotInstalled  )

                    {

                    DLTRACE(("Setting launchable=EFalse"));

                    launchable = EFalse;            

                    }

                else 

                    {

                    atLeastOneLaunchableLauncher = ETrue;

                    }

               }

            tempInstall = CNcdExtendedInstallInfo::NewLC( install,

                download.ContentMimeType(), launchable );

            tempInstall->SetUriExists( download.ContentUri().Length() != 0 );

            // Sets content type to tempInstall according to download's contentUsage

            SetContentType( *tempInstall, download );

            if ( download.ContentUsage() == 

                    MNcdPurchaseDownloadInfo::ELauncherOpen ) 

                {                

                atLeastOneLauncherOpen = ETrue;

                }

            // Set item as launchable if at least one file is launchable    

            if ( launchable ) 

                {

                iLaunchable = ETrue;

                }

            }

        else 

            {

            DLTRACE(("Rights file"));

            tempInstall = CNcdExtendedInstallInfo::NewLC( install,

                KNullDesC, ETrue );

            }        

        tempInfos.AppendL( tempInstall );

        CleanupStack::Pop( tempInstall );

        tempInstall = NULL;        

        DLTRACE(("Info added, iInstallInfo count: %d", iInstallInfos.Count() ));

        }

    if ( atLeastOneLauncher && !atLeastOneLaunchableLauncher )

        {

        DLTRACE(("No launchable launchers, setting everything unlaunchable"));

        iLaunchable = EFalse;

        TInt count = tempInfos.Count();

        while ( count-- ) 

            {

            tempInfos[ count ]->SetLaunchable( EFalse );

            }

        }

    // There was at least one launcher/open dependency so we need to go through

    // the install infos and try to find a suitable file for opening

    if ( atLeastOneLauncherOpen && 

         tempInfos.Count() <= dlInfo.Count() ) 

        {

        DLTRACE(("Setting launcher param"));

        TInt count = tempInfos.Count();

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

            {

            const MNcdPurchaseDownloadInfo& download( *dlInfo[ i ] );

            if ( download.ContentUsage() == MNcdPurchaseDownloadInfo::ELauncherOpen ) 

                {

                SetLaunchParameterL( tempInfos, i );

                }            

            }

        }

    DLTRACE(("Replacing old values with new ones"));

    // Read installed status

    iInstalled = ( aDetails.State() == MNcdPurchaseDetails::EStateInstalled );

    DLINFO(( "Installed: %d", iInstalled ));

    // Get purpose

    iPurpose = aDetails.ItemPurpose();

    DLINFO(( "Purpose: %d", iPurpose ));        

    // Replace old values

    iInstallInfos.ResetAndDestroy();    

    iInstallInfos = tempInfos;

    CleanupStack::Pop( &tempInfos );

    delete iDownloadedFiles;

    iDownloadedFiles = tempDownloads;

    CleanupStack::Pop( tempDownloads );

    TInt depCount = DependencyCount( dlInfo );

    if ( !iInstalled && 

         depCount &&

         // must be more download infos than just deps

         dlInfo.Count() > depCount &&

         // install info count must be at least the amount of dlInfos 

         // since deps have equal number of install and dl infos and

         // all content must have been installed before

         info.Count() >= dlInfo.Count() )

        {

        iInstalled = ETrue;

        DLTRACE(("Dependency has already been installed, setting iInstalled to ETrue"));

        }

    if ( iInstalledContent ) 

        {

        DASSERT( iInstalledContent->ApplicationUid() != TUid::Null() );

        // Disable launching if protocol says so. 

        // By default apps defined in content info are launchable

        iInstalledContent->SetLaunchable( iLaunchable );

        // Delete iInstalledContent if it is duplicated in purchase history

        for ( TInt i = 0; i < iInstallInfos.Count(); ++i ) 

            {

            if ( iInstalledContent->ApplicationUid() == 

                 iInstallInfos[i]->ApplicationUid() )

                {

                DLTRACE(("App has been bought and installed"));

                delete iInstalledContent;

                iInstalledContent = NULL;

                break;

                }

            }        

        }

    SetContentVersionL( aDetails.Version() );

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

    return ETrue;

    }

void CNcdNodeInstall::ReceiveMessage( MCatalogsBaseMessage* aMessage,

                                      TInt aFunctionNumber )

    {

    DLTRACEIN(("this-ptr: %X", this));    

    DASSERT( aMessage );

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

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

    iMessage = aMessage;

    TInt trapError( KErrNone );

    // Check which function is called by the proxy side object.

    // Function number are located in ncdnodefunctinoids.h file.

    switch( aFunctionNumber )

        {

        case NcdNodeFunctionIds::ENcdInternalize:

            // Internalize the proxy side according to the data

            // of this object.

            TRAP( trapError, InternalizeRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdRelease:

            // The proxy does not want to use this object anymore.

            // So, release the handle from the session.

            ReleaseRequest( *aMessage );

            break;

        case NcdNodeFunctionIds::ENcdInstallOpenFile:

            TRAP( trapError, OpenContentFileL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdSetApplicationInstalled:

            TRAP( trapError, SetApplicationInstalledRequestL( *aMessage ) );

            break;

        default:

            DLERROR(("Unidentified function request"));

            DASSERT( EFalse );

            break;

        }

    if ( trapError != KErrNone )

        {

        // Because something went wrong, the complete has not been

        // yet called for the message.

        // So, inform the client about the error if the

        // message is still available.

        aMessage->CompleteAndRelease( trapError );

        }

    // 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.

    if ( !iPeriodic ) 

        {        

        iMessage = NULL;        

        }

    DLTRACEOUT((""));

    }

void CNcdNodeInstall::CounterPartLost( const MCatalogsSession& aSession )

    {

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

        }

    }

const MDesCArray& CNcdNodeInstall::DownloadedFiles() const

    {

    DASSERT( iDownloadedFiles );

    return *iDownloadedFiles;

    }

TNcdApplicationStatus CNcdNodeInstall::IsContentInstalledL( 

    TInt aIndex,

    TBool aIgnoreMissingUri )

    {

    DLTRACEIN(("aIndex: %d", aIndex));

    DASSERT( aIndex >= 0 );

    if ( aIndex >= ContentCount() ) 

        {

        DLTRACEOUT(("Index out of range (count = %d), returning EFalse", 

            ContentCount() ));

        return ENcdApplicationNotInstalled;

        }

    CNcdExtendedInstallInfo& info = *iInstallInfos[aIndex];

    TNcdApplicationStatus status = ENcdApplicationNotInstalled;

    if ( info.Filename() != KNullDesC ) 

        {

        DLTRACE(("Content: file"));

        if ( BaflUtils::FileExists( 

                CNcdProviderUtils::FileSession(),

                info.Filename() ) ) 

            {

            DLTRACE(( _L("File %S exists"), &info.Filename() ));

            status = ENcdApplicationInstalled;

            }

        }

    else if ( info.ApplicationUid() != TUid::Null() )

        {

        DLTRACE(("Content: application"));

        if ( aIgnoreMissingUri && !info.UriExists() ) 

            {

            DLTRACE(("No uri and ignoring missing uris"));

            status = ENcdApplicationInstalled;

            }

        else 

            {            

            status = CNcdProviderUtils::IsApplicationInstalledL(

                info.ApplicationUid(), 

                info.ApplicationVersion() );            

            }

        }

    else if ( info.ThemeName() != KNullDesC )

        {

        DLTRACE(("Content: theme"));

        if ( CNcdProviderUtils::InstallationServiceL().IsThemeInstalledL(

            info.ThemeName() ) )

            {

            status = ENcdApplicationInstalled;

            }

        }

    info.SetInstalledStatus( status );

    return status;

    }

TInt CNcdNodeInstall::ContentCount() const

    {

    return iInstallInfos.Count();

    }

TBool CNcdNodeInstall::IsAllContentInstalledL()

    {