/*

* Copyright (c) 2009-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:   ?Description

*

*/

#include "iaupdateutils.h"

#include "iaupdateversion.h"

#include "iaupdatenode.h"

#include "iaupdatebasenode.h"

#include "iaupdatebasenodeimpl.h"

#include "iaupdatefwversionfilehandler.h"

#include "iaupdateprotocolconsts.h"

#include "iaupdatedebug.h"

#include <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <swi/sisregistrypackage.h>

#include <sysutil.h>

#include <sysversioninfo.h> 

#include <ncdnode.h>

#include <ncdnodepurchase.h>

#include <ncdnodecontentinfo.h>

#include <ncdpurchaseoption.h>

#include <catalogsutils.h>

//Constants

const TText KVersionSeparator( '.' );

_LIT( KExe, ".exe" );

_LIT( KDll, ".dll" );

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

// IAUpdateUtils::DesHexToIntL

// 

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

//  

EXPORT_C TInt IAUpdateUtils::DesHexToIntL( const TDesC& aDes )

    {

    TLex lex( aDes );

    TInt position = aDes.LocateF( 'x' );

    if ( position != KErrNotFound ) 

        {

        // Hex format is of type '0xABC' or 'xABC'

        // Skip over the x-part.

        lex.Assign( aDes.Mid( position+1 ) );

        }

    TUint value;

    User::LeaveIfError( lex.Val( value, EHex ) );

    return value;

    }    

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

// IAUpdateUtils::DesHexToIntL

// 

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

//  

EXPORT_C void IAUpdateUtils::DesToVersionL( 

    const TDesC& aVersion, 

    TInt8& aMajor, TInt8& aMinor, TInt16& aBuild )

    {

    // Initialize temporary variables with the original values.

        // These will be replaced with new ones if values are found from the string.

    TInt8 major( aMajor );

    TInt8 minor( aMinor );

    TInt16 build( aBuild );

    if ( aVersion != KNullDesC )

        // because version may be omitted (service back nodes), empty strings are skipped  

        {

        TBool majorSet( EFalse );

        TBool minorSet( EFalse );

        TBool buildSet( EFalse );

        TLex lex( aVersion );

        lex.Mark();

        for( ;; )

            {

            if( lex.Eos() || lex.Peek() == KVersionSeparator )

                {

                TInt value( 0 );

                TPtrC data( lex.MarkedToken() );

                TLex num;

                num.Assign( data );

                User::LeaveIfError( num.Val( value ) );

                if( !majorSet )

                    {

                    major = value;

                    majorSet = ETrue;

                    }

                else if( !minorSet )

                    {

                    minor = value;

                    minorSet = ETrue;

                    }

                else if( !buildSet )

                    {

                    build = value;

                    buildSet = ETrue;

                    // all values received now, exit loop.

                    break;

                    }

                if( lex.Eos() )

                    {

                    break;

                    }

                else

                    {

                    lex.SkipAndMark( 1 );

                    }

                }

            else 

                {

                lex.Inc();

                }

            }

        }

    // Now replace original values with the parsed temporary values.

    aMajor = major;

    aMinor = minor;

    aBuild = build;

    }

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

// IAUpdateUtils::AppPackageUidL

// 

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

//  

EXPORT_C TUid IAUpdateUtils::AppPackageUidL( const TUid& aUid )

    {

    // This is not actually neede here. But, create it so we can use

    // other version of the AppPackageUidL

    TIAUpdateVersion version;

    TUid appUid = AppPackageUidL( aUid, version );    

    return appUid;

    }

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

// IAUpdateUtils::AppPackageUidL

// 

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

//  

