/*
* 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 );
}
iEntries.Remove( pos );
delete entry;
}
}
// ============================================================================
// CWidgetRegistry::InternalizeL()
// Read entry info from data file into memory
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::InternalizeL( TBool doConsistency, // in param
TBool aIgnoreParseError, // in param
TBool& aDirtyFlag, // out param
TInt& aParseError )// out param
{
LOG_OPEN;
LOG( "Internalize" );
// prepare for consistency enforcement
RArray<TUid> appArchList( KDefaultWidgetCount );
RArray<TInt> appArchListFlags( KDefaultWidgetCount );
// default is internalization just imports files without
// modification, if dirty flag gets set to true, do externalize
// after internalize to bring files into sync with modified
// registry contents
aDirtyFlag = EFalse;
// internal dirty flag, will be copied to arg dirty flag at
// end if no leave occurs
TBool dirtyFlag = EFalse;
// Copy the entries so we are able to use them later
// iOldEntries owns the data and is responcible to ResetAndDestroy()
for ( TInt i = 0; i < iEntries.Count(); i++ )
{
iOldEntries.Append( iEntries[i] );
}
// Only reset here as the iOldEntries owns the data
iEntries.Reset();
iUsedUids.Reset();
CleanupClosePushL( appArchList );
CleanupClosePushL( appArchListFlags );
if ( doConsistency )
{
doConsistency = AppArchWidgets( appArchList, appArchListFlags );
}
if ( doConsistency )
{
// UIDs are the key differentiator of apps in app arch. The
// widget implementation used BundleID to differentiate
// widgets on installation (overwrite is keyed by BundleID).
// But once widgets are installed, they are assigned a unique
// UID. For UID allocation purposes, it is important that
// UIDs already known to app arch be reserved.
for ( TInt i = 0; i < appArchList.Count(); i++ )
{
// Do not maintain the list of used CWRT widget UIDs
if ( !TUidAllocator::IsCWRTWidget((appArchList)[i]) )
{
if ( KErrNone != iUsedUids.Append( (appArchList)[i] ) )
{
// no recovery possible
doConsistency = EFalse;
break;
}
}
}
}
LOG2( " iUsedUids %d and doConsistency %d",
(TInt)(iUsedUids.Count()), (TInt)doConsistency );
TRAPD( error, GetLprojNameL( iLprojName ) );
if ( KErrNone != error )
{
// on error use english
iLprojName = _L("en");
}
// Internalize the CWRT widgets, without consistency checking
// No multi-drive support for CWRT
TDriveUnit driveUnit(EDriveC);
CDir* installedListForDrive = NULL;
RArray<TInt> installedListForDriveFlags;
TRAP_IGNORE( // consistency checking doesn't apply to CWRT
InternalizeXmlL( iRegistryCWRTXmlFileName,
driveUnit,
EFalse,
appArchList,
appArchListFlags,
installedListForDrive,
installedListForDriveFlags,
dirtyFlag ) );
delete installedListForDrive;
installedListForDriveFlags.Close();
// List all drives in the system
TDriveList driveList;
User::LeaveIfError( iFs.DriveList(driveList) );
// Check all drives but Z and D. Scan from Y to A because that is
// the order that the loader and AppArch follow when "shadowing"
// UID identical apps. Drive Z is ignored because it is used for
// the phone ROM image and is not an installation location for
// widgets. Drive D is ignored because it is a temporary RAM disk
// and not a widget install location.
for ( TInt driveNumber = EDriveY; driveNumber >= EDriveA; driveNumber-- )
{
// The drives that will be filtered out are the same ones that
// WidgetInstaller filters out in CWidgetUIHandler::SelectDriveL()
if ( (EDriveD == driveNumber)
|| !driveList[driveNumber] )
{
// EDriveD is a temporary drive usually a RAM disk
continue;
}
TVolumeInfo volInfo;
if ( iFs.Volume( volInfo, driveNumber ) != KErrNone )
{
// volume is not usable (e.g. no media card inserted)
continue;
}
if ( (volInfo.iDrive.iType == EMediaNotPresent) ||
(volInfo.iDrive.iType == EMediaRom) ||
(volInfo.iDrive.iType == EMediaRemote) ||
(volInfo.iDrive.iDriveAtt & KDriveAttRom) ||
(volInfo.iDrive.iDriveAtt & KDriveAttSubsted) )
{
// not a suitable widget install drive
continue;
}
// found a usable drive
TDriveUnit driveUnit( driveNumber );
LOG1( " Drive %c", (TUint)(driveUnit.Name()[0]) );
// prepare for consistency enforcement
CDir* installedListForDrive = NULL;
RArray<TInt> installedListForDriveFlags;
if ( doConsistency )
{
doConsistency = InstallDirWidgets( driveUnit,
installedListForDrive,
installedListForDriveFlags );
}
LOG1( " after InstallDirWidgets doConsistency %d",
(TInt)doConsistency );
// direct install path to this drive
iWidgetInstallPath[0] = driveUnit.Name()[0];
// which persistent data files exist?
iRegistryBinaryFileName[0] = driveUnit.Name()[0];
TBool binaryExists = BaflUtils::FileExists( iFs,
iRegistryBinaryFileName );
iRegistryXmlFileName[0] = driveUnit.Name()[0];
TBool xmlExists = BaflUtils::FileExists( iFs,
iRegistryXmlFileName );
// Here internalizing a single drive. 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.
if ( xmlExists )
{
TRAP( aParseError,
InternalizeXmlL( iRegistryXmlFileName,
driveUnit,
doConsistency,
appArchList,
appArchListFlags,
installedListForDrive,
installedListForDriveFlags,
dirtyFlag ) );
}
else if ( binaryExists )
{
TRAP( aParseError,
InternalizeBinaryL( iRegistryBinaryFileName,
driveUnit,
doConsistency,
appArchList,
appArchListFlags,
installedListForDrive,
installedListForDriveFlags,
dirtyFlag ) );
}
if ( !aIgnoreParseError && aParseError )
{
User::Leave( aParseError );
}
if ( doConsistency )
{
InstallDirConsistency( installedListForDrive,
installedListForDriveFlags,
dirtyFlag );
}
delete installedListForDrive;
installedListForDriveFlags.Close();
} // for
// appArchList will not contain CWRT widgets, so
// consistency checking will not apply to them
if ( doConsistency )
{
AppArchListConsistency( appArchList, appArchListFlags );
}
//Do we need consistency check
//Quick hack to see if we need consistency check
if(!doConsistency)
{
AppArchWidgets( appArchList, appArchListFlags );
TInt wrtWidgetCount(0);
for(TInt i =0;i<iEntries.Count();i++)
{
CWidgetEntry* entry = iEntries[i];
if(!TUidAllocator::IsCWRTWidget(TUid::Uid((*entry)[EUid])))
wrtWidgetCount++;
}
if(appArchList.Count()!=wrtWidgetCount)
aParseError = ETrue;//need consistency
}
CleanupStack::PopAndDestroy( 2, &appArchList );//appArchListFlags, appArchList
aDirtyFlag = dirtyFlag;
// Reset and Destroy entries in iOldEntries array
iOldEntries.ResetAndDestroy();
LOG1( "Internalize done, dirty flag %d", (TInt)dirtyFlag );
LOG_CLOSE;
}
// ============================================================================
// CWidgetRegistry::InternalizeBinaryL()
// Read entry info from data file into memory
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::InternalizeBinaryL( const TDesC& aFileName,
const TDriveUnit& aDriveUnit,
TBool aDoConsistency,
RArray<TUid>& aAppArchList,
RArray<TInt>& aAppArchListFlags,
const CDir* aInstalledListForDrive,
RArray<TInt>& aInstalledListForDriveFlags,
TBool& aDirtyFlag )
{
LOG( "InternalizeBinaryL" );
RFile file;
User::LeaveIfError( file.Open( iFs, aFileName, EFileRead ) );
CleanupClosePushL( file );
RFileReadStream readStream;
CleanupClosePushL( readStream );
readStream.Attach( file );
TInt error = KErrNone;
TInt entryCount = 0,errorCount =0;
TRAP( error, entryCount = readStream.ReadInt32L() );
// TODO should limit entryCount to something like 1024
// for each entry in the registry file
for ( TInt i = 0 ; i < entryCount; i++ )
{
CWidgetEntry* entry = CWidgetEntry::NewL();
// push as delete entry so if we leave it will be handled
CleanupDeletePushL( entry );
// extract one entry
TRAP( error,
entry->InternalizeBinaryL( readStream ) );
if ( KErrNone == error )
{
CWidgetEntry* res( NULL );
if ( aDoConsistency )
{
res = EntryConsistency( entry,
aAppArchList,
aAppArchListFlags,
aInstalledListForDrive,
aInstalledListForDriveFlags,
aDriveUnit,
aDirtyFlag );
}
if ( NULL != res )
{
TRAP( error, InsertL( entry ) );
if ( KErrNone != error )
{
delete entry;
}
else
{
__ASSERT_DEBUG( res == entry, User::Invariant() );
// Entry was inserted successfully.
//CleanupStack::Pop( entry );
// add uid to AppArchList if not there,
// this can happend due to UID
// reallocation for UID collision resolution
TInt uidInt = (*entry)[EUid];
if ( aDoConsistency &&
( KErrNotFound
== aAppArchList.Find(TUid::Uid(uidInt)) ) )
{
User::LeaveIfError( aAppArchList.Append( TUid::Uid(uidInt) ) );
User::LeaveIfError( aAppArchListFlags.Append( EAppListFlagEntry ) );
}
LOG2( " entry 0x%x (%d) added to registry",
uidInt, uidInt );
}
}
else
{
// Pop and delete the un-needed entry so it is not left behind.
errorCount++;
}
}
else
{
// entry error
delete entry;
}
CleanupStack::Pop(); //entry
} // for
CleanupStack::PopAndDestroy( 2, &file ); // readStream, file
if ( errorCount != 0 )
{
User::Leave(KErrGeneral);
}
}
// ============================================================================
// CWidgetRegistry::InternalizeXmlL()
// Read entry info from data file into memory
//
// @since 5.0
// ============================================================================
//
void CWidgetRegistry::InternalizeXmlL( const TDesC& aFileName,
const TDriveUnit& aDriveUnit,
TBool aDoConsistency,
RArray<TUid>& aAppArchList,
RArray<TInt>& aAppArchListFlags,
const CDir* aInstalledListForDrive,
RArray<TInt>& aInstalledListForDriveFlags,
TBool& aDirtyFlag )
{
LOG( "InternalizeXmlL" );
RFile file;
User::LeaveIfError( file.Open( iFs, aFileName, EFileRead ) );
CleanupClosePushL( file );
TInt size;
User::LeaveIfError( file.Size( size ) );
HBufC8* buf = HBufC8::NewLC( size );
TPtr8 bufPtr( buf->Des() );
User::LeaveIfError( file.Read( bufPtr ) );
// initialize the parser and check compiled code matches lib version
LIBXML_TEST_VERSION
xmlDocPtr doc; // resulting document tree
doc = xmlReadMemory( (const char *)bufPtr.Ptr(), bufPtr.Length(),
NULL, // no base URL
NULL, // get encoding from doc
0); // options
if ( !doc )
{
LOG( " leaving: parse failed XML corrupt" );
User::Leave( KErrCorrupt );
}
//TCleanupItem item( XmlDocFree, doc );
//CleanupStack::PushL( item );
xmlNode* rootElement = xmlDocGetRootElement( doc );
TPtrC8 rootTag( rootElement->name );
if ( 0 != rootTag.Compare( KWidgetRegistry() ) )
{
LOG( " leaving: XML root element mismatch" );
User::Leave( KErrCorrupt );
}
for ( xmlNode* n = rootElement->children;
n;
n = n->next )
{
if ( n->type == XML_ELEMENT_NODE )
{
TPtrC8 element( n->name );
if ( 0 == element.Compare( KEntry() ) )
{
if ( NULL == n->children )
{
// malformed? should we require entry to have
// some minimal info?
continue;
}
CWidgetEntry* entry = CWidgetEntry::NewL();
CleanupStack::PushL( entry );
// extract one entry
TRAPD( error,
entry->InternalizeXmlL( iFs, doc, n->children,
iXmlProcessor ) );
LOG2( " entry 0x%x read from XML with error %d",
(error == KErrNone)? (*entry)[EUid] : 0,
error );
if ( KErrNone == error )
{
if ( aDoConsistency )
{
entry = EntryConsistency( entry,
aAppArchList,
aAppArchListFlags,
aInstalledListForDrive,
aInstalledListForDriveFlags,
aDriveUnit,
aDirtyFlag );
}
if ( NULL != entry )
{
CWidgetEntry* entry1 = NULL;
TInt uid = (*entry)[EUid];
TInt pos = GetWidgetOldEntry( TUid::Uid( uid ), entry1 );
if ( pos != -1 )
{
entry->SetActive((iOldEntries[pos]->ActiveL()));
entry->SetFullView((iOldEntries[pos]->GetFullViewState()));
entry->SetMiniView((iOldEntries[pos]->GetMiniViewState()));
}
TRAP( error, InsertL( entry ) );
if ( KErrNone != error )
{
delete entry;
}
else
{
entry->SetBlanketPermission((*entry)[EBlanketPermGranted] );
// add uid to AppArchList if not there,
// this can happend due to UID
// reallocation for UID collision resolution
TInt uidInt = (*entry)[EUid];
if ( aDoConsistency &&
( KErrNotFound
== aAppArchList.Find(TUid::Uid(uidInt)) ) )
{
aAppArchList.Append( TUid::Uid(uidInt) );
aAppArchListFlags.Append( EAppListFlagEntry );
}
LOG2( " entry 0x%x (%d) added to registry",
uidInt, uidInt );
}
}
}
else
{
// entry error
delete entry;
LOG( " entry internalize failed" );
}
CleanupStack::Pop(); //entry
} // if <entry>
} // if n is element
} // for
xmlFreeDoc( doc );
xmlCleanupParser();
CleanupStack::PopAndDestroy( 2, &file ); // buf, file
}
// ============================================================================
// CWidgetRegistry::ExternalizeL()
// Write entry info in memory into data file
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::ExternalizeL()
{
// in order to have a list of all entries for a particular drive,
// create a hash map from the entries with the key as drive name
// and value as an array of entry indices for that drive
RPtrHashMap< TInt, CArrayFixFlat<TInt> > driveEntryHashMap;
CleanupClosePushL( driveEntryHashMap );
CArrayFixFlat<TInt>* cwrtWidgetArray = new (ELeave) CArrayFixFlat<TInt>(1);
CleanupStack::PushL( cwrtWidgetArray );
for (TInt i = 0 ;i < iEntries.Count(); i++)
{
CWidgetEntry* entry = iEntries[i];
// Bypass if the widget is a CWRT widget, they're externalized
// independently
if (TUidAllocator::IsCWRTWidget(TUid::Uid((*entry)[EUid]))) {
cwrtWidgetArray->AppendL(i);
continue;
}
const TDesC& driveName = (*entry)[EDriveName];
TDriveUnit driveUnit( driveName );
CArrayFixFlat<TInt>* array =
driveEntryHashMap.Find( driveUnit );
if( !array )
{
TInt* driveNo = new (ELeave) TInt( driveUnit );
CArrayFixFlat<TInt>* drArray = new (ELeave) CArrayFixFlat<TInt>(1);
CleanupStack::PushL( drArray );
drArray->AppendL(i);
driveEntryHashMap.Insert(driveNo, drArray);
}
else
{
array->AppendL(i);
}
}
// List all drives in the system
TDriveList driveList;
User::LeaveIfError( iFs.DriveList(driveList) );
// Check all drives
for ( TInt driveNumber = EDriveA; driveNumber <= EDriveZ; driveNumber++ )
{
// The drives that will be filtered out are the same ones that
// WidgetInstaller filters out in CWidgetUIHandler::SelectDriveL()
if ( (EDriveD == driveNumber)
|| !driveList[driveNumber] )
{
// EDriveD is a temporary drive, usually a RAM disk
continue;
}
TVolumeInfo volInfo;
if ( iFs.Volume( volInfo, driveNumber ) != KErrNone )
{
// The volume is not usable (e.g. no media card inserted)
continue;
}
if ( (volInfo.iDrive.iType == EMediaNotPresent) ||
(volInfo.iDrive.iType == EMediaRom) ||
(volInfo.iDrive.iType == EMediaRemote) ||
(volInfo.iDrive.iDriveAtt & KDriveAttRom) ||
(volInfo.iDrive.iDriveAtt & KDriveAttSubsted) )
{
continue;
}
// found a usable drive
TDriveUnit driveUnit( driveNumber );
// redirect paths to this drive
iRegistryBinaryFileName[0] = driveUnit.Name()[0];
iRegistryXmlFileName[0] = iRegistryBinaryFileName[0];
iRegistryXmlTempFileName[0] = iRegistryBinaryFileName[0];
const CArrayFixFlat<TInt>* indices =
driveEntryHashMap.Find( driveNumber );
if ( NULL == indices )
{
// not in hash map, delete any existing versions
BaflUtils::DeleteFile( iFs, iRegistryBinaryFileName );
BaflUtils::DeleteFile( iFs, iRegistryXmlFileName );
BaflUtils::DeleteFile( iFs, iRegistryXmlTempFileName );
}
else
{
iFs.CreatePrivatePath( driveUnit );
// a transactional file update to protect against
// disk full, etc: overwrite temp then rename temp to original
TRAPD( error,
ExternalizeXmlL( iRegistryXmlTempFileName, indices ) );
if ( KErrNone == error )
{
// last steps in transactional update
BaflUtils::DeleteFile( iFs, iRegistryXmlFileName );
BaflUtils::RenameFile( iFs,
iRegistryXmlTempFileName,
iRegistryXmlFileName );
}
else // handle leave by deleting temp file
{
BaflUtils::DeleteFile( iFs, iRegistryXmlTempFileName );
}
}
}
TDriveUnit driveUnit( EDriveC );
iRegistryXmlTempFileName[0] = driveUnit.Name()[0];
iFs.CreatePrivatePath( driveUnit );
// a transactional file update to protect against
// disk full, etc: overwrite temp then rename temp to original
TRAPD( error,
ExternalizeXmlL( iRegistryXmlTempFileName, cwrtWidgetArray ) );
if ( KErrNone == error )
{
// last steps in transactional update
BaflUtils::DeleteFile( iFs, iRegistryCWRTXmlFileName );
BaflUtils::RenameFile( iFs,
iRegistryXmlTempFileName,
iRegistryCWRTXmlFileName );
}
else // handle leave by deleting temp file
{
BaflUtils::DeleteFile( iFs, iRegistryXmlTempFileName );
}
for ( TInt i = 0; i < driveEntryHashMap.Count(); i++ )
{
CleanupStack::Pop();
}
CleanupStack::PopAndDestroy( cwrtWidgetArray );
CleanupStack::Pop( &driveEntryHashMap );
driveEntryHashMap.ResetAndDestroy();
driveEntryHashMap.Close();
}
// ============================================================================
// CWidgetRegistry::ExternalizeBinaryL
// Externalize Binary file
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::ExternalizeBinaryL( const TDesC& aFilename,
const CArrayFixFlat<TInt>* aIndices )
{
RFileWriteStream writeStream;
CleanupClosePushL( writeStream );
RFile file;
User::LeaveIfError( file.Replace( iFs, aFilename, EFileWrite ) );
CleanupClosePushL( file );
writeStream.Attach( file );
writeStream.WriteInt32L( aIndices->Count() );
for ( TInt i = 0; i < aIndices->Count() ; i++ )
{
TInt pos = (*aIndices)[i];
CWidgetEntry* entry = iEntries[pos];
if(entry)
{
TRAPD( error, entry->ExternalizeBinaryL( writeStream ) );
if ( KErrNone != error )
{
// TODO how to recover from error?
continue;
}
}
}
writeStream.CommitL();
CleanupStack::PopAndDestroy(2);
}
// ============================================================================
// CWidgetRegistry::ExternalizeXmlL
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::ExternalizeXmlL( const TDesC& aFilename,
const CArrayFixFlat<TInt>* aIndices )
{
// sequence: write XML header, write each entry including
// unrecognized XML, write closing XML
RFileWriteStream writeStream;
CleanupClosePushL( writeStream );
RFile file;
User::LeaveIfError( file.Replace( iFs, aFilename, EFileWrite ) );
CleanupClosePushL( file );
writeStream.Attach( file );
// write XML header
TInt bom = 0xfeff; // byte-order mark
writeStream.WriteInt16L( bom );
writeStream.WriteL( KXmlHeader );
writeStream.WriteL( KXmlNewline );
writeStream.WriteL( KXmlRootStart );
writeStream.WriteL( KXmlNewline );
for ( TInt i = 0; i < aIndices->Count() ; i++ )
{
TInt pos = (*aIndices)[i];
CWidgetEntry* entry = iEntries[pos];
if ( entry )
{
writeStream.WriteL( KWidgetEntryStart );
writeStream.WriteL( KXmlNewline );
// TODO handle unrecognized XML from internalize
TRAPD( error, entry->ExternalizeXmlL( writeStream,
iXmlProcessor,
iFs) );
writeStream.WriteL( KWidgetEntryEnd );
writeStream.WriteL( KXmlNewline );
if ( KErrNone != error )
{
// TODO how to recover from error?
continue;
}
}
}
writeStream.WriteL( KXmlRootEnd );
writeStream.WriteL( KXmlNewline );
writeStream.CommitL();
CleanupStack::PopAndDestroy( 2 ); // file, writeStream
}
// ============================================================================
// CWidgetRegistry::RegisterWidget()
// Creates CWidgetEntry
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::RegisterWidgetL( RReadStream& aStream )
{
CWidgetEntry* entry = CWidgetEntry::NewL();
CleanupStack::PushL( entry );
entry->InternalizeBinaryL( aStream );
InsertL( entry );
CleanupStack::Pop(); //entry
ExternalizeL();
//Notify WRT Harvester that widget registry has changed
NotifyWidgetAltered();
}
// ============================================================================
// CWidgetRegistry::IsWidget()
// Returns true if the Uid falls within the range specified for widgets
//
// @since 3.1
// ============================================================================
//
TBool CWidgetRegistry::IsWidget( const TUid& aUid ) const
{
if ( ( aUid.iUid >= KWidgetUidLowerBound ) &&
( aUid.iUid <= KWidgetUidUpperBound ) )
{
return ETrue;
}
else
{
return EFalse;
}
}
// ============================================================================
// CWidgetRegistry::WidgetExists()
// Returns true if the widget is installed
//
// @since 3.1
// ============================================================================
//
TBool CWidgetRegistry::WidgetExists( const TDesC& aWidgetId ) const
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( TPtrC( aWidgetId ), entry );
return ( pos != -1 )? ETrue : EFalse;
}
// ============================================================================
// CWidgetRegistry::IsWidgetRunning()
// Returns true if the widget is running
//
// @since 3.1
// ============================================================================
//
TBool CWidgetRegistry::IsWidgetRunning( const TUid& aUid ) const
{
TBool active = EFalse;
CWidgetEntry* entry = NULL;
GetWidgetEntry( aUid, entry );
if ( entry && entry->ActiveL() )
{
active = ETrue;
}
return active;
}
// ============================================================================
// CWidgetRegistry::WidgetSapiAccessState()
// Returns sapi widget access state
//
// @since 5.0
// ============================================================================
//
TInt CWidgetRegistry::WidgetSapiAccessState( const TUid& aUid ) const
{
CWidgetEntry* entry = NULL;
GetWidgetEntry( aUid, entry );
if ( entry)
{
return entry->SapiAccessState();
}
return -1;
}
// ============================================================================
// CWidgetRegistry::IsWidgetInMiniView()
// Returns true if the widget is in miniview
//
// @since 5.0
// ============================================================================
//
TBool CWidgetRegistry::IsWidgetInMiniView( const TUid& aUid ) const
{
TBool state = EFalse;
CWidgetEntry* entry = NULL;
GetWidgetEntry( aUid, entry );
if ( entry && entry->GetMiniViewState())
{
state = ETrue;
}
return state;
}
// ============================================================================
// CWidgetRegistry::IsWidgetInFullView()
// Returns true if the widget is in miniview
//
// @since 5.0
// ============================================================================
//
TBool CWidgetRegistry::IsWidgetInFullView( const TUid& aUid ) const
{
TBool state = EFalse;
CWidgetEntry* entry = NULL;
GetWidgetEntry( aUid, entry );
if ( entry && entry->GetFullViewState())
{
state = ETrue;
}
return state;
}
TBool CWidgetRegistry::IsBlanketPermGranted( const TUid& aUid ) const
{
TBool state = EFalse;
CWidgetEntry* entry = NULL;
GetWidgetEntry( aUid, entry );
if ( entry && entry->GetBlanketPermGranted())
{
state = ETrue;
}
return state;
}
// ============================================================================
// CWidgetRegistry::InstalledWidgets()
// Returns widget info for all the installed widgets
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::InstalledWidgetsL( RWidgetInfoArray& aWidgetInfoArr )
{
for ( TInt pos = 0; pos < iEntries.Count(); pos++ )
{
CWidgetEntry* entry = iEntries[pos];
if(entry)
{
CWidgetInfo *info = new ( ELeave ) CWidgetInfo();
info->iUid = TUid::Uid( (*entry)[EUid] );
info->iFileSize = (*entry)[EFileSize];
*(info->iBundleName) = (*entry)[EBundleName];
*(info->iDriveName) = (*entry)[EDriveName];
aWidgetInfoArr.AppendL( info );
}
}
}
// ============================================================================
// CWidgetRegistry::RunningWidgetsL()
// Returns widget info for all the running widgets
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::RunningWidgetsL( RWidgetInfoArray& aWidgetInfoArr )
{
for ( TInt pos = 0; pos < iEntries.Count(); pos++ )
{
CWidgetEntry* entry = iEntries[pos];
if ( entry && entry->ActiveL() )
{
CWidgetInfo* info = new ( ELeave ) CWidgetInfo();
info->iUid = TUid::Uid( (*entry)[EUid] );
info->iFileSize = (*entry)[EFileSize];
*(info->iBundleName) = (*entry)[EBundleName];
*(info->iDriveName) = (*entry)[EDriveName];
aWidgetInfoArr.AppendL( info );
}
}
}
// ============================================================================
// CWidgetRegistry::DeRegisterWidgetL()
// Deregister the widget
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::DeRegisterWidgetL( const TUid& aUid )
{
Remove( aUid );
ExternalizeL( );
//Notify WRT Harvester that widget registry has changed
NotifyWidgetAltered();
}
// ============================================================================
// CWidgetRegistry::GetWidgetBundleId()
// Returns bundleId of the widget with a particular UId.
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::GetWidgetBundleId( const TUid& aUid, TDes& aBundleId )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
const TDesC& widgetBundleId = (*entry)[EBundleIdentifier];
aBundleId.Copy( widgetBundleId );
aBundleId.SetLength( widgetBundleId.Length() );
}
else
{
aBundleId.SetLength( 0 );
}
}
// ============================================================================
// CWidgetRegistry::GetWidgetBundleName()
// Returns bundle display name of the widget with a particular UId.
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::GetWidgetBundleName( const TUid& aUid, TDes& aBundleName )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
const TDesC& widgetBundleName = (*entry)[EBundleName];
aBundleName.Copy( widgetBundleName );
aBundleName.SetLength( widgetBundleName.Length() );
}
else
{
aBundleName.SetLength( 0 );
}
}
// ============================================================================
// CWidgetRegistry::GetWidgetPropertyValueL()
// return serialized value of property aId for the widget aUid or leave
//
// @since 3.1
// ============================================================================
//
CBufFlat* CWidgetRegistry::GetWidgetPropertyValueL(
const TUid& aUid,
TWidgetPropertyId aId,
TInt aMaxLength )
{
CWidgetEntry& entry = GetWidgetEntryL( aUid );
CBufFlat* buf = CBufFlat::NewL( aMaxLength );
CleanupStack::PushL( buf );
RBufWriteStream stream( *buf ); // stream over the buffer
CleanupClosePushL( stream );
// TBD safe array indexing (leave if out of range)
entry[aId].SerializeL( stream ); // serialize
CleanupStack::PopAndDestroy( &stream );
CleanupStack::Pop(); // buf
return buf;
}
// ============================================================================
// CWidgetRegistry::GetWidgetPath()
// Returns path of the widget with a particular UId.
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::GetWidgetPath( const TUid& aUid, TDes& aPath )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
const TDesC& widgetBasePath = (*entry)[EBasePath];
aPath.Copy( widgetBasePath );
aPath.SetLength( widgetBasePath.Length() );
}
else
{
aPath.SetLength( 0 );
}
}
// ============================================================================
// CWidgetRegistry::GetLprojName()
// Returns lproj name
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::GetLprojNameL( TDes& aPath )
{
if ( !iLangDirList.Count() )
{
CreateLangDirListL();
}
HBufC8* lprojName = iLangDirList.Find( User::Language() );
if ( lprojName )
{
TPtr8 lprojNamePtr = lprojName->Des();
aPath.Copy( lprojNamePtr );
}
else
{
aPath.Copy( KWidgetDefaultLangDir );
}
}
// ============================================================================
// CWidgetRegistry::GetWidgetUid()
// Returns UId of the widget with a particular bundle identifier
//
// @since 3.1
// ============================================================================
//
TUid CWidgetRegistry::GetWidgetUid( const TDesC& aBundleId ) const
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aBundleId, entry );
if ( pos != -1 )
{
return TUid::Uid( (*entry)[EUid] );
}
else
{
return KNullUid;
}
}
// ============================================================================
// CWidgetRegistry::GetWidgetUidForUrl()
// Returns uid of the widget with a patricular html path
//
// @since 3.1
// ============================================================================
//
TUid CWidgetRegistry::GetWidgetUidForUrl( const TDesC& aUrl ) const
{
for( TInt i = 0; i < iEntries.Count(); i++)
{
CWidgetEntry* entry = iEntries[i];
if ( aUrl.CompareF( (*entry)[EMainHTML] ) == 0 )
{
return TUid::Uid( (*entry)[EUid] );
}
}
return KNullUid;
}
// ============================================================================
// CWidgetRegistry::UsedUids()
// Returns array of used UIds
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::UsedUidsL( RUidArray& aUsedUids )
{
for( TInt i = 0; i < iUsedUids.Count(); i++ )
{
aUsedUids.AppendL( iUsedUids[i] );
}
}
// ============================================================================
// CWidgetRegistry::GetAvailableUidL()
// Get next availble uid from the pool using a random generation
//
// @since 3.1
// ============================================================================
//
TUid CWidgetRegistry::GetAvailableUidL( TInt aDriveLetter )
{
TUidAllocator uidAllocator;
return TUid::Uid( uidAllocator.AllocateL( iUsedUids, aDriveLetter ) );
}
// ============================================================================
// CWidgetRegistry::SetActive()
// Set/Reset active status of the widget with a particular UId
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::SetActive( TUid aUid, TInt aStatus )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
entry->SetActive( aStatus );
}
}
// ============================================================================
// CWidgetRegistry::SetMiniView()
// Set/Reset Widget status for launched in MiniView
//
// @since 5.0
// ============================================================================
//
void CWidgetRegistry::SetMiniView( TUid aUid, TInt aStatus )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
entry->SetMiniView( aStatus );
}
}
// ============================================================================
// CWidgetRegistry::SetFullView()
// Set/Reset Widget status in FullView
//
// @since 5.0
// ============================================================================
//
void CWidgetRegistry::SetFullView( TUid aUid, TInt aStatus )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
entry->SetFullView( aStatus );
}
}
// ============================================================================
// CWidgetRegistry::SetBlanketPermissionL()
// Set/Reset Widget Blanket Permission
//
// @since 5.0
// ============================================================================
//
void CWidgetRegistry::SetBlanketPermissionL( TUid aUid, TInt aStatus )
{
CWidgetEntry* entry = NULL;
TInt pos = GetWidgetEntry( aUid, entry );
if ( pos != -1 )
{
entry->SetBlanketPermission( aStatus );
}
ExternalizeL();
}
// ============================================================================
// CWidgetRegistry::CreateLangDirListL()
// create the mapping table for language and lproj dir
//
// @since 3.1
// ============================================================================
//
void CWidgetRegistry::CreateLangDirListL()
{
TLanguage defaultLanguage = User::Language();
RFile file;
TFileName langDirFile;
iFs.PrivatePath( langDirFile );
#ifdef __WINSCW__
langDirFile.Insert( 0, _L( "C:" ));
#else
langDirFile.Insert( 0, _L( "Z:" ));
#endif
langDirFile.Append( KWidgetDirFile );
User::LeaveIfError( file.Open( iFs, langDirFile, EFileRead ) );
CleanupClosePushL( file );
TInt size;
User::LeaveIfError( file.Size( size ) );
HBufC8* buf = HBufC8::NewLC( size );
TPtr8 bufPtr( buf->Des() );
User::LeaveIfError( file.Read( bufPtr ) );
CleanupStack::Pop( buf );
CleanupStack::PopAndDestroy( &file );
CleanupStack::PushL( buf );
// initialize the parser and check compiled code matches lib version
LIBXML_TEST_VERSION
xmlDocPtr doc; // resulting document tree
doc = xmlReadMemory( (const char *)bufPtr.Ptr(), bufPtr.Length(),
NULL, // no base URL
NULL, // get encoding from doc
0); // options
if ( !doc )
{
User::Leave( KErrCorrupt );
}
xmlNode* rootElement = xmlDocGetRootElement( doc );
TInt* langID = NULL;
xmlNode* n;
for ( n = rootElement; n; n = TraverseNextNode( n ) )
{
HBufC8* langDir;
if ( n->type == XML_ELEMENT_NODE )
{
TPtrC8 element( n->name );
if ( element.Compare( KLangID() ) == 0 )
{
if ( n->children && n->children->type == XML_TEXT_NODE )
{
TPtrC8 content( n->children->content );
langID = new TInt( atoi( (const char *)content.Ptr() ) );
CleanupStack::PushL( langID );
}
}
if ( element.Compare( KLangDir() ) == 0 )
{
if ( n->children && n->children->type == XML_TEXT_NODE )
{
TPtrC8 content( n->children->content );
langDir = HBufC8::NewLC( content.Length() );
langDir->Des().Copy( content );
if ( *langID <= 0 )
{
User::Leave( KErrCorrupt );
}
TInt* currentLangID = new TInt(*langID);
CleanupStack::Pop(langDir);
iLangDirList.Insert( currentLangID, langDir );
*langID = 0;
CleanupStack::PopAndDestroy(langID);
langID = NULL;
}
}
} // if n is element
} // for
xmlFreeDoc(doc);
xmlCleanupParser();
XmlEngineCleanup();
CleanupStack::PopAndDestroy( buf );
}
TBool CWidgetRegistry::InstallDirWidgets(
const TDriveUnit& aDriveUnit,
CDir*& aInstalledListForDrive,
RArray<TInt>& aInstalledListForDriveFlags )
{
LOG( "InstallDirWidgets" );
TBool doConsistency = ETrue;
aInstalledListForDrive = NULL;
aInstalledListForDriveFlags.Reset();
iWidgetInstallPath[0] = aDriveUnit.Name()[0];
TInt error = iFs.GetDir( iWidgetInstallPath,
KEntryAttDir | KEntryAttMatchExclusive,
ESortNone,
aInstalledListForDrive );
if ( KErrPathNotFound == error )
{
LOG( "install path not found" );
delete aInstalledListForDrive;
aInstalledListForDrive = NULL;
return doConsistency;
}
if ( KErrNone != error || NULL == aInstalledListForDrive )
{
delete aInstalledListForDrive;
aInstalledListForDrive = NULL;
doConsistency = EFalse;
LOG( "error listing install directory, doConsistency 0" );
}
else
{
TInt count =
( (NULL == aInstalledListForDrive) ?
0 : aInstalledListForDrive->Count() );
if ( count )
{
for ( TInt i = 0; i < aInstalledListForDrive->Count(); i++ )
{
error = aInstalledListForDriveFlags.Append( 0 );
if ( KErrNone != error )
{
break;
}
}
if ( KErrNone != error )
{
doConsistency = EFalse;
aInstalledListForDriveFlags.Reset();
delete aInstalledListForDrive;
aInstalledListForDrive = NULL;
}
}
}
LOG_CODE( if ( aInstalledListForDrive ) )
LOG2( "InstallDirWidgets done count %d doConsistency %d",
aInstalledListForDrive->Count(),
(TInt)doConsistency );
LOG_CODE( else )
LOG1( "InstallDirWidgets return NULL list doConsistency %d",
(TInt)doConsistency );
return doConsistency;
}
// a routine to build an array of widgets according to app arch app list
// returns NULL on error, otherwise a UID list (possibly with no entries)
TInt CWidgetRegistry::AppArchWidgetUids( RArray< TUid >& aUids )
{
LOG( "AppArchWidgetUids" );
TInt error = iAppArch.GetAllApps();
aUids.Reset();
if ( KErrNone != error )
{
LOG ( "AppArchWidgetUids done error NULL list" );
return error;
}
TInt appArchWaitTotal = 0;
TApaAppInfo info;
do
{
error = iAppArch.GetNextApp( info );
if ( KErrNone == error )
{
if ( TUidAllocator::IsWidget( info.iUid ) &&
!TUidAllocator::IsCWRTWidget( info.iUid ) )
{
LOG2( " widget uid 0x%x (%d)",
(TUint)(info.iUid.iUid), info.iUid.iUid );
error = aUids.Append( info.iUid );
if ( KErrNone != error )
{
break;
}
}
continue;
}
else if ( RApaLsSession::EAppListInvalid == error )
{
if ( appArchWaitTotal > KAppArchTimeout )
{
LOG( " appArchWaitTotal > KAppArchTimeout" );
break;
}
appArchWaitTotal += KAppArchDelayInterval;
LOG1( " appArchWaitTotal %d", appArchWaitTotal );
User::After( KAppArchDelayInterval );
continue;
}
} while ( RApaLsSession::ENoMoreAppsInList != error );
if ( RApaLsSession::ENoMoreAppsInList != error )
{
aUids.Reset();
}
else
{
error = KErrNone;
}
LOG_CODE( if ( aUids.Count() ) )
LOG1( "AppArchWidgetUids done widget count %d",
aUids.Count() );
LOG_CODE( else )
LOG( "AppArchWidgetUids done error NULL list" );
return error;
}
// if primary return bool is T then arg lists will be non NUll, else
// return bool will be F and arg lists will be NULL (error condition)
TBool CWidgetRegistry::AppArchWidgets( RArray<TUid>& aAppArchList,
RArray<TInt>& aAppArchListFlags )
{
TBool doConsistency = ETrue;
TInt error = AppArchWidgetUids( aAppArchList );
aAppArchListFlags.Reset();
// NULL means AppArchWidgetUids encountered an error
if ( error )
{
// doConsistency flase means there is an unrecoverable error
// in consistency logic
doConsistency = EFalse;
}
else
{
TInt error = KErrNone;
for ( TInt i = 0 ; i < aAppArchList.Count(); i++ )
{
error = aAppArchListFlags.Append( 0 );
if ( KErrNone != error )
{
break;
}
}
if ( KErrNone != error )
{
doConsistency = EFalse;
aAppArchListFlags.Reset();
aAppArchList.Reset();
}
}
LOG_CODE( if ( aAppArchList.Count() ) )
LOG2( "AppArchWidgets done widgets count %d doConsistency %d",
aAppArchListFlags.Count(), (TInt)doConsistency );
LOG_CODE( else )
LOG1( "AppArchWidgets done error doConsistency %d",
(TInt)doConsistency );
return doConsistency;
}
// when called: aAppArchList and Flags must not be
// NULL. aInstalledListForDrive and Flags may be NULL
CWidgetEntry* CWidgetRegistry::EntryConsistency(
CWidgetEntry* aEntry,
const RArray<TUid>& aAppArchList,
RArray<TInt>& aAppArchListFlags,
const CDir* aInstalledListForDrive,
RArray<TInt>& aInstalledListForDriveFlags,
const TDriveUnit& aDriveUnit,
TBool& aDirtyFlag )
{
LOG( "EntryConsistency" );
TInt error;
TBool inAppList;
TUid uid;
if ( IsEntryInstalled( aEntry, aInstalledListForDrive,
aInstalledListForDriveFlags ) )
{
error = IsEntryInAppList( aEntry,
aAppArchList,
aAppArchListFlags,
inAppList,
uid );
if ( ( inAppList == EFalse ) || ( KErrNone != error ) )
{
if ( KErrNone == error )
{
LOG( " entry not in AppArch" );
// not in AppArch but may be using a UID already in
// use (UID conflict)
error =
InternalizeEntryNewUidIfNeeded( aEntry, aDriveUnit );
if ( KErrNone == error )
{
iInstaller->RenameIconFile( iFs, aEntry->Properties() );
TInt uidInt = (*aEntry)[EUid];
TRAP( error,
iInstaller->RegisterWidgetL(
(*aEntry)[EMainHTML],
(*aEntry)[EBundleDisplayName],
(*aEntry)[EIconPath],
(*aEntry)[EDriveName],
TUid::Uid( uidInt ) ) );
if ( KErrNone == error )
{
LOG2( " registered widget 0x%x (%d)",
uidInt, uidInt );
LOG( " registry dirty flag set" );
aDirtyFlag = ETrue;
}
}
}
// catches errors from several prior lines
if ( KErrNone != error )
{
// allocated uid hasn't been added to iUsedUid yet so
// just delete entry
// on error don't put entry in registry
LOG( " error entry deleted" );
delete aEntry;
aEntry = NULL;
}
}
}
else
{
LOG( " entry is not installed" );
// entry is not installed, clean up app list if needed
error = IsEntryInAppList( aEntry,
aAppArchList,
aAppArchListFlags,
inAppList,
uid );
if ( ( (TInt)ETrue == inAppList ) && ( KErrNone == error ) )
{
LOG( " removing from AppArch" );
// there is nothing useful to do on error
TRAP_IGNORE( iInstaller->DeregisterWidgetL( uid ) );
}
// don't put entry in registry
LOG( " entry deleted" );
delete aEntry;
aEntry = NULL;
aDirtyFlag = ETrue;
}
LOG( "EntryConsistency done " );
return aEntry;
}
// aInstalledListForDrive and Flags may be NULL (meaning no installed widgets)
TBool CWidgetRegistry::IsEntryInstalled(
CWidgetEntry* aEntry,
const CDir* aInstalledListForDrive,
RArray<TInt>& aInstalledListForDriveFlags )
{
TBool result = EFalse;
// NULL is an expected input due to GetDir producing it for empty lists
if ( NULL != aInstalledListForDrive )
{
const TDesC& bundleIdentifier = (*aEntry)[EBundleIdentifier];
for ( TInt i = 0; i < aInstalledListForDrive->Count(); i++ )
{
if ( !((aInstalledListForDriveFlags)[i] & EInstallListFlagEntry ))
{
TEntry dirEntry = (*aInstalledListForDrive)[i];
if ( 0 == bundleIdentifier.CompareF( dirEntry.iName ) )
{
(aInstalledListForDriveFlags)[i] |= EInstallListFlagEntry;
result = ETrue;
break;
}
}
}
}
LOG1( "IsEntryInstalled result %d", (TInt)result );
return result;
}
// aAppArchList and Flags must not be NULL but may be empty (0 count)
TInt CWidgetRegistry::IsEntryInAppList( CWidgetEntry* aEntry,
const RArray<TUid>& aAppArchList,
RArray<TInt>& aAppArchListFlags,
TBool& aInAppList,
TUid& uid )
{
// entry has uid and EMainHTML, appInfo has uid and iFullName,
// both should match exactly
TInt error = KErrNone;
aInAppList = EFalse;
for ( TInt i = 0; i < aAppArchList.Count(); i++ )
{
if ( !( (aAppArchListFlags)[i] & EAppListFlagEntry ) )
{
uid = aAppArchList[i];
TInt uidInt = (*aEntry)[EUid];
TUid uid2 = TUid::Uid( uidInt );
if ( uid == uid2 )
{
TApaAppInfo appInfo;
error = iAppArch.GetAppInfo( appInfo, uid );
if ( KErrNone == error )
{
const TDesC& mainHtml = (*aEntry)[EMainHTML];
if ( 0 == mainHtml.Compare( appInfo.iFullName ) )
{
aAppArchListFlags[i] |= EAppListFlagEntry;
aInAppList = ETrue;
break;
}
}
else
{
break;
}
}
}
}
LOG2( "IsEntryInAppList done %d error %d",
(TInt)aInAppList, error );
return error;
}
// This will assign a new UID if the UID in the entry appears either
// in iUsedUids or a call to GetAppInfo returns some info (something
// is using the UID). The new UID will *not* be placed in iUsedUids and
// GetAppInfo using the new UID will return KErrNotFound.
TInt CWidgetRegistry::InternalizeEntryNewUidIfNeeded(
CWidgetEntry* aEntry,
const TDriveUnit& aDriveUnit )
{
LOG( "InternalizeEntryNewUidIfNeeded" );
// entry has a uid but it may already be in use by another widget
// according to app arch or iUsedUids
TUidAllocator uidAllocator;
TInt upos = iUsedUids.Find( TUid::Uid( (*aEntry)[EUid] ) );
TApaAppInfo appInfo;
TInt error = iAppArch.GetAppInfo( appInfo, TUid::Uid( (*aEntry)[EUid] ) );
if ( KErrNotFound != upos || KErrNotFound != error )
{
LOG( " widget needs a new UID" );
LOG_CLOSE;
LOG_OPEN;
do
{
TInt uidInt = 0;
TRAP( error,
uidInt = uidAllocator.AllocateL( iUsedUids,
aDriveUnit.Name()[0] ) );
if ( KErrNone != error )
{
LOG(
"InternalizeEntryNewUidIfNeeded done error failed to allocate a new UID" );
return KErrNotFound;
}
TUid uid = TUid::Uid( uidInt );
error = iAppArch.GetAppInfo( appInfo, uid );
if ( KErrNotFound == error )
{
// use new uid (do icon mbm file rename elsewhere) and
// don't add it to iUsedUids yet as that will be done
// when entry is finally inserted in registry
(*aEntry)[EUid] = uidInt;
LOG2(
"InternalizeEntryNewUidIfNeeded done new uid is 0x%x (%d)", uidInt, uidInt );
return KErrNone;
}
else if ( KErrNone == error )
{
// don't allocate this uid because AppArch thinks it
// is in use
error = iUsedUids.Append( uid );
}
} while ( KErrNone == error );
LOG(
"InternalizeEntryNewUidIfNeeded done error failed to allocate a new UID" );
return KErrNotFound;
}
LOG( "InternalizeEntryNewUidIfNeeded done widget already has a unique ID" ); LOG_CLOSE;
LOG_OPEN;
return KErrNone;
}
// this examines the installed widget list after the persistent
// registry entries have been processed for any installed widgets that
// don't yet have a registry entry. An entry is generated and the
// widget is registered with app arch.
void CWidgetRegistry::InstallDirConsistency(
const CDir* aInstalledListForDrive,
RArray<TInt>& aInstalledListForDriveFlags,
TBool& aDirtyFlag )
{
LOG( "InstallDirConsistency" );
if ( NULL == aInstalledListForDrive
|| ( ( NULL != aInstalledListForDrive)
&& ( 0 == aInstalledListForDrive->Count() ) ) )
{
LOG( " nothing is installed" );
return;
}
TInt error = KErrNone;
TUidAllocator uidAllocator;
for ( TInt i = 0; i < aInstalledListForDrive->Count(); i++ )
{
if ( !( aInstalledListForDriveFlags[i] & EInstallListFlagEntry ) )
{
TFileName widgetPath( iWidgetInstallPath );
widgetPath.Append( (*aInstalledListForDrive)[i].iName );
widgetPath.Append( _L("\\") );
// assume directory under this is widget top-level dir
CDir *listing = NULL;
error = iFs.GetDir( widgetPath,
KEntryAttDir | KEntryAttMatchExclusive,
ESortNone,
listing );
if ( ( KErrNone != error )
|| ( 1 != listing->Count() ) )
{
// skip this widget
LOG( " rejecting a directory that has unexpected contents" );
delete listing;
continue;
}
LOG( " found inconsistency" );
widgetPath.Append( ((*listing)[0]).iName );
widgetPath.Append( _L("\\") );
delete listing;
TInt uidInt = 0;
TRAP( error, uidInt =
uidAllocator.AllocateL( iUsedUids,
iWidgetInstallPath[0] ) );
if ( KErrNone != error )
{
LOG1( " uid allocate error %d", error );
continue; // skip this widget
}
LOG( " getting properties from installed widget" );
LOG_CLOSE;
LOG_OPEN;
RPointerArray<CWidgetPropertyValue>* tmp;
TRAP( error,
tmp =
iInstaller->WidgetPropertiesFromInstalledWidgetL(
iFs, widgetPath, iLprojName, TUid::Uid( uidInt ) ) );
if ( KErrNone != error || !tmp )
{
LOG1( " props from installed widget error %d", error );
continue; // skip this widget
}
LOG( " got properties from installed widget" );
// transfer ownership of tmp
CWidgetEntry* entry = NULL;
TRAP( error, entry = CWidgetEntry::NewL( &tmp ) );
if ( KErrNone != error )
{
LOG1( " new entry copy ctor error %d", error );
if ( tmp )
{
tmp->ResetAndDestroy();
}
continue; // skip this widget
}
// app arch may have this widget under another uid
// but if we assign a new uid and register the
// widget then the duplicate app arch entry will
// be removed when app arch list is made
// consistent by removing entries not in the
// registry by uid
// check that uid is unknown to app arch
TDriveUnit driveUnit( widgetPath );
error = InternalizeEntryNewUidIfNeeded( entry, driveUnit );
if ( KErrNone != error )
{
LOG1( " new uid if needed error %d", error );
delete entry;
continue; // skip this widget
}
LOG_CODE( TInt uidLog = (*entry)[EUid] );
LOG1( " uid 0x%x", uidLog );
LOG_CODE( const TDesC& logDes = (*entry)[EMainHTML] );
LOG1( " mainHTML %S", &logDes );
LOG_CODE( const TDesC& logDes2 = (*entry)[EBundleDisplayName] );
LOG1( " bundleDiplayname %S", &logDes2 );
TRAP( error,
iInstaller->RegisterWidgetL(
(*entry)[EMainHTML],
(*entry)[EBundleDisplayName],
(*entry)[EIconPath],
(*entry)[EDriveName],
TUid::Uid( (*entry)[EUid]) ) );
if ( KErrNone == error )
{
LOG2( " registered widget 0x%x (%d)",
uidLog, uidLog );
TRAP( error,
InsertL( entry ) );
if ( KErrNone != error )
{
LOG1( " insert entry error %d", error );
delete entry;
continue; // skip this widget
}
LOG2( " entry 0x%x (%d) added to registry",
uidLog, uidLog );
LOG( "registry dirty flag set" );
aDirtyFlag = ETrue;
}
else
{
// allocated uid hasn't been added to iUsedUid yet so
// just delete entry
delete entry;
LOG( "failed to recover an installed widget" );
continue; // skip this widget
}
}
}
LOG( "InstallDirConsistency done" );
}
void CWidgetRegistry::AppArchListConsistency( const RArray<TUid>& aAppArchList,
RArray<TInt>& aAppArchListFlags )
{
LOG( "AppArchListConsistency" );
RArray<TUid> deRegisterList( KDefaultWidgetCount );
CleanupClosePushL(deRegisterList);
for ( TInt i = 0; i < aAppArchList.Count(); i++ )
{
if ( !( aAppArchListFlags[i] & EAppListFlagEntry ) )
{
LOG_CODE( TInt uidIntLog = aAppArchList[i].iUid );
LOG2( " deregistered widget 0x%x (%d)",
uidIntLog, uidIntLog );
deRegisterList.Append(aAppArchList[i]);
}
}
if(deRegisterList.Count())
{
TRAP_IGNORE( iInstaller->DeregisterWidgetsL( deRegisterList ) );
}
CleanupStack::PopAndDestroy(&deRegisterList);
LOG( "AppArchListConsistency done" );
}
// End of File