/*

* Copyright (c) 2006, 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Manages list of widget entries.

*

*/

#include <e32base.h>

#include <f32file.h>

#include <s32file.h>

#include <s32mem.h>

#include <bautils.h>

#include "WidgetEntry.h"

#include "WidgetRegistry.h"

#include "WidgetInstaller.h"

#include <libxml2_globals.h>

#include <libc/stdlib.h>

#include <libxml2_parser.h>

#include <libxml2_tree.h>

#include "WidgetMMCHandler.h"

#include <xmlengxestd.h>

#include "UidAllocator.h"

#if defined( BRDO_WRT_SECURITY_MGR_FF )

#include <RTSecManager.h>

#endif

#include <e32property.h>

// CONSTANTS

static const TInt KDefaultWidgetCount = 20; // used for initial RArray size

static const TInt KAppArchTimeout = 10000000; // 10 seconds in microseconds

static const TInt KAppArchDelayInterval = 500000; // 500 milliseonds in microseconds

enum

    {

    EAppListFlagEntry = 1

    };

enum

    {

    EInstallListFlagEntry = 1

    };

// Be sure that length of literal pathname strings is less than

// KWidgetRegistryMaxPathName in header file.

//

// drive letter a: is used as a placeholder, it will be set as needed

_LIT( KWidgetInstallPath,

      "a:\\private\\10282822\\" );

_LIT( KWidgetEntryStoreBinaryFile,

      "a:\\private\\10282f06\\WidgetEntryStore.dat" );

_LIT( KWidgetEntryStoreXmlFile,

      "a:\\private\\10282f06\\WidgetEntryStore.xml" );

_LIT( KCWRTWidgetEntryStoreXmlFile,

      "c:\\private\\10282f06\\CWRTWidgetEntryStore.xml" );

_LIT( KWidgetEntryStoreXmlTempFile,

      "a:\\private\\10282f06\\WidgetEntryStoreTemp.xml" );

_LIT( KWidgetDirFile, "widget_lproj.xml" );

_LIT( KWidgetAccessPolicy, "WidgetAccessPolicy.xml" );

_LIT( KWidgetPolicyIdFile, "WidgetPolicyId.dat" );

_LIT( KWidgetDefaultLangDir, "en" );

_LIT8( KLangID, "LangID" );

_LIT8( KLangDir, "LangDir" );

// for exteranlize

_LIT( KXmlHeader,

      "<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"yes\" ?>" );

_LIT( KXmlRootStart, "<widgetregistry>" );

_LIT( KXmlRootEnd, "</widgetregistry>" );

_LIT( KWidgetEntryStart, "<entry>" );

_LIT( KWidgetEntryEnd, "</entry>" );

_LIT( KXmlNewline, "\x0D\x0A" ); // DOS/Symbian style works with XML parsers

// for internalize

_LIT8( KWidgetRegistry, "widgetregistry" );

_LIT8( KEntry, "entry" );

LOG_NAMES( "widreg", "widreg.txt" )

void XmlDocFree( TAny* aPtr )

    {

    __ASSERT_DEBUG( aPtr, User::Invariant() );

    xmlDocPtr ptr( (xmlDocPtr)(aPtr) );

    xmlFreeDoc( ptr );

    }

// ============================================================================

// Traverse to the next Node

//

// @param aNode: current node

// @since 3.1

// @return next node

// ============================================================================

//

xmlNode* TraverseNextNode( xmlNode* n )

    {

    // depth first

    if ( n->children )

        {

        n = n->children;

        }

    else

        {

        // go up while no sibling

        while ( n->parent && !n->next )

            {

            n = n->parent;

            }

        // sibling?

        if ( n->next )

            {

            n = n->next;

            }

        else // done

            {

            n = NULL;

            }

        }

    return n;

    }

// ============================================================================

// Changes the Publish & Subscribe key value

// ============================================================================

//

