1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Definition of CNcdInstallationService

    15 *

    16 */

    17  

    18 

    19 #include "ncdinstallationserviceimpl.h"

    20 

    21 #include <DocumentHandler.h>

    22 #include <apmstd.h>

    23 #include <apmrec.h>

    24 #include <bautils.h>

    25 

    26 #include <swi/sisregistrypackage.h>

    27 #include <caf/caf.h>

    28 #include <caf/supplier.h> 

    29 #include <caf/importfile.h>

    30 #include <Oma2Agent.h>

    31 #include <s32file.h>

    32 #include <e32property.h>

    33 #include <sacls.h>

    34 

    35 #ifdef USE_OLD_JAVA_API

    36     #include <mjavaregistry.h>

    37     #include <swi/minstalledappsregistry.h>

    38 #else

    39     #include <javaregistry.h>

    40     #include <javaregistrypackageentry.h>

    41 

    42     using namespace Java;

    43 #endif

    44 

    45 #include "ncdinstallationserviceobserver.h"

    46 #include "ncdactiveoperationobserver.h"

    47 #include "ncdsilentinstallactiveobserver.h"

    48 #include "ncderrors.h"

    49 #include "catalogsutils.h"

    50 #include "catalogsconstants.h"

    51 #include "catalogsdebug.h"

    52 

    53 _LIT( KJadFileExtension, ".jad" );

    54 const TInt KDelayWhenAppListInvalid = 500000;

    55 

    56 const TUint KFileOpenFlags = EFileShareReadersOrWriters;

    57 

    58 #ifdef __SERIES60_31__

    59 

    60     const TInt32 KPSUidJavaLatestInstallation = KUidJmiLatestInstallation;

    61 

    62 #else

    63 

    64     // Defined originally in /mw/java/inc/javauids.h

    65     // This should become available at some point in javadomainpskeys.h

    66     //const TInt32 KPSUidJavaLatestInstallation = 0x10282567;

    67     #include <javadomainpskeys.h>

    68 

    69 #endif

    70 

    71 // length taken from WidgetRegistryData.h

    72 const TInt KWidgetBundleIdLength = KWidgetRegistryVal + 1;    

    73 

    74 _LIT( KWidgetExtension, ".wgz" );

    75 

    76 // ======== CALLBACK FUNCTION ========

    77  

    78 static TInt InstallationCompleteCallback( TAny* aData )

    79     {

    80     DLTRACEIN((""));

    81     TRAPD( err,

    82         {

    83         CNcdInstallationService* service = 

    84             reinterpret_cast<CNcdInstallationService*>( aData );

    85         DASSERT( service );

    86         service->NotifyObserverL();

    87         } );

    88         

    89     DLTRACEOUT((""));

    90     return err;

    91     }

    92 

    93 

    94 // ======== MEMBER FUNCTIONS ========

    95 

    96 // ---------------------------------------------------------------------------

    97 // Constructor.

    98 // ---------------------------------------------------------------------------

    99 //

   100 CNcdInstallationService* CNcdInstallationService::NewL()

   101     {

   102     CNcdInstallationService* self = NewLC();

   103     CleanupStack::Pop();

   104     return self;

   105     }

   106     

   107 // ---------------------------------------------------------------------------

   108 // Constructor.

   109 // ---------------------------------------------------------------------------

   110 //

   111 CNcdInstallationService* CNcdInstallationService::NewLC()

   112     {

   113     CNcdInstallationService* self =

   114         new (ELeave) CNcdInstallationService();

   115     CleanupStack::PushL( self );

   116     self->ConstructL();

   117     return self;

   118     }

   119     

   120 // ---------------------------------------------------------------------------

   121 // Destructor.

   122 // ---------------------------------------------------------------------------

   123 //

   124 CNcdInstallationService::~CNcdInstallationService()

   125     {

   126     DLTRACEIN((""));

   127     delete iSilentInstallActiveObserver;

   128     iSilentInstallActiveObserver = NULL;

   129     delete iDocHandler;

   130     iRegistrySession.Close();

   131     iFs.Close();

   132     iAknsSrv.Close();

   133     delete iInstallationCompleteCallback;

   134     delete iJadFileName;

   135     delete iRecognizedMime;

   136 #ifdef USE_OLD_JAVA_API    

   137     iMIDletUids.Close();

   138 #endif    

   139     iApaLs.Close();

   140     if( iThemes )

   141         {

   142         iThemes->ResetAndDestroy();

   143         delete iThemes;        

   144         }

   145     

   146     // Deletes iInstallStatusObserver and closes iInstaller

   147     CancelInstall(); 

   148     iRomUids.Close();

   149     

   150     if ( iWidgetRegistry.Handle() )

   151         {

   152         // decreases widget server's refcount but this cannot be called

   153         // if Connect has not been called or we'll get a KERN-EXEC 0

   154         iWidgetRegistry.Disconnect();

   155         }

   156     else

   157         {

   158         iWidgetRegistry.Close();

   159         }

   160     iInstalledWidgets.ResetAndDestroy();

   161     }

   162 

   163 // ---------------------------------------------------------------------------

   164 // Constructor.

   165 // ---------------------------------------------------------------------------

   166 //

   167 CNcdInstallationService::CNcdInstallationService()

   168     {

   169     }

   170     

   171 // ---------------------------------------------------------------------------

   172 // Constructor.

   173 // ---------------------------------------------------------------------------

   174 //

   175 void CNcdInstallationService::ConstructL()

   176     {

   177     DLTRACEIN((""));

   178     iDocHandler = CDocumentHandler::NewL();

   179     iDocHandler->SetExitObserver( this );

   180     

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

   182     User::LeaveIfError( iFs.ShareProtected() );

   183     User::LeaveIfError( iRegistrySession.Connect() );

   184     User::LeaveIfError( iAknsSrv.Connect() ); 

   185 

   186     iInstallationCompleteCallback = new(ELeave) CAsyncCallBack( 

   187         TCallBack( InstallationCompleteCallback, this ),

   188         CActive::EPriorityStandard );  

   189               

   190     InitializeRomApplicationListL();

   191     }

   192 

   193 

   194 // ---------------------------------------------------------------------------

   195 // Installs all kinds of files.

   196 // ---------------------------------------------------------------------------

   197 //

   198 void CNcdInstallationService::InstallL( const TDesC& aFileName,

   199                                         const TDesC& aMimeType,

   200                                         const TNcdItemPurpose& aPurpose )

   201     {

   202     DLTRACEIN((""));

   203     RFile file;

   204     CleanupClosePushL( file );

   205     User::LeaveIfError( file.Open( FileServerSession(), aFileName, KFileOpenFlags ) ); 

   206     InstallL( file, aMimeType, aPurpose, NULL );

   207     CleanupStack::PopAndDestroy( &file );

   208     DLTRACEOUT((""));        

   209     }

   210 

   211 // ---------------------------------------------------------------------------

   212 // Installs all kinds of files.

   213 // ---------------------------------------------------------------------------

   214 //

   215 void CNcdInstallationService::InstallL( RFile& aFile,

   216                                         const TDesC& aMimeType,

   217                                         const TNcdItemPurpose& aPurpose )

   218     {

   219     DLTRACEIN((""));

   220     InstallL( aFile, aMimeType, aPurpose, NULL );

   221     DLTRACEOUT((""));        

   222     }

   223 

   224 

   225 // ---------------------------------------------------------------------------

   226 // Installs java files.

   227 // ---------------------------------------------------------------------------

   228 //

   229 void CNcdInstallationService::InstallJavaL( const TDesC& aFileName,

   230                                             const TDesC& aMimeType,

   231                                             const TDesC8& aDescriptorData )

   232     {

   233     DLTRACEIN((""));

   234     RFile file;

   235     CleanupClosePushL( file );

   236     User::LeaveIfError( file.Open( FileServerSession(), aFileName, KFileOpenFlags ) );     

   237     InstallJavaL( file, aMimeType, aDescriptorData, NULL );

   238     CleanupStack::PopAndDestroy( &file );

   239     DLTRACEOUT((""));

   240     }

   241 

   242 // ---------------------------------------------------------------------------

   243 // Installs java files.

   244 // ---------------------------------------------------------------------------

   245 //

   246 void CNcdInstallationService::InstallJavaL( RFile& aFile,

   247                                             const TDesC& aMimeType,

   248                                             const TDesC8& aDescriptorData )

   249     {

   250     DLTRACEIN((""));    

   251     InstallJavaL( aFile, aMimeType, aDescriptorData, NULL );    

   252     DLTRACEOUT((""));

   253     }

   254 

   255 

   256 // ---------------------------------------------------------------------------

   257 // Installs all kinds of files silently.

   258 // ---------------------------------------------------------------------------

   259 //

   260 void CNcdInstallationService::SilentInstallL( RFile& aFile,

   261                                         const TDesC& aMimeType,

   262                                         const TNcdItemPurpose& aPurpose,

   263                                         const SwiUI::TInstallOptionsPckg& aInstallOptionsPckg )

   264     {

   265     DLTRACEIN((""));

   266 

   267     if ( iSilentInstallActiveObserver == NULL )

   268         {

   269         DLINFO(("Create active observer for silent install"));

   270         iSilentInstallActiveObserver = CNcdSilentInstallActiveObserver::NewL( *this );        

   271         }

   272 

   273     InstallL( aFile, aMimeType, aPurpose, &aInstallOptionsPckg );

   274 

   275     DLTRACEOUT(("")); 

   276     }

   277 

   278 

   279 // ---------------------------------------------------------------------------

   280 // Installs java files silently.

   281 // ---------------------------------------------------------------------------

   282 //

   283 void CNcdInstallationService::SilentInstallJavaL( RFile& aFile,

   284                                             const TDesC& aMimeType,

   285                                             const TDesC8& aDescriptorData,

   286                                             const SwiUI::TInstallOptionsPckg& aInstallOptionsPckg )

   287     {

   288     DLTRACEIN((""));

   289 

   290     if ( iSilentInstallActiveObserver == NULL )

   291         {

   292         DLINFO(("Create active observer for silent install"));

   293         iSilentInstallActiveObserver = CNcdSilentInstallActiveObserver::NewL( *this );        

   294         }

   295 

   296     InstallJavaL( aFile, aMimeType, aDescriptorData, &aInstallOptionsPckg );

   297 

   298     DLTRACEOUT((""));

   299     }

   300 

   301 

   302 // ---------------------------------------------------------------------------

   303 // Cancell silent install.

   304 // ---------------------------------------------------------------------------

   305 //

   306 void CNcdInstallationService::CancelSilentInstall( HBufC*& aFileName,

   307                                                    TUid& aAppUid,

   308                                                    TInt& aError )

   309     {

   310     DLTRACEIN((""));

   311     

   312     // Silent install can only be cancelled if silent is allowed.

   313     // The capability check makes sure of this.

   314 

   315     // Set intial values for the reference parameters.

   316     delete aFileName;

   317     aFileName = NULL;

   318     aAppUid = KNullUid;

   319     aError = KErrCancel;

   320     

   321     if ( iBusy )

   322         {

   323         DLINFO(("Install operation was busy"));

   324         

   325         // Some operation is on. Here we expect that it is silent.

   326         // Inform the installer that the asynchronous silent install request 

   327         // needs to be cancelled. 

   328         // Because we use a dummy active object to observe

   329         // completion of installation and that dummy object uses call backs

   330         // to inform completion to observer, we have to cancel the operation

   331         // by using the dummy object here.

   332         aError = iSilentInstallActiveObserver->CancelAsyncOperation();

   333 

   334         if ( aError == KErrNone )

   335             {

   336             DLINFO(("Installation was success even if cancel was issued."))

   337             

   338             // The installation was finished after all.

   339             TRAPD( trapError, 

   340                    HandleSilentInstallSuccessAfterCancelL( aFileName,

   341                                                            aAppUid,

   342                                                            aError ) );

   343             if ( trapError != KErrNone )

   344                 {

   345                 DLERROR(("Install success handling leave."));

   346                 aError = trapError;

   347                 }

   348             }

   349 

   350         // Do cleaning if necessary.

   351         if( iJadFileName != NULL )

   352             {

   353             // Delete tmp JAD file that was created in the beginning of

   354             // the install operation. It will be recreated in new install operation

   355             // if needed.

   356             BaflUtils::DeleteFile( iFs, *iJadFileName ); // NOTE, error ignored

   357             delete iJadFileName;

   358             iJadFileName = NULL;

   359             }

   360         

   361 #ifdef USE_OLD_JAVA_API        

   362         // Clean the array.

   363         iMIDletUids.Reset();

   364 #endif        

   365 

   366         // Reset information flags.            

   367         InstallationFinishedSetup( aError );

   368         }

   369     }

   370 

   371 

   372 // ---------------------------------------------------------------------------

   373 // Sets observer for installation services.

   374 // ---------------------------------------------------------------------------

   375 //

   376 void CNcdInstallationService::SetObserver(

   377                             MNcdInstallationServiceObserver& aObserver )

   378     {

   379     iObserver = &aObserver;

   380     }

   381 

   382 

   383 // ---------------------------------------------------------------------------

   384 // Gets version of installed application by using its UID.

   385 // ---------------------------------------------------------------------------

   386 //

   387 TInt CNcdInstallationService::ApplicationVersion( const TUid& aUid,

   388                                                   TCatalogsVersion& aVersion )

   389     {

   390     DLTRACEIN(("Uid=%X",aUid.iUid));

   391 

   392     // First case: see if the uid is directly in the sis registry.

   393     Swi::RSisRegistryEntry entry;

   394     

   395     TVersion version;

   396     TRAPD( err, 

   397         {

   398         SisRegistryEntryLC( entry, aUid );         

   399         // Get version number

   400         version = entry.VersionL();

   401         CleanupStack::PopAndDestroy( &entry );

   402         });

   403 

   404     if ( err != KErrNone ) 

   405         {

   406         DLTRACEOUT(("Error: %d", err));

   407         return err;

   408         }

   409         

   410     aVersion.iMajor = version.iMajor;

   411     aVersion.iMinor = version.iMinor;

   412     aVersion.iBuild = version.iBuild;        

   413 

   414     DLTRACEOUT(("err=%d",err));

   415     return err;

   416     }

   417 

   418 // ---------------------------------------------------------------------------

   419 // Checks whether an application is installed on the device.

   420 // ---------------------------------------------------------------------------

   421 //

   422 TBool CNcdInstallationService::IsApplicationInstalledL( const TUid& aUid )

   423     {

   424     DLTRACEIN(("uid=%X",aUid.iUid));

   425     TBool result = EFalse;

   426     

   427     Swi::RSisRegistryEntry entry;

   428     

   429     // First case: See if the UID is directly in the SIS Registry.

   430     TRAPD( err, 

   431         {

   432         SisRegistryEntryLC( entry, aUid ); 

   433         

   434         DLTRACE(("Check that entry is present"));

   435         result = entry.IsPresentL();

   436         CleanupStack::PopAndDestroy( &entry );

   437         });

   438         

   439     LeaveIfNotErrorL( err, KErrNotFound );    

   440 

   441     // Third case: see if the UID is mapped to the Java Registry or is a Widget

   442     if ( !result )

   443         {

   444         result = ( JavaAppExistsL( aUid ) || 

   445                    WidgetExistsL( aUid ) );

   446         }

   447     

   448     

   449     // Check if the app is ROM only

   450     if ( !result ) 

   451         {

   452         result = IsRomApplication( aUid );

   453         }

   454     DLTRACEOUT(("result=%d",result));

   455     return result;

   456     }

   457 

   458 // ---------------------------------------------------------------------------

   459 // Opens SIS registry entry

   460 // ---------------------------------------------------------------------------

   461 //

   462 void CNcdInstallationService::SisRegistryEntryLC( 

   463     Swi::RSisRegistryEntry& aEntry,

   464     const TUid& aUid )

   465     {

   466     DLTRACEIN((""));    

   467     CleanupClosePushL( aEntry );

   468     

   469     if ( aEntry.Open( iRegistrySession, aUid ) == KErrNone )

   470         {

   471         DLTRACEOUT(("Entry opened"));

   472         return;

   473         }

   474         

   475     // Second case: See if the UID is mapped to a package/entry

   476     // in the registry ( -> APP UID that differs from SIS UID ).

   477 

   478     Swi::CSisRegistryPackage* sisRegistryPackage =

   479         iRegistrySession.SidToPackageL( aUid );

   480     CleanupStack::PushL( sisRegistryPackage );

   481 

   482     TInt err = aEntry.OpenL( iRegistrySession, *sisRegistryPackage );

   483     User::LeaveIfError( err );

   484         

   485     CleanupStack::PopAndDestroy( sisRegistryPackage );

   486     

   487     DLTRACEOUT(("Entry opened"));    

   488     }

   489 

   490 

   491 // ---------------------------------------------------------------------------

   492 // Open java suite entry

   493 //

   494 // ---------------------------------------------------------------------------

   495 //

   496 #ifdef USE_OLD_JAVA_API

   497 

   498 TBool CNcdInstallationService::JavaAppExistsL( 

   499     const TUid& aUid )

   500     {

   501     DLTRACEIN((""));

   502 

   503     MJavaRegistry* javaRegistry = MJavaRegistry::CreateL();

   504     CleanupReleasePushL( *javaRegistry );

   505     

   506     TRAPD( err, 

   507         {

   508         // Leaves with KErrNotFound if not found

   509         MJavaRegistryMIDletEntry* midletEntry = javaRegistry->MIDletEntryL(

   510             aUid );    

   511         midletEntry->Release();

   512         });

   513     

   514     LeaveIfNotErrorL( err, KErrNotFound );

   515     

   516     CleanupStack::PopAndDestroy( javaRegistry );

   517     return err == KErrNone;

   518     }

   519 

   520 #else

   521 

   522 TBool CNcdInstallationService::JavaAppExistsL( 

   523     const TUid& aUid )

   524     {

   525     DLTRACEIN((""));

   526 

   527     CJavaRegistry* javaRegistry = CJavaRegistry::NewLC();    

   528 

   529     TBool exists = javaRegistry->RegistryEntryExistsL( aUid );

   530     

   531     CleanupStack::PopAndDestroy( javaRegistry );

   532     return exists;

   533     }

   534 

   535 #endif

   536     

   537 // ---------------------------------------------------------------------------

   538 // Checks the application status

   539 // ---------------------------------------------------------------------------

   540 //

   541 TNcdApplicationStatus CNcdInstallationService::IsApplicationInstalledL( 

   542     const TUid& aUid, const TCatalogsVersion& aVersion )

   543     {

   544     DLTRACEIN((""));

   545 

   546     TNcdApplicationStatus status( ENcdApplicationNotInstalled );

   547     

   548     if ( aUid == TUid::Null() ) 

   549         {

   550         DLTRACEOUT(("Null uid"));

   551         return status;

   552         }

   553 

   554 

   555     Swi::RSisRegistryEntry entry;    

   556     TCatalogsVersion installedVersion;

   557     

   558     // Get SIS-app version

   559     TRAPD( err, 

   560         {

   561         SisRegistryEntryLC( entry, aUid ); 

   562         

   563         DLTRACE(("Check that entry is present"));

   564         

   565         if ( entry.IsPresentL() ) 

   566             {

   567             DLTRACE(("Is present"));

   568             status = ENcdApplicationInstalled;

   569             }

   570         

   571         TVersion version = entry.VersionL();

   572         installedVersion = TCatalogsVersion(         

   573             version.iMajor,

   574             version.iMinor,

   575             version.iBuild );

   576 

   577         CleanupStack::PopAndDestroy( &entry );

   578         });

   579         

   580     // SIS app not found, try to get java

   581     if ( err == KErrNotFound &&

   582          ( JavaAppExistsL( aUid ) ||

   583            WidgetExistsL( aUid ) ) )

   584         {

   585         status = ENcdApplicationInstalled;

   586         }

   587         

   588     LeaveIfNotErrorL( err, KErrNotFound );  

   589     

   590     // Some app found, check version numbers if they are something else than 

   591     // 0.0.0

   592     if ( err == KErrNone && 

   593          status == ENcdApplicationInstalled &&

   594          installedVersion != TCatalogsVersion() &&

   595          aVersion != TCatalogsVersion() ) 

   596         {

   597         DLINFO(("Installed version: %d.%d.%d, comparing to: %d.%d.%d",

   598             installedVersion.iMajor,

   599             installedVersion.iMinor,

   600             installedVersion.iBuild,

   601             aVersion.iMajor,

   602             aVersion.iMinor,

   603             aVersion.iBuild ));

   604             

   605         if ( installedVersion > aVersion ) 

   606             {

   607             status = ENcdApplicationNewerVersionInstalled;

   608             }

   609         else if ( !( installedVersion == aVersion ) ) 

   610             {

   611             status = ENcdApplicationOlderVersionInstalled;

   612             }

   613         }

   614     

   615     // Checking if the app is ROM only

   616     if ( status == ENcdApplicationNotInstalled && 

   617          IsRomApplication( aUid ) ) 

   618         {

   619         status = ENcdApplicationInstalled;

   620         }

   621     

   622     DLTRACEOUT(("Status: %d", status));

   623     return status;

   624     }

   625 

   626 

   627 // ---------------------------------------------------------------------------

   628 // Gets the first SID from the SIS registry package

   629 // ---------------------------------------------------------------------------

   630 //

   631 TUid CNcdInstallationService::SidFromSisRegistryL( const TUid& aUid )

   632     {

   633     DLTRACEIN(("uid=%X",aUid.iUid));

   634     Swi::RSisRegistryEntry entry;

   635     TUid sid( KNullUid );

   636     

   637     User::LeaveIfError( entry.Open( iRegistrySession, aUid ) );

   638     CleanupClosePushL( entry );

   639 

   640     RArray<TUid> sids;

   641     CleanupClosePushL( sids );

   642     entry.SidsL( sids );

   643         

   644     DLINFO(("sid count=%d",sids.Count()));

   645 

   646     if ( sids.Count() > 0 )

   647         {

   648         sid.iUid = sids[0].iUid;

   649         }

   650     else

   651         {

   652         DLERROR(("No SIDs found"));

   653         User::Leave( KErrNotFound );

   654         }

   655 

   656     CleanupStack::PopAndDestroy( &sids );

   657     CleanupStack::PopAndDestroy( &entry );

   658 

   659     DLTRACEOUT(("uid=%X",sid.iUid));

   660     return sid;

   661     }

   662 

   663 // ---------------------------------------------------------------------------

   664 // Appends rights into the rights database.

   665 // ---------------------------------------------------------------------------

   666 //

   667 void CNcdInstallationService::AppendRightsL(

   668     const TDesC8& aRightsObject,

   669     const TDataType& aMimeType )

   670     {

   671     DLTRACEIN(("MimeType: %S", &aMimeType.Des8() ));

   672     

   673     ContentAccess::CSupplier* supplier = 

   674         ContentAccess::CSupplier::NewLC();

   675     ContentAccess::CMetaDataArray* metaData =

   676         ContentAccess::CMetaDataArray::NewLC();

   677     

   678     DLTRACE(("Creating CImportFile"));

   679     // Indicate what type of content we are importing.

   680     ContentAccess::CImportFile* file = supplier->ImportFileL( aMimeType.Des8(), *metaData );

   681     CleanupStack::PushL( file );

   682     

   683     DLTRACE(("Importing data"));

   684     // Start importing data. This can also be done in parts.

   685     User::LeaveIfError( file->WriteData( aRightsObject ) );

   686     

   687     DLTRACE(("Finished importing"));

   688     // Indicate that we are finished

   689     User::LeaveIfError( file->WriteDataComplete() );

   690     

   691     CleanupStack::PopAndDestroy( file );

   692     CleanupStack::PopAndDestroy( metaData );

   693     CleanupStack::PopAndDestroy( supplier );

   694     DLTRACEOUT((""));

   695     }

   696 

   697 

   698 // ---------------------------------------------------------------------------

   699 // Reads the package uid from a SISX file

   700 // ---------------------------------------------------------------------------

   701 //

   702 TUid CNcdInstallationService::PackageUidFromSisL( RFile& aFile ) const

   703     {

   704     DLTRACEIN((""));

   705     RFileReadStream readStream( aFile );

   706     CleanupClosePushL( readStream );

   707 

   708     // Get Application UID

   709     //

   710     

   711     // NOTE: In 3.0 the SIS file format has changed

   712     // the UID is the third long word ( 32 bits ) of the file.

   713     TInt dummy = readStream.ReadUint32L();

   714     dummy = readStream.ReadUint32L();

   715             

   716     TUid uid( TUid::Uid( readStream.ReadUint32L() ) );

   717     

   718     // this closes the attached file too

   719     CleanupStack::PopAndDestroy( &readStream ); 

   720     DLTRACEOUT(( _L("Uid: %S"), &uid.Name() ));

   721     return uid;

   722     }

   723 

   724 

   725 // ---------------------------------------------------------------------------

   726 // IsThemeInstalled

   727 // ---------------------------------------------------------------------------

   728 //

   729 TBool CNcdInstallationService::IsThemeInstalledL( const TDesC& aThemeName )

   730     {

   731     DLTRACEIN(( _L("Theme: %S"), &aThemeName ));

   732     TInt result = EFalse;

   733 

   734     if ( aThemeName != KNullDesC )

   735         {

   736         RAknsSrvSession skinSrvSession;

   737         User::LeaveIfError( skinSrvSession.Connect() );

   738         CleanupClosePushL( skinSrvSession );

   739 

   740         CArrayPtr<CAknsSrvSkinInformationPkg>* srvArray = NULL;

   741         // Look themes from C: and E: drives

   742         for ( TInt index = 0; index < 2; index++ )

   743             {

   744             //TUint skinLocation = 0;

   745             if ( index == 0 )

   746                 {

   747                 //skinLocation = EAknsSrvPhone;

   748                 srvArray = skinSrvSession.EnumerateSkinPackagesL( EAknsSrvPhone );

   749                 CleanupStack::PushL( srvArray );

   750                 }

   751             else

   752                 {

   753                 //skinLocation = EAknsSrvMMC;

   754                 srvArray = skinSrvSession.EnumerateSkinPackagesL( EAknsSrvMMC );

   755                 CleanupStack::PushL( srvArray );

   756                 }

   757 

   758             while ( srvArray && srvArray->Count() > 0 )

   759                 {

   760                 CAknsSrvSkinInformationPkg* info = srvArray->At( 0 );

   761 

   762                 // If match is found, theme can be set

   763                 if ( info->Name().Compare( aThemeName ) == 0 )

   764                     {

   765                     result = ETrue;

   766                     }

   767         

   768                 delete info;

   769                 srvArray->Delete( 0 );

   770                 }

   771 

   772             CleanupStack::PopAndDestroy( srvArray );

   773 

   774             if ( result )

   775                 {

   776                 break;

   777                 }

   778             }

   779 

   780         CleanupStack::PopAndDestroy();  // skinSrvSession

   781         }

   782     DLTRACEOUT(("Result: %d", result));

   783     return result;

   784     }

   785 

   786 

   787 // ---------------------------------------------------------------------------

   788 // Deletes the given file

   789 // ---------------------------------------------------------------------------

   790 //

   791 TInt CNcdInstallationService::DeleteFile( const TDesC& aFilename )

   792     {

   793     DLTRACEIN(( _L("Filepath: %S"), &aFilename ));

   794     // Ensure that we don't accidentally delete whole directories

   795     // because of empty path

   796     if ( aFilename.Length() ) 

   797         {

   798         return BaflUtils::DeleteFile( iFs, aFilename );

   799         }

   800     return KErrArgument;

   801     }

   802 

   803 

   804 // ---------------------------------------------------------------------------

   805 // File server session getter

   806 // ---------------------------------------------------------------------------

   807 //

   808 RFs& CNcdInstallationService::FileServerSession()

   809     {

   810     return iFs;

   811     }

   812 

   813 

   814 // ---------------------------------------------------------------------------

   815 // JAD writer

   816 // ---------------------------------------------------------------------------

   817 //

   818 HBufC* CNcdInstallationService::WriteJadL( 

   819     const TDesC& aJarFileName, const TDesC8& aJad  )

   820     {

   821     DLTRACEIN(("Writing JAD"));

   822     TParsePtrC jarParse( aJarFileName );

   823     HBufC* jadFileName = HBufC::NewLC( 

   824             aJarFileName.Length() + KJadFileExtension().Length() );

   825     TPtr jadPtr( jadFileName->Des() );

   826     jadPtr.Append( jarParse.DriveAndPath() );

   827     jadPtr.Append( jarParse.Name() );

   828     jadPtr.Append( KJadFileExtension );

   829 

   830     RFile file;

   831     CleanupClosePushL( file );

   832     User::LeaveIfError( file.Replace( iFs, *jadFileName, EFileWrite | EFileShareAny ) );

   833     User::LeaveIfError( file.Write( aJad ) );

   834     DLINFO(( _L("JAD=%S"), jadFileName ));

   835     CleanupStack::PopAndDestroy( &file );

   836     CleanupStack::Pop( jadFileName );

   837     return jadFileName;

   838     }

   839 

   840 

   841 // ---------------------------------------------------------------------------

   842 // Documenthandler getter

   843 // ---------------------------------------------------------------------------

   844 //

   845 CDocumentHandler& CNcdInstallationService::DocumentHandler()

   846     {

   847     return *iDocHandler;

   848     }

   849 

   850 

   851 // ---------------------------------------------------------------------------

   852 // Callback function of MNcdAsyncOperationObserver interface

   853 // This is called when an async operation has finished.

   854 // ---------------------------------------------------------------------------

   855 //

   856 void CNcdInstallationService::AsyncOperationComplete( TInt aError )

   857     {    

   858     DLTRACEIN(("aError: %d", aError));

   859     

   860     iInstaller.Close();

   861     

   862     if ( aError == SwiUI::KSWInstErrUserCancel ) 

   863         {

   864         DLTRACE(("User cancelled, converting error to KErrAbort" ) );

   865         aError = KErrAbort;        

   866         }

   867     

   868     // Handle this like in normal cases.

   869     HandleServerAppExit( aError );

   870     }

   871 

   872 

   873 // ---------------------------------------------------------------------------

   874 // Callback function of MNcdAsyncSilentInstallObserver interface

   875 // This is called when the silent install has finished.

   876 // ---------------------------------------------------------------------------

   877 //

   878 void CNcdInstallationService::AsyncSilentInstallComplete( TInt aError )

   879     {    

   880     DLTRACEIN(("aError: %d", aError));

   881     

   882     // Handle this like in normal cases.

   883     HandleServerAppExit( aError );

   884     }

   885 

   886 

   887 // ---------------------------------------------------------------------------

   888 // This function is called after application installer has finished.

   889 // ---------------------------------------------------------------------------

   890 //

   891 void CNcdInstallationService::NotifyObserverL()

   892     {

   893     DLTRACEIN(("install error: %d", iInstallError ));        

   894     

   895     if ( iInstallType == EWidgetInstall )

   896         {

   897         HandleInstalledWidgetL();

   898         }

   899     else if ( iInstallType == EJavaInstall )

   900         {    

   901         if( iJadFileName )

   902             {

   903             BaflUtils::DeleteFile( iFs, *iJadFileName ); // NOTE, error ignored

   904             delete iJadFileName;

   905             iJadFileName = 0;

   906             }

   907 

   908         if ( iInstallError != KErrNone ) 

   909             {        

   910             DLTRACE(("Notify install error"));

   911 #ifdef USE_OLD_JAVA_API            

   912             iMIDletUids.Reset();

   913 #endif            

   914             iObserver->InstallationCompleteL( KNullDesC, TUid(), iInstallError );       

   915             return; 

   916             }

   917 

   918         TUid midletUid = InstalledMidletUidL();

   919         

   920         DLINFO(("Installed midlet uid=%X", midletUid.iUid ));

   921         

   922         iObserver->InstallationCompleteL( KNullDesC, midletUid, 

   923                                           // Return error if nothing found.

   924                                           midletUid == KNullUid ? KErrNotFound : KErrNone );

   925         }

   926     

   927     else if ( iInstallType == ESisInstall )

   928         {

   929 

   930         if ( iInstallError != KErrNone ) 

   931             {        

   932             DLTRACE(("Notify install error"));

   933             iObserver->InstallationCompleteL( KNullDesC, TUid(), iInstallError );       

   934             return; 

   935             }

   936         

   937         // Get theme name if such was installed

   938         const TDesC& name( LatestThemeL() );

   939                 

   940         // Notify about theme installation

   941         if ( iPackageUid.iUid == KNcdThemeSisUid || name != KNullDesC ) 

   942             {            

   943             DLTRACE(( _L("Notify observer about theme installation, theme: %S"), 

   944                 &name ));

   945             // Ensure that uid is theme uid

   946             iPackageUid.iUid = KNcdThemeSisUid;

   947             

   948             if ( name == KNullDesC && iThemePackageUid.iUid != KNcdThemeSisUid ) 

   949                 {

   950                 DLTRACE(("Checking theme installation status with package uid, %x", 

   951                     iThemePackageUid.iUid ));

   952                 

   953                 TBool themeInstalled = EFalse;

   954                 

   955                 // Check if the theme was indeed successfully installed

   956                 TRAP_IGNORE( themeInstalled = IsApplicationInstalledL( 

   957                     iThemePackageUid ) );

   958                     

   959                 if ( themeInstalled ) 

   960                     {

   961                     DLINFO(("Theme is installed but we didn't get the name"));

   962                         iObserver->InstallationCompleteL( 

   963                             name, 

   964                             iPackageUid,                     

   965                             KNcdThemeReinstalled );                    

   966                     }

   967                 else

   968                     {

   969                     DLINFO(("Theme was not installed"));

   970                     iObserver->InstallationCompleteL( 

   971                         name, 

   972                         iPackageUid,                     

   973                         KErrGeneral );

   974                     

   975                     }

   976                 }

   977             else 

   978                 {

   979                 DLTRACE(("Either theme name was acquired or package uid was theme"));

   980                 iObserver->InstallationCompleteL( 

   981                     name, 

   982                     iPackageUid, 

   983                     // Consider missing theme name as a theme reinstallation

   984                     name == KNullDesC ? KNcdThemePossiblyReinstalled : KErrNone );    

   985                 }

   986             }

   987         else 

   988             {            

   989             

   990             // Get the actual app UID from sis registry

   991             TRAPD( err, iAppUid = SidFromSisRegistryL( iPackageUid ) );

   992             

   993             DLTRACE(("Notify observer about application installation, uid: %x", 

   994                 iAppUid.iUid ));

   995             

   996             if ( err == KErrNotFound ) 

   997                 {

   998                 DLTRACE(("Didn't get SID, using package UID: %x", 

   999                     iPackageUid.iUid));

  1000                 iAppUid.iUid = iPackageUid.iUid;

  1001                 err = KErrNone;

  1002                 }

  1003             

  1004             if ( err == KErrNone ) 

  1005                 {

  1006                 DLTRACE(("Check the application is actually installed"));          

  1007                 TBool installed = EFalse;      

  1008                 TRAP( err, installed = IsApplicationInstalledL( iAppUid ) );

  1009                 if ( err == KErrNone )

  1010                     {                    

  1011                     if ( !installed ) 

  1012                         {                        

  1013                         err = KErrGeneral;

  1014                         }

  1015                     else

  1016                         {

  1017                         TCatalogsVersion version;

  1018                         err = ApplicationVersion( iAppUid, version );

  1019                         if ( err == KErrNone ) 

  1020                             {

  1021                             DLTRACE(("Converting version to string"));

  1022                             // Put application version as the filename

  1023                             HBufC* versionString = 

  1024                                 TCatalogsVersion::ConvertLC( version );

  1025                             // Notify about application installation

  1026                             iObserver->InstallationCompleteL( 

  1027                                 *versionString, 

  1028                                 iAppUid, 

  1029                                 err );

  1030                             CleanupStack::PopAndDestroy( versionString );

  1031                             return;

  1032                             }

  1033                         }

  1034                     }

  1035                 

  1036                 }

  1037 

  1038             // Notify about application installation

  1039             iObserver->InstallationCompleteL( KNullDesC, iAppUid, err );

  1040             }

  1041         }

  1042     else 

  1043         {

  1044         DLTRACE(("Was not Java nor SIS install"));

  1045         // This is executed after a content file has been moved.

  1046         // We don't set the exit observer as NULL since it panics in debug builds

  1047         }

  1048     DLTRACEOUT((""));

  1049     }

  1050 

  1051     

  1052 // ---------------------------------------------------------------------------

  1053 // This function is called after application installer has finished.

  1054 // ---------------------------------------------------------------------------

  1055 //

  1056 void CNcdInstallationService::HandleServerAppExit( TInt aReason )

  1057     {    

  1058     DLTRACEIN(("aReason=%d",aReason));

  1059 

  1060     InstallationFinishedSetup( aReason );

  1061 

  1062     // If observer exists, notify it.

  1063     iInstallationCompleteCallback->CallBack();

  1064     }

  1065 

  1066 

  1067 // ---------------------------------------------------------------------------

  1068 // Update the list of installed themes

  1069 // ---------------------------------------------------------------------------

  1070 //

  1071 void CNcdInstallationService::UpdateInstalledThemesL()

  1072     {

  1073     DLTRACEIN((""));

  1074     if ( iThemes ) 

  1075         {

  1076         DLTRACE(("Delete old list"));

  1077         iThemes->ResetAndDestroy();

  1078         delete iThemes;

  1079         iThemes = NULL;        

  1080         }

  1081         

  1082     iThemes = iAknsSrv.EnumerateSkinPackagesL( EAknsSrvAll );

  1083 

  1084     DLTRACEOUT(("Got new theme list"));

  1085     }

  1086 

  1087 

  1088 // ---------------------------------------------------------------------------

  1089 // Get name of the theme installed after the latest UpdateInstalledThemesL() 

  1090 // call

  1091 // ---------------------------------------------------------------------------

  1092 //

  1093 const TDesC& CNcdInstallationService::LatestThemeL()

  1094     {  

  1095     DLTRACEIN((""));  

  1096     

  1097     if ( !iThemes ) 

  1098         {

  1099         DLTRACEOUT(("Was not installing a theme"));

  1100         return KNullDesC();

  1101         }

  1102         

  1103     CArrayPtr<CAknsSrvSkinInformationPkg>* newThemes = 

  1104         iAknsSrv.EnumerateSkinPackagesL( EAknsSrvAll );

  1105 

  1106 #ifdef CATALOGS_BUILD_CONFIG_DEBUG

  1107     DLTRACE(("Installed old themes, count: %d", iThemes->Count() ));

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

  1109         {

  1110         DLINFO(( _L("%S"), &iThemes->At( i )->Name() ));

  1111         }

  1112 

  1113     DLTRACE(("Installed new themes, count: %d", newThemes->Count() ));

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

  1115         {

  1116         DLINFO(( _L("%S"), &newThemes->At( i )->Name() ));

  1117         }            

  1118 #endif         

  1119 

  1120     // Empty previous information

  1121     delete iThemeName;

  1122     iThemeName = NULL;

  1123     iPID.Set( TUid::Uid( 0 ) );

  1124    

  1125     // Check if new theme has been installed after last

  1126     // call to the GetInstalledSkinPackagesL()

  1127     if ( newThemes->Count() > iThemes->Count() )

  1128         {

  1129         DLTRACE(("New themes installed, count: %d", 

  1130             newThemes->Count() - iThemes->Count() ));

  1131             

  1132         // New theme has been installed

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

  1134             {