* Copyright (c) 2008 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 <xml/dom/xmlengnodelist.h>

#include <xml/dom/xmlengdomparser.h>

#include <xml/dom/xmlengdocument.h>

#include <xml/dom/xmlengelement.h>

#include <e32base.h>

//

CCaWidgetScannerParser::CCaWidgetScannerParser( RFs& aFs ) :

// 

void CCaWidgetScannerParser::ConstructL()

// 

// 

    CCaWidgetScannerParser* self = new ( ELeave ) CCaWidgetScannerParser( aFs );

    self->ConstructL();

// 

RWidgetArray& CCaWidgetScannerParser::WidgetsScanL(

        const RWidgetArray& aWidgets )

    TChar currentDriveLetter;

    iFetchedWidgets = aWidgets;

    for ( TInt driveNumber = EDriveZ; driveNumber >= EDriveA; driveNumber-- )

                    currentDriveLetter ) );

            ScanOnDriveL( currentDriveLetter );

void CCaWidgetScannerParser::ScanOnDriveL( TChar& aDrive )

    CDir* directories = GetDirectoriesLC( aDrive );

        for ( TInt i( 0 ); i < directories->Count(); i++ )

            if ( ( *directories )[i].IsDir() )

                ParseDirectoryL( ( *directories )[i].iName, aDrive );

void CCaWidgetScannerParser::ParseDirectoryL( const TDesC& aDirectoryName,

        TChar& aDrive )

    HBufC* manifestDirectoryPath = GetManifestDirectoryPathLC( aDirectoryName,

            aDrive );

            KEntryAttMatchExclude | KEntryAttDir, ESortByDate, fileList ) );

    for ( TInt i = 0; i < fileList->Count(); i++ )

        if ( ( *fileList )[i].iName.Find( KManifest ) != KErrNotFound )

            fullFilePath.CreateL( manifestDirectoryPath->Length()

                    + ( *fileList )[i].iName.Length() );

            fullFilePath.Append( ( *fileList )[i].iName );

            TPtrC packageUidPtr = manifestDirectoryPath->Mid(

                    manifestDirectoryPath->Length() - KPackageUidPosition,

                    KPackageUidLength); 

            TUint packageUid;            

            TLex lexer( packageUidPtr );

            User::LeaveIfError( lexer.Val( packageUid, EHex ) );

            CCaWidgetDescription* compareWidget = NULL;

            for ( TInt j = 0; j < iFetchedWidgets.Count(); j++ )

                {

                if ( iFetchedWidgets[j]->GetPackageUidL() ==  packageUid )

                    {

                    compareWidget = iFetchedWidgets[j];

                    compareWidget->SetValid( ETrue ); //do not remove from db

                    break; // once found we dont iterate anymore

                    }

                }

            if ( compareWidget )

                {

                TTime modificationTime = ( *fileList )[i].iModified;

                TInt64 modificationIntTime = modificationTime.Int64();

                TLex lex( compareWidget->GetModificationTime() );

                TInt64 uintTimeDB( 0 );

                User::LeaveIfError( lex.Val( uintTimeDB ) );

                if ( uintTimeDB != modificationIntTime )

                    {

                    TRAP_IGNORE( ParseManifestFileL( fullFilePath,

                                    aDirectoryName, aDrive ) );

                    }

                }

            else

                {

                TRAP_IGNORE( ParseManifestFileL( fullFilePath, aDirectoryName,

                                aDrive ) );

                }