void CWidgetRegistry::NotifyWidgetAltered()

    {

    const TUid KMyPropertyCat = { 0x10282E5A };

    enum TMyPropertyKeys { EMyPropertyAltered = 110 };

    TInt altered( 1 );

    RProperty::Set( KMyPropertyCat, EMyPropertyAltered , altered );

    }

// ============================================================================

// CWidgetRegistry::NewL()

// two-phase constructor

//

// @since 3.1

// ============================================================================

//

CWidgetRegistry* CWidgetRegistry::NewL( RFs& aFs )

    {

    CWidgetRegistry* widgetRegistry = new ( ELeave ) CWidgetRegistry( aFs );

    CleanupStack::PushL( widgetRegistry );

    TRAP_IGNORE( widgetRegistry->ConstructL() );

    CleanupStack::Pop( widgetRegistry );

    return widgetRegistry;

    }

// ============================================================================

// CWidgetRegistry::CWidgetRegistry()

// C++ constructor

//

// @since 3.1

// ============================================================================

//

CWidgetRegistry::CWidgetRegistry( RFs& aFs ):

    iFs( aFs ),

    iWidgetInstallPath( KWidgetInstallPath ),

    iRegistryBinaryFileName( KWidgetEntryStoreBinaryFile ),

    iRegistryXmlFileName( KWidgetEntryStoreXmlFile ),

    iRegistryCWRTXmlFileName( KCWRTWidgetEntryStoreXmlFile ),

    iRegistryXmlTempFileName( KWidgetEntryStoreXmlTempFile ),

    iPolicyId( 0 )

    {

    }

// ============================================================================

// CWidgetRegistry::~CWidgetRegistry()

// destructor

//

// @since 3.1

// ============================================================================

//

CWidgetRegistry::~CWidgetRegistry()

    {

    iEntries.ResetAndDestroy();

    iOldEntries.ResetAndDestroy();

    iUsedUids.Close();

    // iFs not owned

    iAppArch.Close();

    delete iInstaller;

    iLangDirList.ResetAndDestroy();

    delete iMMCHandler;

    delete iXmlProcessor;

    iFs.Close();

    LOG_DESTRUCT;

    }

// ============================================================================

// CWidgetRegistry::ConstructL()

// Symbian second phase constructor

//

// @since 3.1

// ============================================================================

//

void CWidgetRegistry::ConstructL()

    {

    LOG_CONSTRUCTL;

    LOG_OPEN;

    LOG( "CWidgetRegistry::ConstructL internalize" );

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

    iFs.CreatePrivatePath( EDriveC );

    iFs.SetSessionToPrivate( EDriveC );

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

    iInstaller = CWidgetInstaller::NewL();

    // If internalizing leaves, then the registry will be out-of-sync

    // with the installed widgets and apparc.  But that's okay since

    // it should be detected and corrected once the resource limit

    // that caused the leave is removed.

    TBool dirtyFlag = EFalse;

    TInt parseError = KErrNone;

    iXmlProcessor = CWidgetRegistryXml::NewL();

    // For first attempt assume usual case that things are consistent

    // and the registry entry file can be parsed and used.

    TRAP_IGNORE( InternalizeL( EFalse, // aDoConsistency,

                               EFalse, // aIgnoreParseError

                               dirtyFlag,

                               parseError ) );

    if ( parseError )

        {

        // Special case where we need to do consistency because

        // the widget registry entry file is corrupt.

        TRAP_IGNORE( InternalizeL( ETrue, // aDoConsistency,

                                   ETrue, // aIgnoreParseError

                                   dirtyFlag,

                                   parseError ) );

        }

    if ( dirtyFlag )

        {

        // Basically same reason to ignore leaves here.

        TRAP_IGNORE( ExternalizeL() );

        }

    LOG( " ctor internalize done" );

#if defined( BRDO_WRT_SECURITY_MGR_FF )

    FetchSecurityPolicyIdL();

#endif

    LOG1( "ConstructL internalize done, registry count %d",

              iEntries.Count() );

    LOG_CLOSE;

    iMMCHandler = CWidgetMMCHandler::NewL( *this, iFs );

    iMMCHandler->Start();

    }