EXPORT_C TUid IAUpdateUtils::AppPackageUidL( 

    const TUid& aUid, TIAUpdateVersion &aVersion )

    {

    TUid packageUid( TUid::Null() );

    Swi::RSisRegistrySession registrySession;

    Swi::RSisRegistryEntry entry;

    Swi::CSisRegistryPackage* sisRegistryPackage = NULL;

    TInt err = KErrNone;

    TBool entryFound = EFalse;

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

    CleanupClosePushL( registrySession );

    TRAP( err, sisRegistryPackage = registrySession.SidToPackageL( aUid ) );

    if ( err == KErrNone )

        {

        CleanupStack::PushL( sisRegistryPackage );

        if ( entry.OpenL( registrySession, *sisRegistryPackage ) == KErrNone )

            {

            entryFound = ETrue;

            // The sid was found from this package

            packageUid = sisRegistryPackage->Uid();

            }

        }

    else if ( entry.Open( registrySession, aUid ) == KErrNone )

        {

        entryFound = ETrue;

        // The given uid was already the package UID

        packageUid = aUid;

        }

    if ( entryFound )

        {

        CleanupClosePushL( entry );        

        if ( entry.IsPresentL() )

            {

            aVersion = entry.VersionL();

            RPointerArray< Swi::CSisRegistryPackage > augs;

            CleanupResetAndDestroyPushL( augs );

            entry.AugmentationsL( augs );

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

                {

                Swi::RSisRegistryEntry augEntry;

                TIAUpdateVersion augVersion;

                if ( augEntry.OpenL( registrySession, *augs[i] ) == KErrNone )

                    {

                    CleanupClosePushL( augEntry );

                    if ( augEntry.IsPresentL() )

                        {

                        augVersion = augEntry.VersionL();

                        if( augVersion > aVersion )

                            {

                            aVersion = augEntry.VersionL();

                            }

                        }

                    CleanupStack::PopAndDestroy( &augEntry );

                    }

                }

            CleanupStack::PopAndDestroy( &augs );

            }

        else

            {

            entryFound = EFalse;

            packageUid = TUid::Null();            

            }

        CleanupStack::PopAndDestroy( &entry );

        }

    if ( sisRegistryPackage )

        {

        CleanupStack::PopAndDestroy( sisRegistryPackage );

        }

    CleanupStack::PopAndDestroy( &registrySession );

    return packageUid;

    }

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

// IAUpdateUtils::IsAppInstalledL

// 

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

//  

EXPORT_C TBool IAUpdateUtils::IsAppInstalledL( const TUid& aUid )

    {

    // This is not actually neede here. But, create it so we can use

    // other version of the IsAppInstalledL

    TIAUpdateVersion version;

    TBool isInstalled( IsAppInstalledL( aUid, version ) );

    return isInstalled;

    }

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

// IAUpdateUtils::IsAppInstalledL

// 

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

//  

EXPORT_C TBool IAUpdateUtils::IsAppInstalledL( 

    const TUid& aUid, TIAUpdateVersion &aVersion )

    {

    if ( AppPackageUidL( aUid, aVersion ) != TUid::Null() )

        {

        return ETrue;

        }

    else 

        {

        return EFalse;

        }

    }

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

// IAUpdateUtils::IsWidgetInstalledL

// Check existance of widget and request the version info if the widget has been installed

// The Widget registry API is used here.

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

EXPORT_C TBool IAUpdateUtils::IsWidgetInstalledL(const TDesC& aIdentifier, TIAUpdateVersion& aVersion )

    {

    RWidgetRegistryClientSession widgetRegistry;

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

    CleanupClosePushL( widgetRegistry );

    RPointerArray<CWidgetInfo> widgetInfoArr;

    CleanupResetAndDestroyPushL( widgetInfoArr );

    TInt err = widgetRegistry.InstalledWidgetsL(widgetInfoArr); 

    for( TInt i( widgetInfoArr.Count() - 1 ); i >= 0; --i ) 

        {

        CWidgetInfo* widgetInfo( widgetInfoArr[i] );  

        CWidgetPropertyValue* BundleId = widgetRegistry.GetWidgetPropertyValueL(widgetInfo->iUid, EBundleIdentifier );

        CleanupStack::PushL( BundleId );

        if( aIdentifier.Compare( *(BundleId->iValue.s) )== 0 )

            {

            CWidgetPropertyValue* version = widgetRegistry.GetWidgetPropertyValueL(widgetInfo->iUid, EBundleVersion );

            CleanupStack::PushL( version );

            DesToVersionL(*(version->iValue.s), aVersion.iMajor, aVersion.iMinor, aVersion.iBuild );

            CleanupStack::PopAndDestroy( version );

            CleanupStack::PopAndDestroy( BundleId );

            CleanupStack::PopAndDestroy( &widgetInfoArr );

            CleanupStack::PopAndDestroy( &widgetRegistry);

            return ETrue;

            }

        CleanupStack::PopAndDestroy( BundleId );

        }

    CleanupStack::PopAndDestroy( &widgetInfoArr );

    CleanupStack::PopAndDestroy( &widgetRegistry);

    return EFalse;

    }

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

// IAUpdateUtils::SpaceAvailableInInternalDrivesL

// 

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