void CCaWidgetScannerParser::ParseManifestFileL( const TDesC& aFilePath,

        const TDesC& aPackageUid, TChar& aDrive )

    CleanupClosePushL( parser );

    User::LeaveIfError( parser.Open( iDomImpl ) );

    RXmlEngDocument doc = parser.ParseFileL( aFilePath, KChunkSize );

    CleanupClosePushL( doc );

    if ( docElement.Name() == KWidgetProvider )

        {

        CleanupClosePushL( elementList );

        docElement.GetElementsByTagNameL( elementList, KWidget );

        while ( elementList.HasNext() )

                ParseWidgetL( aFilePath, element, aPackageUid, aDrive );

        CleanupStack::PopAndDestroy( &elementList );

        }

    else if ( docElement.Name() == KWidgetManifest )

        {

        CCaWidgetDescription* widgetDescriptor = CCaWidgetDescription::NewL();

        widgetDescriptor->SetPackageUidL( aPackageUid );

        widgetDescriptor->SetFlag( EVisible, ETrue );

        widgetDescriptor->SetManifestFilePathNameL( aFilePath );

        SetMmcIdL( widgetDescriptor, aDrive );

        CleanupClosePushL( childElementList );

        docElement.GetChildElements( childElementList );

        while ( childElementList.HasNext() )

            {

            element = childElementList.Next();

            if ( element.Name() == KUri )

                {

                ParseUriL( element, widgetDescriptor );

                }

            else if ( element.Name() == KTitle )

                {

                ParseTitleL( element, widgetDescriptor );

                }

            else if ( element.Name() == KIcon )

                {

                ParseIconL( element, aPackageUid, widgetDescriptor, aDrive );

                }

            else if ( element.Name() == KDescription )

                {

                ParseDescriptionL( element, widgetDescriptor );

                }

            else if ( element.Name() == KHidden )

                {

                ParseHiddenL( element, widgetDescriptor );

                }

            else if ( element.Name() == KServiceXml )

                {

                ParseServiceXmlL( element, widgetDescriptor );

                }

            else if ( element.Name() == KPreviewImageElementName )

                {

                ParsePreviewImageNameL( element, aPackageUid, widgetDescriptor, aDrive );

                }

            }

        CleanupStack::PopAndDestroy( &childElementList );

        HBufC *libraryPath2 = GetManifestDirectoryPathLC( aPackageUid, aDrive );

        libraryPath2 = libraryPath2->ReAllocL( libraryPath2->Length()

                + widgetDescriptor->GetUri().Length() );

        libraryPath2->Des().Append( widgetDescriptor->GetUri() );

        widgetDescriptor->SetLibraryL( *libraryPath2 );

        CleanupStack::PopAndDestroy( libraryPath2 );

        SetModificationTimeL( aFilePath, widgetDescriptor );

        TInt index = iWidgets.Find( widgetDescriptor,

                CCaWidgetDescription::Compare );

        iWidgets.AppendL( widgetDescriptor );//ownership transfer

        widgetDescriptor = NULL;

        }

    CleanupStack::PopAndDestroy( &doc );

    CleanupStack::PopAndDestroy( &parser );

void CCaWidgetScannerParser::ParseWidgetL( const TDesC& aFilePath,

        TXmlEngElement& aElement, const TDesC& aPackageUid, TChar& aDrive )

    SetLibraryL( aElement, aPackageUid, widget, aDrive );

    SetIconUriL( aElement, aPackageUid, widget, aDrive );

    SetMmcIdL( widget, aDrive );

    SetModificationTimeL( aFilePath, widget );

void CCaWidgetScannerParser::SetUriL( TXmlEngElement& aElement,

        CCaWidgetDescription* aWidget )

    {

            aElement.AttributeValueL( KUri ) );

    if ( attributeValue->Compare( KNullDesC ) != 0 )

    }

//   

void CCaWidgetScannerParser::SetLibraryL( TXmlEngElement& aElement,

        const TDesC& aPackageUid, CCaWidgetDescription* aWidget, TChar& aDrive )

    {

            aElement.AttributeValueL( KLibrary ) );

    if ( attributeValue->Compare( KNullDesC ) != 0 )

        HBufC *libraryPath = GetManifestDirectoryPathLC( aPackageUid, aDrive );

        libraryPath->ReAllocL( libraryPath->Length() + attributeValue->Length() );

    }

void CCaWidgetScannerParser::SetTitleL( TXmlEngElement& aElement,

        CCaWidgetDescription* aWidget )

    {

            aElement.AttributeValueL( KTitle ) );

    if ( attributeValue->Compare( KNullDesC ) != 0 )

    }

void CCaWidgetScannerParser::SetDescriptionL( TXmlEngElement& aElement,

        CCaWidgetDescription* aWidget )

    {

            aElement.AttributeValueL( KDescription ) );

    if ( attributeValue->Compare( KNullDesC ) != 0 )

    }

void CCaWidgetScannerParser::SetVisibilityL( TXmlEngElement& aElement,

        CCaWidgetDescription* aWidget )

    {

            aElement.AttributeValueL( KHidden ) );

    if ( hidden->Compare( KTrue ) == 0 )

        aWidget->SetFlag( EVisible, EFalse );

        aWidget->SetFlag( EVisible, ETrue );

    }

void CCaWidgetScannerParser::SetIconUriL( TXmlEngElement& aElement,

        const TDesC& aPackageUid, CCaWidgetDescription* aWidget, TChar& aDrive )

    {

            aElement.AttributeValueL( KIconUri ) );

    if ( attributeValue->Compare( KNullDesC ) != 0 )

        HBufC* iconUriPath = GetManifestDirectoryPathLC( aPackageUid, aDrive );

        iconUriPath->ReAllocL( iconUriPath->Length() + attributeValue->Length() );

    }

void CCaWidgetScannerParser::SetMmcIdL( CCaWidgetDescription* aWidget,

        TChar& aDrive )

    {

            DriveInfo::EDefaultRemovableMassStorage, removableDrive ) );

            DriveInfo::EDefaultMassStorage, massStorageDrive ) );

    if ( aDrive == removableDrive )

        mmcId.CreateL( KMassStorageIdLength );

        aWidget->SetMmcIdL( mmcId );

    else if ( aDrive == massStorageDrive )

        aWidget->SetMmcIdL( KCaMassStorage );