// ============================================================================

// CWidgetRegistry::FetchSecurityPolicyIdL()

// Get policyId from security manager

//

// @since 5.0

// ============================================================================

//

TInt CWidgetRegistry::FetchSecurityPolicyIdL()

    {

#if defined( BRDO_WRT_SECURITY_MGR_FF )

    if ( !iPolicyId )

        {

        if ( KErrNone == iFs.ShareProtected() )

            {

            TFileName secPolicyFileName;

            RFile secPolicyFile;

            iFs.PrivatePath( secPolicyFileName );

#ifdef __WINSCW__

            secPolicyFileName.Insert( 0, _L( "C:" ));

#else

            secPolicyFileName.Insert( 0, _L( "Z:" ));

#endif

            secPolicyFileName.Append( KWidgetAccessPolicy );

            if ( KErrNone == secPolicyFile.Open( iFs, secPolicyFileName, EFileShareAny ) )

                {

                CleanupClosePushL( secPolicyFile );

                CRTSecManager* secMgr = CRTSecManager::NewL();

                iPolicyId = secMgr->SetPolicy( secPolicyFile );

                CleanupStack::PopAndDestroy( &secPolicyFile );

                CleanupStack::PushL( secMgr );

                // read old policyId, unset old policy file; store new policyId

                RFile policyIdFile;

                TFileName policyIdFileName;

                iFs.PrivatePath( policyIdFileName );

                policyIdFileName.Insert( 0, _L( "C:" ));

                policyIdFileName.Append( KWidgetPolicyIdFile );

                TInt error = KErrNotFound;

                error = policyIdFile.Open( iFs, policyIdFileName, EFileShareAny );

                // policy Id file exists

                if ( error == KErrNone )

                    {

                    CleanupClosePushL( policyIdFile );

                    RFileReadStream readStream;

                    CleanupClosePushL( readStream );

                    readStream.Attach( policyIdFile );

                    TInt oldPolicyId = 0;

                    TRAP_IGNORE( oldPolicyId = readStream.ReadInt32L() );

                    // clean the old policy file

                    if ( oldPolicyId > 0 )

                        {

                        secMgr->UnSetPolicy( oldPolicyId );

                        }

                    CleanupStack::PopAndDestroy( &readStream );

                    }

                // create policy Id file

                else if ( error == KErrNotFound )

                    {

                    User::LeaveIfError( policyIdFile.Create( iFs, policyIdFileName, EFileShareAny ) );

                        CleanupClosePushL( policyIdFile );

                    }

                // we should have a good policyIdFile by now, store iPolicyId there

                    RFileWriteStream writeStream;

                    CleanupClosePushL( writeStream );

                    writeStream.Replace( iFs, policyIdFileName, EFileShareAny );

                    TRAP_IGNORE( writeStream.WriteInt32L( iPolicyId ) );

                CleanupStack::PopAndDestroy( 2, &policyIdFile );// writeStream, policyIdFile

                CleanupStack::PopAndDestroy( secMgr );

                }

            }

        }

#else

  iPolicyId = KErrNotSupported;

#endif    

    return iPolicyId;

    }

// ============================================================================

// CWidgetRegistry::GetWidgetEntryL()

// Get widget entry by UID or leave with KErrNotFound

//

// @since 3.1

// ============================================================================

//

CWidgetEntry& CWidgetRegistry::GetWidgetEntryL( const TUid& aUid ) const

    {

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

        {

        CWidgetEntry* entry = iEntries[i];

        if ( TUid::Uid( (*entry)[EUid] ) == aUid )

            {

            return *entry;

            }

        }

    User::Leave( KErrNotFound );

    return *iEntries[0];  // just for compiler

    }

// ============================================================================

// CWidgetRegistry::GetWidgetEntry()

// Get the widget entry

//

// @since 3.1

// ============================================================================

//

