/*
* Copyright (c) 2006-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: SConPcdUtility implementation
*
*/
// CLASS HEADER
#include <swi/sisregistryentry.h>
#include <swi/sisregistrysession.h>
#include <swi/sisregistrypackage.h>
#include <stringresourcereader.h>
#include <widgetregistryclient.h>
#include <javaregistryincludes.h>
#include <appversion.h>
#include <mmf/common/mmfcontrollerpluginresolver.h>
#include <sconftp.rsg> // Resource to be read header
using namespace Java;
#include "debug.h"
#include "sconpcdutility.h"
#include "sconconmltask.h"
// localized "unknown vendor".
_LIT( KSConResourceName, "z:\\Resource\\sconftp.rsc" );
// METHODS
//----------------------------------------------------------------------------
// void SConPcdUtility::ProcessListInstalledAppsL( CSConTask*& aTask )
//----------------------------------------------------------------------------
//
void SConPcdUtility::ProcessListInstalledAppsL( CSConTask*& aTask )
{
TRACE_FUNC_ENTRY;
LOGGER_WRITE_1("iAllApps: %d",(TInt)aTask->iListAppsParams->iAllApps);
LOGGER_WRITE8_1("driveList: %S", &aTask->iListAppsParams->iDriveList);
AppendInstalledSisL( *aTask->iListAppsParams );
AppendInstalledJavaL( *aTask->iListAppsParams );
AppendInstalledWidgetsL( *aTask->iListAppsParams );
TRACE_FUNC_EXIT;
}
//----------------------------------------------------------------------------
// void SConPcdUtility::AppendInstalledSisL( RPointerArray<CSConInstApp> &aApps )
// Appends installed sis packages and augmentations to aApps array.
//----------------------------------------------------------------------------
//
void SConPcdUtility::AppendInstalledSisL( CSConListInstApps& aListInstApps )
{
TRACE_FUNC_ENTRY;
// Get installed applications from sis registry
Swi::RSisRegistrySession sisRegistry;
CleanupClosePushL( sisRegistry );
User::LeaveIfError( sisRegistry.Connect() );
RArray<TUid> uids;
CleanupClosePushL(uids);
sisRegistry.InstalledUidsL( uids );
//Read package information
for( TInt i = 0; i < uids.Count(); i++ )
{
Swi::RSisRegistryEntry entry;
CleanupClosePushL(entry);
User::LeaveIfError( entry.Open( sisRegistry, uids[i] ) );
TBool showIt( EFalse );
if ( aListInstApps.iAllApps )
{
// show all apps -param defined, exlude stubs on ROM
if ( !entry.IsInRomL() )
{
showIt = ETrue;
}
}
else
{
// show if installed one of the specified drives
// don't exlude stubs on ROM
showIt = IsInstalledToSelectedDrive( aListInstApps.iDriveList,
entry.InstalledDrivesL() );
}
// Only show if not in rom
if ( showIt && entry.IsPresentL() )
{
// Add the created object to the list
LOGGER_WRITE_1( "SConPcdUtility::ProcessListInstalledAppsL : add pkg, index %d", i );
CSConInstApp* app = new (ELeave) CSConInstApp();
CleanupStack::PushL( app );
HBufC* temp = entry.PackageNameL();
TPtrC tempPtr = temp->Des();
LOGGER_WRITE_1("PackageNameL: %S", &tempPtr);
CleanupStack::PushL( temp );
if ( temp->Length() > app->iName.MaxLength() )
{
User::Leave( KErrTooBig );
}
app->iName.Copy( *temp );
CleanupStack::PopAndDestroy( temp );
temp = NULL;
temp = entry.UniqueVendorNameL();
CleanupStack::PushL( temp );
if ( temp->Length() > app->iVendor.MaxLength() )
{
User::Leave( KErrTooBig );
}
app->iVendor.Copy( *temp );
CleanupStack::PopAndDestroy( temp );
temp = NULL;
app->iVersion.Copy( entry.VersionL().Name() );
app->iType = ESisApplication;
app->iSize = entry.SizeL();
app->iUid = entry.UidL();
User::LeaveIfError( aListInstApps.iApps.Append( app ) );
CleanupStack::Pop( app );
}
// Get possible augmentations
RPointerArray<Swi::CSisRegistryPackage> augPackages;
CleanupResetAndDestroyPushL( augPackages );
entry.AugmentationsL( augPackages );
for ( TInt j( 0 ); j < augPackages.Count(); j++ )
{
Swi::RSisRegistryEntry augmentationEntry;
CleanupClosePushL( augmentationEntry );
augmentationEntry.OpenL( sisRegistry, *augPackages[j] );
TBool showIt( EFalse );
if ( aListInstApps.iAllApps )
{
// show all apps -param defined, exlude stubs on ROM
if ( !augmentationEntry.IsInRomL() )
{
showIt = ETrue;
}
}
else
{
// show if installed one of the specified drives
// don't exlude stubs on ROM
showIt = IsInstalledToSelectedDrive( aListInstApps.iDriveList,
augmentationEntry.InstalledDrivesL() );
}
// Only show if not in rom
if ( showIt && augmentationEntry.IsPresentL() )
{
CSConInstApp* augApp = new (ELeave) CSConInstApp();
CleanupStack::PushL( augApp );
augApp->iName.Copy( augPackages[j]->Name() );
HBufC* temp = entry.PackageNameL();
CleanupStack::PushL( temp );
if ( temp->Length() > augApp->iParentName.MaxLength() )
{
User::Leave( KErrTooBig );
}
augApp->iParentName.Copy( *temp );
CleanupStack::PopAndDestroy( temp );
temp = NULL;
augApp->iVendor.Copy( augPackages[j]->Vendor() );
augApp->iVersion.Copy( augmentationEntry.VersionL().Name() );
augApp->iType = ESisAugmentation;
augApp->iSize = augmentationEntry.SizeL();
augApp->iUid = augmentationEntry.UidL();
LOGGER_WRITE_1( "SConPcdUtility::ProcessListInstalledAppsL : add augmentation, index: %d", j );
LOGGER_WRITE_1( "SConPcdUtility::ProcessListInstalledAppsL : add augmentation, basepkg: %d", i );
TInt augindex = augPackages[j]->Index();
LOGGER_WRITE_1( "SConPcdUtility::ProcessListInstalledAppsL : augindex: %d",augindex );
User::LeaveIfError( aListInstApps.iApps.Append( augApp ) );
CleanupStack::Pop( augApp );
}
CleanupStack::PopAndDestroy( &augmentationEntry );
}
CleanupStack::PopAndDestroy( &augPackages );
CleanupStack::PopAndDestroy( &entry );
}
CleanupStack::PopAndDestroy(&uids);
CleanupStack::PopAndDestroy(&sisRegistry);
TRACE_FUNC_EXIT;
}
//----------------------------------------------------------------------------
// void SConPcdUtility::AppendInstalledJavaL( RPointerArray<CSConInstApp> &aApps )
// Appends installed java packages to aApps array.
//----------------------------------------------------------------------------
//
void SConPcdUtility::AppendInstalledJavaL( CSConListInstApps& aListInstApps )
{
TRACE_FUNC_ENTRY;
CJavaRegistry* javaRegistry = CJavaRegistry::NewLC( );
RArray<TUid> packageUids;
CleanupClosePushL( packageUids );
javaRegistry->GetRegistryEntryUidsL( packageUids );
LOGGER_WRITE_1("packageUids.Count(): %d", packageUids.Count());
for (TInt i=0; i<packageUids.Count(); i++ )
{
LOGGER_WRITE_1("RegistryEntryL: %d",i);
LOGGER_WRITE_1("handle entry uid: 0x%08X",packageUids[i].iUid);
CJavaRegistryEntry* entry = javaRegistry->RegistryEntryL( packageUids[i] );
if ( entry )
{
CleanupStack::PushL( entry );
if ( entry->Type() >= EGeneralPackage && entry->Type() < EGeneralApplication )
{
// entry was correct type
CJavaRegistryPackageEntry* packageEntry = ( CJavaRegistryPackageEntry* ) entry;
// check do we need to filter it out
TBool showIt( EFalse );
if ( aListInstApps.iAllApps )
{
showIt = ETrue;
}
else
{
TDriveNumber drive = packageEntry->Drive();
if ( aListInstApps.iDriveList.Length() > drive
&& aListInstApps.iDriveList[ drive ] )
{
showIt = ETrue;
}
}
if ( showIt )
{
CSConInstApp* app = new (ELeave) CSConInstApp();
CleanupStack::PushL( app );
// Get Uid, name, type, vendor
app->iUid = packageEntry->Uid();
app->iName.Copy ( packageEntry->Name() );
LOGGER_WRITE_1( "Name: %S", &app->iName );
app->iType = EJavaApplication;
// Get version
TAppVersion midletVersion( packageEntry->Version() );
TVersion verType(midletVersion.iMajor, midletVersion.iMinor, midletVersion.iBuild);
app->iVersion.Copy( verType.Name() );
// Get vendor
if ( entry->NumberOfCertificateChains() > 0 && packageEntry->Vendor().Length() > 0 )
{
app->iVendor.Copy( packageEntry->Vendor() );
}
else
{
// untrusted applications do not have certificates.
// if the application has a certificate, it is installed either as
// trusted or not installed at all.
// unknown vendor
TFileName myFileName( KSConResourceName );
CStringResourceReader* resReader = CStringResourceReader::NewL( myFileName );
TPtrC bufUnknownSuplier;
bufUnknownSuplier.Set( resReader->ReadResourceString( R_SECON_UNKNOWN_SUPPLIER ) );
app->iVendor.Copy( bufUnknownSuplier );
delete resReader;
}
// Get size
app->iSize = packageEntry->UsedUserDiskSpace();
User::LeaveIfError( aListInstApps.iApps.Append( app ) );
CleanupStack::Pop( app );
}
}
CleanupStack::PopAndDestroy( entry );
}
}
CleanupStack::PopAndDestroy( &packageUids );
CleanupStack::PopAndDestroy( javaRegistry );
TRACE_FUNC_EXIT;
}
//----------------------------------------------------------------------------
// void SConPcdUtility::AppendInstalledWidgetsL( RPointerArray<CSConInstApp> &aApps )
// Appends installed widgets to aApps array.
//----------------------------------------------------------------------------
//
void SConPcdUtility::AppendInstalledWidgetsL( CSConListInstApps& aListInstApps )
{
TRACE_FUNC_ENTRY;
RWidgetRegistryClientSession widgetSession;
CleanupClosePushL( widgetSession );
User::LeaveIfError( widgetSession.Connect() );
// Get the list of installed widgets
RWidgetInfoArray widgetInfoArr;
CleanupClosePushL( widgetInfoArr );
widgetSession.InstalledWidgetsL( widgetInfoArr );
TFileName bundleId;
for ( TInt i = 0; i < widgetInfoArr.Count(); i++ )
{
CWidgetInfo *item = widgetInfoArr[i];
CleanupStack::PushL( item );
TBool showIt( EFalse );
if ( aListInstApps.iAllApps )
{
// show all apps -param defined
showIt = ETrue;
}
else
{
TDriveUnit locationDrive = item->iDriveName->Des();
// show if installed one of the specified drives
if ( aListInstApps.iDriveList.Length() > locationDrive
&& aListInstApps.iDriveList[locationDrive] )
{
showIt = ETrue;
}
}
if ( showIt )
{
CSConInstApp* app = new (ELeave) CSConInstApp();
CleanupStack::PushL( app );
app->iName.Copy( *(item->iBundleName) );
app->iType = EWidgetApplication;
app->iSize = item->iFileSize;
app->iUid = item->iUid;
CWidgetPropertyValue* propValue = widgetSession.GetWidgetPropertyValueL(
item->iUid, EBundleVersion );
if ( propValue && propValue->iType == EWidgetPropTypeString )
{
app->iVersion.Copy( *(propValue->iValue.s) );
}
delete propValue;
propValue = NULL;
bundleId.Zero();
widgetSession.GetWidgetBundleId( item->iUid, bundleId );
app->iWidgetBundleId = bundleId.AllocL();
User::LeaveIfError( aListInstApps.iApps.Append( app ) );
CleanupStack::Pop( app ); // ownership transferred, do not delete
}
CleanupStack::PopAndDestroy( item );
}
User::LeaveIfError( widgetSession.Disconnect() );
CleanupStack::PopAndDestroy( &widgetInfoArr );
CleanupStack::PopAndDestroy( &widgetSession );
TRACE_FUNC_EXIT;
}
// ---------------------------------------------------------
// SConPcdUtility::IsInstalledToSelectedDrive
// Solve highest drive from aInstalledDrives and check
// if that drive is selected
// ---------------------------------------------------------
//
TBool SConPcdUtility::IsInstalledToSelectedDrive( const TDriveList& aSelectedDriveList, TUint aInstalledDrives )
{
TInt locationDrive;
if( aInstalledDrives )
{
// Select the highest drive as location drive
TInt drive = EDriveA;
while( aInstalledDrives >>= 1 )
{
drive++;
}
locationDrive = drive;
}
else
{
// No installed files, select C: as location drive
locationDrive = EDriveC;
}
if ( aSelectedDriveList.Length() > locationDrive && aSelectedDriveList[locationDrive] )
{
LOGGER_WRITE("SConPcdUtility::IsInstalledToSelectedDrive : return ETrue");
return ETrue;
}
else
{
LOGGER_WRITE("SConPcdUtility::IsInstalledToSelectedDrive : return EFalse");
return EFalse;
}
}
// END OF FILE