//  

EXPORT_C TBool IAUpdateUtils::SpaceAvailableInInternalDrivesL( 

    RPointerArray<MIAUpdateNode>& aNodes )

    {

    TBool enoughSpaceFound = ETrue; 

    // packages are cached in C drive. Needed cache size is a size of the biggest package

    TInt sizeOfBiggest = 0;

    TInt i = 0;

    RFs fs;

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

    CleanupClosePushL( fs );  

    for ( i = 0; i < aNodes.Count(); ++i )

        {

        MIAUpdateNode* node( aNodes[ i ] );

        MIAUpdateBaseNode& baseNode( node->Base() );

        if ( baseNode.ContentSizeL() > sizeOfBiggest )

            {

            sizeOfBiggest = baseNode.ContentSizeL();

            }

        }

    TInt64 freeOnC = FreeDiskSpace( fs, EDriveC );

    TInt64 freeOnE = FreeDiskSpace( fs, EDriveE );

	TDriveUnit driveUnit( EDriveC );

	if ( freeOnE > freeOnC )

	    {

	    driveUnit = EDriveE;

	    }

	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &fs, sizeOfBiggest, driveUnit ) ) 

	    { // no space even for package caching

		enoughSpaceFound = EFalse;

	    }

/*	else

	    {

        TInt sizeNeededInDrive = sizeOfBiggest + KSpaceMarginal; //size of the biggest package is included in C drive

        for ( i = 0; i < aNodes.Count() && enoughSpaceFound; ++i )

            {

            TDriveUnit installedDrive;

            MIAUpdateNode* node( aNodes[ i ] );

            MIAUpdateBaseNode& baseNode( node->Base() );

            if ( !IAUpdateUtils::InstalledDriveL( fs, baseNode.Uid(), installedDrive ) )

                { //let's assume that already installed package does not need extra space

        	    sizeNeededInDrive += ( baseNode.ContentSizeL() * KSizeMultiplier );       

                if ( SysUtil::DiskSpaceBelowCriticalLevelL( &fs, sizeNeededInDrive, driveUnit ) )

                    { // not enough space in a drive, try the next internal drive 

                    enoughSpaceFound = EFalse;

                    //

                    // other drives than C are not scanned...installation is always to C.                     //

                    //

                    //TBool nextInternalDrive = ETrue;

                    //while ( nextInternalDrive )

                    //    {

            	    //    if ( NextInternalDriveL( fs, driveUnit, driveUnit ) )

            	    //        {

            	    //        sizeNeededInDrive = KSpaceMarginal + 

            	    //               ( baseNode.ContentSizeL() * KSizeMultiplier );

            		//        if ( !SysUtil::DiskSpaceBelowCriticalLevelL( &fs, 

            		//                                                     sizeNeededInDrive, 

            		//                                                     driveUnit ) )

            		//            { 

            		//	        nextInternalDrive = EFalse;

            		//            }

             	    //        }

             	    //    else

             	    //        { //all internal drives scanned, just give up now

             	    //        nextInternalDrive = EFalse;

             	    //        enoughSpaceFound = EFalse;	

             	    //        }    

                    //    }

                    }

        	    }

            }

        }*/

    CleanupStack::PopAndDestroy( &fs );

    return enoughSpaceFound;

    }

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

// IAUpdateUtils::IsInstalledL

// 

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

// 

EXPORT_C TBool IAUpdateUtils::IsInstalledL( 

    const TUid& aPUid, const TDesC& aExecutable )

    {

    Swi::RSisRegistrySession registrySession;

    Swi::RSisRegistryEntry entry;

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

    CleanupClosePushL( registrySession );

    TInt exeFound = EFalse;

    if ( entry.Open( registrySession, aPUid ) == KErrNone )

        {

        CleanupClosePushL( entry );

    	RPointerArray<HBufC> files; 

        entry.FilesL( files );

    	for( TInt i = 0; !exeFound && i < files.Count(); i++)

    	    {

    	    TFileName fullName = *files[i];	

            TParse parse;

            parse.Set( fullName, NULL, NULL);    

            if ( parse.NameAndExt().CompareF( aExecutable ) == 0 )

    		    {

    			exeFound = ETrue;

    		    }

    	    }

    	files.ResetAndDestroy();    

        CleanupStack::PopAndDestroy( &entry );

        }

    CleanupStack::PopAndDestroy( &registrySession );

    return exeFound;

    }

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

// 

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

    {