// TODO use leaving version GetWidgetEntryL everywhere and delete this version

TInt CWidgetRegistry::GetWidgetEntry(

    const TUid& aUid,

    CWidgetEntry*& aEntry) const

    {

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

        {

        CWidgetEntry* entry = iEntries[i];

        if ( TUid::Uid( (*entry)[EUid] ) == aUid )

            {

            aEntry = entry;

            return i;

            }

        }

    return -1;

    }

// ============================================================================

// CWidgetRegistry::GetWidgetOldEntry()

// Get the widget entry from iOldEntrys array

//

// @since 3.1

// ============================================================================

//

TInt CWidgetRegistry::GetWidgetOldEntry(

    const TUid& aUid,

    CWidgetEntry*& aEntry) const

    {

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

        {

        CWidgetEntry* entry = iOldEntries[i];

        if ( TUid::Uid( (*entry)[EUid] ) == aUid )

            {

            aEntry = entry;

            return i;

            }

        }

    return -1;

    }

// ============================================================================

// CWidgetRegistry::GetWidgetEntry()

// Get the widget entry

//

// @since 3.1

// ============================================================================

//

TInt CWidgetRegistry::GetWidgetEntry(

    const TDesC& aBundleId,

    CWidgetEntry*& aEntry) const

    {

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

        {

        CWidgetEntry* entry = iEntries[i];

        const TDesC& widgetBundleId = (*entry)[EBundleIdentifier];

        if ( widgetBundleId.CompareF( aBundleId ) == 0 )

            {

            aEntry = entry;

            return i;

            }

        }

    return -1;

    }

// ============================================================================

// CWidgetRegistry::GetWidgetEntry()

// Returns the WidgetEntry at a particular index

//

// @since 3.1

// ============================================================================

//

const CWidgetEntry* CWidgetRegistry::GetWidgetEntry( const TInt& aPos )

    {

    return iEntries[aPos];

    }

// ============================================================================

// CWidgetRegistry::InsertL()

// Insert the widget entry into the list if BundleID is not already in

// the list.

//

// @since 3.1

// ============================================================================

//

TInt CWidgetRegistry::InsertL( CWidgetEntry* aEntry )

    {

    CWidgetEntry* entry = NULL;

    TDesC bundleID = (*aEntry)[EBundleIdentifier];

    TInt pos  = GetWidgetEntry( bundleID, entry );

    if ( pos == KErrNotFound )

        {

        iUsedUids.AppendL( TUid::Uid( (*aEntry)[EUid] ) );

        TInt error = iEntries.Append( aEntry );

        if ( KErrNone != error )

            {

            TInt upos = iUsedUids.FindReverse( TUid::Uid( (*aEntry)[EUid] ) );

            iUsedUids.Remove( upos );

            User::Leave( error );

            }

        }

    return pos;

    }

// ============================================================================

// CWidgetRegistry::Remove()

// Remove the widget entry from the list

//

// @since 3.1

// ============================================================================

//

void CWidgetRegistry::Remove( const TDesC& aBundleId )

    {

    CWidgetEntry* entry = NULL;

    TInt pos  = GetWidgetEntry( aBundleId, entry );

    if ( pos != -1 )

        {

        TInt upos = iUsedUids.Find( TUid::Uid( (*entry)[EUid] ) );

        if ( upos >= 0 )

            {

            iUsedUids.Remove( upos );

            }

        iEntries.Remove( pos );

        delete entry;

        }

    }

// ============================================================================

// CWidgetRegistry::Remove()

// Remove the widget entry from the list

//

// @since 3.1

// ============================================================================

//

void CWidgetRegistry::Remove( const TUid& aUid )

    {

    CWidgetEntry* entry = NULL;

    TInt pos  = GetWidgetEntry( aUid, entry );

    if ( pos != -1 )

        {

        TInt upos = iUsedUids.Find( TUid::Uid( (*entry)[EUid] ) );

        if ( upos >= 0 )

            {

            iUsedUids.Remove( upos );

            }