1 /*

     2 * Copyright (c) 2006 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:  

    15 *

    16 */

    17 

    18 

    19 #include "ncdinstalloperationimpl.h"

    20 

    21 #include <s32mem.h>

    22 #include <f32file.h>

    23 #include <bautils.h>

    24 

    25 #include "catalogsbasemessage.h"

    26 #include "ncdnodemanager.h"

    27 #include "ncdnodeimpl.h"

    28 #include "ncdnodeidentifier.h"

    29 #include "catalogsutils.h"

    30 #include "catalogscontext.h"

    31 #include "ncdproviderdefines.h"

    32 #include "ncdnodeclassids.h"

    33 #include "catalogsconstants.h"

    34 #include "ncdinstallinfo.h"

    35 #include "ncdfileinfo.h"

    36 #include "ncdpurchasehistorydbimpl.h"

    37 #include "ncdutils.h"

    38 #include "ncderrors.h"

    39 #include "ncdoperationremovehandler.h"

    40 #include "ncdnodeinstallimpl.h"

    41 #include "ncdnodedownloadimpl.h"

    42 #include "ncdnodecontentinfoimpl.h"

    43 #include "ncdnodemetadataimpl.h"

    44 #include "ncdnodelink.h"

    45 #include "ncdproviderutils.h"

    46 #include "ncdpurchasehistoryutils.h"

    47 #include "ncdinstallreportobserver.h"

    48 #include "catalogsaccesspointmanager.h"

    49 #include "catalogsconnectionmethod.h"

    50 #include "catalogshttpconnectionmanager.h"

    51 #include "ncdgeneralmanager.h"

    52 

    53 #include "catalogsdebug.h"

    54 

    55 // ======== MEMBER FUNCTIONS ========

    56 

    57 // ---------------------------------------------------------------------------

    58 // NewL

    59 // ---------------------------------------------------------------------------

    60 //

    61 CNcdInstallOperation* CNcdInstallOperation::NewL(

    62     MNcdOperationRemoveHandler& aRemoveHandler,

    63     const CNcdNodeIdentifier& aNodeId,

    64     CNcdGeneralManager& aGeneralManager,

    65     MCatalogsHttpSession& aHttpSession,

    66     MNcdInstallReportObserver& aReportObserver,

    67     MCatalogsSession& aSession )

    68     {

    69     CNcdInstallOperation* self = new( ELeave ) CNcdInstallOperation( 

    70         aRemoveHandler,

    71         aGeneralManager,

    72         aHttpSession,        

    73         aReportObserver,

    74         aSession );

    75     CleanupClosePushL( *self );

    76     self->ConstructL( aNodeId );

    77 

    78     CleanupStack::Pop();

    79     return self;

    80     }

    81 

    82 

    83 // ---------------------------------------------------------------------------

    84 // Destructor

    85 // ---------------------------------------------------------------------------

    86 //

    87 CNcdInstallOperation::~CNcdInstallOperation()

    88     {

    89     DLTRACEIN((""));

    90     

    91     delete iNodeId;

    92     

    93     // Deletes the JAD from disk and also deletes iJadFile

    94     DeleteJad();

    95     DLTRACEOUT((""));

    96     }

    97 

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

    99 // Node Id getter

   100 // ---------------------------------------------------------------------------

   101 //

   102 const CNcdNodeIdentifier& CNcdInstallOperation::NodeIdentifier() const

   103     {

   104     return *iNodeId;

   105     }

   106 

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

   108 // Cancel

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

   110 //

   111 void CNcdInstallOperation::Cancel() 

   112     {    

   113     DLTRACEIN(( "" ));

   114     

   115     // Nothing to do here. Most of the install operation

   116     // functionality is in proxy side.

   117     

   118     DLTRACEOUT(( "" ));

   119     }

   120 

   121 

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

   123 // Receive message

   124 // ---------------------------------------------------------------------------

   125 //

   126 void CNcdInstallOperation::ReceiveMessage( 

   127         MCatalogsBaseMessage* aMessage,

   128         TInt aFunctionNumber )

   129     {

   130     DLTRACEIN((""));

   131 

   132     DASSERT( aMessage );

   133     

   134     DLINFO(( "Handle: %i, aFunctionNumber=%d",

   135             aMessage->Handle(),

   136             aFunctionNumber));

   137 

   138     // Now, we can be sure that rest of the time iMessage exists.

   139     // This member variable is set for the CounterPartLost function.

   140     iMessage = aMessage;

   141     

   142     TRAPD( err, DoReceiveMessageL( aMessage, aFunctionNumber ) ); 

   143     

   144     if ( err != KErrNone ) 

   145         {

   146         DLINFO(( ( "Error: %d" ), err ));

   147         CompleteMessage( iMessage, 

   148             ENCDOperationMessageCompletionError,

   149             err );

   150         }

   151 

   152     // Because the message should not be used after this, set it NULL.

   153     // So, CounterPartLost function will know that no messages are

   154     // waiting the response at the moment.

   155     iMessage = NULL;

   156 

   157     DLTRACEOUT((""));

   158     }

   159 

   160 

   161 // ---------------------------------------------------------------------------

   162 // Counter part lost

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

   164 //

   165 void CNcdInstallOperation::CounterPartLost( const MCatalogsSession& aSession )

   166     {

   167     DLTRACEIN((""));

   168 

   169     // This function may be called whenever -- when the message is waiting

   170     // response or when the message does not exist.

   171     // iMessage may be NULL here, because in the end of the

   172     // ReceiveMessage it is set to NULL. The life time of the message

   173     // ends shortly after CompleteAndRelease is called.

   174     if ( iMessage != NULL )

   175         {

   176         iMessage->CounterPartLost( aSession );

   177         }    

   178 

   179     DLTRACEOUT((""));    

   180     }

   181 

   182 // ---------------------------------------------------------------------------

   183 // RunOperation

   184 // ---------------------------------------------------------------------------

   185 //

   186 TInt CNcdInstallOperation::RunOperation()

   187     {

   188     DLTRACEIN(( "Pending message: %X", iPendingMessage ));    

   189     

   190    

   191     DLTRACEOUT((""));

   192     return KErrNone;

   193     }

   194 

   195 

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

   197 // Initializer

   198 // ---------------------------------------------------------------------------

   199 //

   200 TInt CNcdInstallOperation::Initialize()

   201     {

   202     DLTRACEIN( ( "" ) );

   203 

   204     TRAPD( err,

   205         {

   206         DLTRACE(("Writing initialize response"));

   207         CBufBase* buf = CBufFlat::NewL( KBufExpandSize );

   208         CleanupStack::PushL( buf );

   209 

   210         RBufWriteStream stream( *buf );

   211         CleanupClosePushL( stream );

   212          

   213         // write completion code

   214         stream.WriteInt32L( ENCDOperationMessageCompletionInit );        

   215 

   216         // Get the file count from the node and return it to the proxy

   217         // Notice here that the node has to have some kind of metadata

   218         // in order the install operation to start.

   219         DLINFO(("Get the metadata of the node"));

   220         CNcdNode& node( iNodeManager->NodeL( *iNodeId ) );

   221         CNcdNodeMetaData& metaData( node.NodeMetaDataL() );

   222         DLINFO(("Get the install object of the metadata."));

   223         CNcdNodeInstall& install( metaData.InstallL() );        

   224         stream.WriteInt32L( install.DownloadedFiles().MdcaCount() );        

   225         

   226         CleanupStack::PopAndDestroy( &stream );        

   227 

   228         DLINFO(("Create report"));

   229         // Because everything has gone smoothly so far,

   230         // create the install report for the server reports.

   231         CreateReportL();        

   232         

   233         DLTRACE(("Response length: %i", buf->Size() ));

   234 

   235         iPendingMessage->CompleteAndReleaseL( buf->Ptr(0), KErrNone );

   236         iPendingMessage = NULL;

   237         CleanupStack::PopAndDestroy( buf );

   238         });

   239     

   240     if ( err != KErrNone ) 

   241         {

   242         DLTRACE( ( "Err: %d", err ) );

   243         iPendingMessage->CompleteAndRelease( err );

   244         iPendingMessage = NULL;

   245         }

   246     DLTRACEOUT(( "err: %d", err ));

   247     return err;    

   248     }

   249 

   250 

   251 // ---------------------------------------------------------------------------

   252 // Constructor

   253 // ---------------------------------------------------------------------------

   254 //

   255 CNcdInstallOperation::CNcdInstallOperation( 

   256     MNcdOperationRemoveHandler& aRemoveHandler,    

   257     CNcdGeneralManager& aGeneralManager,

   258     MCatalogsHttpSession& aHttpSession,    

   259     MNcdInstallReportObserver& aReportObserver,

   260     MCatalogsSession& aSession ) : 

   261     CNcdBaseOperation( aGeneralManager, &aRemoveHandler, EInstallOperation, aSession ),

   262     iHttpSession( aHttpSession ),

   263     iAccessPointManager( aGeneralManager.AccessPointManager() ),

   264     iReportObserver( aReportObserver ),

   265     iReportId( KNcdReportNotSupported )

   266     {

   267     }

   268 

   269 

   270 // ---------------------------------------------------------------------------

   271 // ConstructL

   272 // ---------------------------------------------------------------------------

   273 //

   274 void CNcdInstallOperation::ConstructL( const CNcdNodeIdentifier& aNodeId )

   275     {

   276     DLTRACEIN( ( "" ) );

   277     // Call ConstructL for the base class

   278     CNcdBaseOperation::ConstructL();

   279     

   280     // copy the identifier

   281     iNodeId = CNcdNodeIdentifier::NewL( aNodeId );

   282     

   283     iInstallService = &CNcdProviderUtils::InstallationServiceL();

   284     DLTRACEOUT(( "" ));

   285     }    

   286     

   287 

   288 // ---------------------------------------------------------------------------

   289 // Gets info for an installable file from the node

   290 // ---------------------------------------------------------------------------

   291 //        

   292 void CNcdInstallOperation::GetFileInfoL( MCatalogsBaseMessage& aMessage )

   293     {

   294     DLTRACEIN((""));

   295     TInt nextFile = ReadFileIndexL( aMessage );

   296     

   297     CNcdNode& node( iNodeManager->NodeL( *iNodeId ) );

   298     // Notice that in order the node to start install, the

   299     // node has to have some kind of metadata

   300     CNcdNodeMetaData& metaData( node.NodeMetaDataL() );

   301     CNcdNodeDownload& nodeDl = metaData.DownloadL();

   302     CNcdNodeInstall& install( metaData.InstallL() );

   303     

   304     // Check that file index is in the valid range

   305     if ( nextFile < 0 || nextFile >= install.DownloadedFiles().MdcaCount() ) 

   306         {

   307         DLERROR(("Invalid index"));

   308         User::Leave( KErrArgument );

   309         }

   310 

   311     // Get item purpose        

   312     TUint completePurpose = 0;

   313     TPtrC contentMime;

   314     

   315     DeleteJad();

   316     

   317     TRAPD( error, 

   318         {

   319         const CNcdNodeContentInfo& contentInfo = 

   320             node.NodeMetaData()->ContentInfoL();

   321         

   322         completePurpose = contentInfo.Purpose();

   323         contentMime.Set( contentInfo.MimeType() );

   324         DLINFO(( _L("Content mime: %S"), &contentMime ));

   325         });

   326     

   327     LeaveIfNotErrorL( error, KErrNotFound );    

   328     

   329     // By default, use unknown purpose since installer

   330     // uses purpose for installing themes

   331     TNcdItemPurpose purpose = ENcdItemPurposeUnknown;

   332 

   333     // Check if the purpose includes theme or application

   334     if ( completePurpose & ENcdItemPurposeTheme ) 

   335         {

   336         DLTRACE(("Purpose: Theme"));

   337         purpose = ENcdItemPurposeTheme;

   338         }

   339     else if ( completePurpose & ENcdItemPurposeApplication 

   340         || completePurpose & ENcdItemPurposeGame 

   341         || completePurpose & ENcdItemPurposeScreensaver )

   342         {

   343         DLTRACE(("Purpose: Application"));

   344         purpose = ENcdItemPurposeApplication;

   345         }

   346     

   347     // Used to index downloadInfos.

   348     TInt downloadInfoIndex = nextFile;        

   349     

   350     // This check used to be for handling rights objects that were not really

   351     // rights objects, eg. a picture given in the rights uri but now it has

   352     // been removed

   353     if ( install.DownloadedFiles().MdcaCount() >

   354          nodeDl.DownloadInfo().Count() )

   355         {

   356         DLERROR(("Too many downloaded files, leaving with KErrCorrupt"));

   357         User::Leave( KErrCorrupt );

   358         }

   359     

   360     DLTRACE(("File index: %d, downloadInfoIndex: %d", nextFile, downloadInfoIndex ));

   361     CNcdFileInfo* fileInfo = NULL;

   362 

   363     // Use normal install by default

   364     CNcdInstallInfo::TNcdInstallType installType = 

   365         CNcdInstallInfo::ENcdInstallNormal;

   366         

   367             

   368     // Skip files that have not been downloaded or are already installed

   369     // Files that are downloaded are not skipped, doesn't matter 

   370     // if they are installed or not

   371     while( nextFile < install.DownloadedFiles().MdcaCount() &&

   372            ( !install.DownloadedFiles().MdcaPoint( nextFile ).Length() ||

   373            // Check if file is missing and is installed, if it's missing

   374            // and not installed, we give an error by failing the installation

   375            // on proxy side when the file is missing

   376             ( !BaflUtils::FileExists( CNcdProviderUtils::FileSession(), 

   377                 install.DownloadedFiles().MdcaPoint( nextFile ) ) && (                    

   378             install.IsContentInstalledL( nextFile, EFalse ) >= ENcdApplicationInstalled ||

   379             // unless the file is launcher application which we can happily skip over

   380             IsOneOf( nodeDl.DownloadInfo()[ downloadInfoIndex ]->ContentUsage(),

   381                 MNcdPurchaseDownloadInfo::ELauncher,                

   382                 MNcdPurchaseDownloadInfo::ELauncherOpen,

   383                 MNcdPurchaseDownloadInfo::EConsumable ) ) ) ) )

   384         {

   385         DLTRACE(("Skipping installed files or not downloaded files"));            

   386         nextFile++;    

   387         downloadInfoIndex++;

   388         }

   389    

   390     // We may have skipped over the last possible file so we have to 

   391     // complete the operation

   392     if ( nextFile == install.DownloadedFiles().MdcaCount() ) 

   393         {

   394         DLERROR(("Either nothing has been downloaded or everything is already installed"));

   395         HandleAllFilesInstalledL( nextFile, aMessage );

   396         DLTRACEOUT(("Operation complete because all files have been installed"));

   397         return;

   398         }

   399         

   400     // Shortcut to correct download info

   401     MNcdPurchaseDownloadInfo* downloadInfo( 

   402         nodeDl.DownloadInfo()[ downloadInfoIndex ] );       

   403 

   404     // Set dependency flag that we know not to update dependency/launcher

   405     iIsDependency = NcdPurchaseHistoryUtils::IsDependency( *downloadInfo );

   406         

   407     

   408     DLINFO(( _L("Descriptor type: %S"), &downloadInfo->DescriptorType() ));

   409     DLINFO(( _L("Descriptor name: %S"), &downloadInfo->DescriptorName() ));

   410     DLINFO(( _L("Descriptor URI: %S"), &downloadInfo->DescriptorUri() ));

   411                 

   412     

   413     if ( downloadInfo->ContentMimeType().MatchF( 

   414             KMimeTypeMatch1JavaApplication ) != KErrNotFound ||

   415          downloadInfo->ContentMimeType().MatchF( 

   416             KMimeTypeMatch2JavaApplication ) != KErrNotFound ||

   417          contentMime.MatchF( 

   418             KMimeTypeMatch1JavaApplication ) != KErrNotFound ||

   419          contentMime.MatchF( 

   420             KMimeTypeMatch2JavaApplication ) != KErrNotFound )

   421 

   422         {

   423         if ( downloadInfo->DescriptorType().CompareF( 

   424             KDescriptorTypeJad ) == 0 )

   425             {

   426             DLINFO(("Java app with JAD"));

   427             purpose = ENcdItemPurposeApplication;

   428             installType = CNcdInstallInfo::ENcdInstallJad;                

   429             }

   430         else 

   431             {            

   432             DLINFO(("Java-application"));

   433             // Ensure that purpose is correct

   434             purpose = ENcdItemPurposeApplication;

   435             installType = CNcdInstallInfo::ENcdInstallJar;

   436             }

   437         }

   438     else if ( downloadInfo->ContentMimeType().MatchF(

   439             KMimeTypeMatchJad ) != KErrNotFound ||

   440         contentMime.MatchF( KMimeTypeMatchJad ) != KErrNotFound )

   441         {

   442         DLINFO(("Java app with JAD"));

   443         purpose = ENcdItemPurposeApplication;        

   444         installType = CNcdInstallInfo::ENcdInstallJad;                

   445         }

   446 

   447 

   448     DLTRACE(("Creating fileinfo"));

   449     // Create file info for proxy-side installer

   450     fileInfo = CNcdFileInfo::NewLC( 

   451         install.DownloadedFiles().MdcaPoint( nextFile ), 

   452         nodeDl.DownloadInfo()[ downloadInfoIndex ]->ContentMimeType(), 

   453         purpose );

   454 

   455     if ( installType == CNcdInstallInfo::ENcdInstallJad ) 

   456         {

   457         DLINFO(( _L("Descriptor type: %S"), &downloadInfo->DescriptorType() ));

   458         DLINFO(( _L("Descriptor name: %S"), &downloadInfo->DescriptorName() ));

   459         DLINFO(( _L("Descriptor URI: %S"), &downloadInfo->DescriptorUri() ));

   460         DLINFO(( "Descriptor Data: %S", &downloadInfo->DescriptorData() ));

   461         if ( downloadInfo->DescriptorData().Length() ) 

   462             {

   463             // This "if" is an ugly fix for embedded DD descriptors where

   464             // the .dm file is given in downloaddetails 

   465             if ( !(downloadInfo->DescriptorType() == KDescriptorTypeOdd &&

   466                 downloadInfo->ContentUri().Length() ) )

   467                 {

   468                 // Writing JAD to file on this side because proxies can't

   469                 // write to engine's private dir

   470                 DeletePtr( iJadFile );

   471                 iJadFile = 

   472                     CNcdProviderUtils::InstallationServiceL().WriteJadL(

   473                         fileInfo->FilePath(), downloadInfo->DescriptorData() );

   474                 }

   475             }

   476         else 

   477             {

   478             DLINFO(("No descriptor for JAD install"));                        

   479             }

   480         // Ensure that mime is JAD

   481         fileInfo->SetMimeTypeL( KMimeTypeMatchJad );

   482         }

   483     

   484         

   485     CNcdInstallInfo* info = CNcdInstallInfo::NewL( fileInfo,

   486         installType );

   487     CleanupStack::Pop( fileInfo );

   488     CleanupStack::PushL( info );

   489     info->SetIndex( nextFile );    

   490         

   491     MCatalogsBaseMessage* message = &aMessage;

   492     // Send the info back

   493     TInt err = CompleteMessage( 

   494         message, 

   495         ENCDOperationMessageCompletionComplete,

   496         *info, 

   497         KErrNone );

   498     

   499     CleanupStack::PopAndDestroy( info );

   500     DLTRACEOUT(("err: %d", err));

   501     }

   502 

   503 

   504 // ---------------------------------------------------------------------------

   505 // Completes the message correctly when all files have already been installed

   506 // ---------------------------------------------------------------------------

   507 //        

   508 void CNcdInstallOperation::HandleAllFilesInstalledL( 

   509     TInt aFinalIndex, MCatalogsBaseMessage& aMessage )

   510     {

   511     DLTRACEIN((""));

   512     CNcdInstallInfo* info = CNcdInstallInfo::NewL( NULL,

   513         CNcdInstallInfo::ENcdInstallNormal );            

   514     CleanupStack::PushL( info );

   515     info->SetIndex( aFinalIndex );    

   516         

   517     MCatalogsBaseMessage* message = &aMessage;

   518     // Send the info back

   519     TInt err = CompleteMessage( 

   520         message, 

   521         ENCDOperationMessageCompletionComplete,

   522         *info, 

   523         KErrNone );

   524     CleanupStack::PopAndDestroy( info );

   525     DLTRACEOUT(("Err: %d", err));

   526     }

   527 

   528 

   529 // ---------------------------------------------------------------------------

   530 // Updates the info of an installed file

   531 // ---------------------------------------------------------------------------

   532 //        

   533 void CNcdInstallOperation::UpdateInstalledFileInfoL( 

   534     MCatalogsBaseMessage& aMessage )

   535     {

   536     DLTRACEIN((""));

   537     

   538     RCatalogsMessageReader reader;

   539     reader.OpenLC( aMessage );

   540         

   541     // Read input message

   542     DLTRACE(("Reading file index"));

   543     TInt index = reader().ReadInt32L();

   544 

   545     // Read the info from the stream

   546     CNcdFileInfo* info = CNcdFileInfo::NewLC( reader() );

   547     

   548     // Read uids of installed applications

   549     TInt appUids = reader().ReadInt32L();

   550     DLTRACE(( "Reading app uids: %d", appUids ));

   551     RArray<TUid> uids;

   552     CleanupClosePushL( uids );

   553     uids.ReserveL( appUids );

   554     while( appUids ) 

   555         {

   556         uids.AppendL( TUid::Uid( reader().ReadInt32L() ) );

   557         DLINFO(("Read UID: %x", uids[uids.Count() - 1] ));

   558         --appUids;

   559         }

   560     

   561     

   562     // Installed dependencies/upgrades are not updated to purchase history

   563     if ( !iIsDependency ) 

   564         {        

   565         //update purchase history with the info         

   566         UpdatePurchaseHistoryL( *info, uids, 

   567             aMessage.Session().Context().FamilyId() );

   568         }

   569         

   570     CleanupStack::PopAndDestroy( 3, &reader );   // uids, info, reader

   571     

   572     DLTRACE(("Updating node from purchase history"));

   573     // Update node from the purchase history

   574     iNodeManager->InstallHandlerL( *iNodeId );

   575         

   576     DLTRACE(("Completing message"));

   577     MCatalogsBaseMessage* message = &aMessage;

   578     TInt err = CompleteMessage( 

   579         message, 

   580         ENCDOperationMessageCompletionComplete,

   581         KErrNone );

   582     

   583     DLTRACEOUT((""));

   584     }

   585 

   586 

   587 void CNcdInstallOperation::CreateReportL()

   588     {

   589     DLTRACEIN((""));  

   590     CNcdNode& node( iNodeManager->NodeL( *iNodeId ) ); 

   591     CNcdNodeMetaData& metaData( node.NodeMetaDataL() );

   592     

   593     TNcdReportStatusInfo info( ENcdReportCreate, KErrNone );

   594     // Use the node identifier to identify the content in install report.

   595     // Node id uniquely identifies the node that contains contents

   596     // that will be installed. One node may contains multiple contents but

   597     // they are all thought as one bundle, in one operation. Also, notice that 

   598     // multiple nodes can contain same metadata and same content.

   599 

   600     /**

   601      * @ Get timestamp and purchase option id from purchase details and

   602      * set them to the report

   603      */

   604     iReportId = 

   605         iReportObserver.RegisterInstallL( 

   606             iNodeId->NodeId(),

   607             metaData.Identifier(),

   608             info,

   609             metaData.Identifier().ServerUri(),

   610             metaData.Identifier().NodeNameSpace() );

   611 

   612     // Access point is set when report is started.

   613     // Then base message is used to get required info.

   614     }

   615 

   616 

   617 void CNcdInstallOperation::StartReportL( MCatalogsBaseMessage& aMessage )

   618     {

   619     DLTRACEIN((""));

   620     // Set access point for report.

   621     UpdateReportAccessPointL( aMessage.Session().Context().FamilyId() );    

   622 

   623     TNcdReportStatusInfo info( ENcdReportStart, KErrNone );

   624     iReportObserver.ReportInstallStatusL(

   625             iReportId,

   626             info );

   627 

   628     // If this leaves, ReceiveMessge will complete the message.

   629     aMessage.CompleteAndRelease( KErrNone );

   630     }

   631     

   632     

   633 void CNcdInstallOperation::CompleteReportL( MCatalogsBaseMessage& aMessage )

   634     {

   635     DLTRACEIN((""));

   636     RCatalogsMessageReader reader;

   637     reader.OpenLC( aMessage );

   638     

   639     RReadStream& stream( reader() );

   640     TInt errorCode( stream.ReadInt32L() );

   641         

   642     CleanupStack::PopAndDestroy( &reader );        

   643 

   644     TNcdReportStatus status( ENcdReportSuccess );

   645     if ( errorCode == KErrNone )

   646         {

   647         status = ENcdReportSuccess;

   648         }

   649     else if ( errorCode == KErrCancel )

   650         {

   651         status = ENcdReportCancel;

   652         }

   653     else 

   654         {

   655         status = ENcdReportFail;

   656         }

   657     

   658     // Create the status info object with the given info.

   659     TNcdReportStatusInfo info( status, errorCode );

   660     

   661     iReportObserver.ReportInstallStatusL(

   662             iReportId,

   663             info );

   664 

   665     // If this leaves, ReceiveMessge will complete the message.

   666     aMessage.CompleteAndRelease( KErrNone );

   667     }

   668 

   669 

   670 // ---------------------------------------------------------------------------

   671 // UpdateReportAccessPointL

   672 // ---------------------------------------------------------------------------

   673 //

   674 void CNcdInstallOperation::UpdateReportAccessPointL( const TUid& aClientUid )

   675     {

   676     DLTRACEIN((""));

   677 

   678     CNcdPurchaseHistoryDb& db = iNodeManager->PurchaseHistory();    

   679     CNcdNode& node( iNodeManager->NodeL( *iNodeId ) ); 

   680     CNcdNodeMetaData& metadata( node.NodeMetaDataL() );

   681     

   682     CNcdPurchaseDetails* purchase = 

   683         NcdPurchaseHistoryUtils::PurchaseDetailsLC(

   684             db,

   685             aClientUid,

   686             metadata.Identifier(),

   687             EFalse );

   688                 

   689     // Create origin identifier

   690     CNcdNodeIdentifier* originIdentifier = 

   691         CNcdNodeIdentifier::NewL(

   692             node.Identifier().NodeNameSpace(), 

   693             purchase->OriginNodeId(), 

   694             node.Identifier().ClientUid() );

   695 

   696     CleanupStack::PopAndDestroy( purchase );

   697     

   698     CleanupStack::PushL( originIdentifier );

   699     

   700     // Get report ap    

   701     TUint32 apId( 0 );

   702 

   703     TInt error = 

   704         iAccessPointManager.AccessPointIdL(

   705             *originIdentifier, 

   706             MCatalogsAccessPointManager::EBrowse, 

   707             aClientUid, 

   708             apId );

   709         

   710     TCatalogsConnectionMethod reportAp;

   711     if ( error == KErrNone ) 

   712         {

   713         DLTRACE(( "Setting access point %d for reports", apId ))   

   714         reportAp = 

   715             TCatalogsConnectionMethod( 

   716                 apId, 

   717                 ECatalogsConnectionMethodTypeAccessPoint );

   718         }

   719     

   720     if ( reportAp.iId == 0 ) 

   721         {

   722         reportAp = iHttpSession.ConnectionManager().DefaultConnectionMethod();

   723         }

   724 

   725     CleanupStack::PopAndDestroy( originIdentifier );

   726 

   727     iReportObserver.SetInstallReportAccessPoint( 

   728         iReportId,

   729         reportAp );

   730     }

   731 

   732 

   733 // ---------------------------------------------------------------------------

   734 // Updates purchase history

   735 // ---------------------------------------------------------------------------

   736 //        

   737 void CNcdInstallOperation::UpdatePurchaseHistoryL( const CNcdFileInfo& aInfo,

   738     const RArray<TUid>& aAppUids, const TUid& aClientUid )

   739     {

   740     DLTRACEIN((""));

   741     

   742     CNcdPurchaseHistoryDb& db = iNodeManager->PurchaseHistory();    

   743     CNcdNode& node( iNodeManager->NodeL( *iNodeId ) ); 

   744     CNcdNodeMetaData& metadata( node.NodeMetaDataL() );

   745     

   746     CNcdPurchaseDetails* purchase = NcdPurchaseHistoryUtils::PurchaseDetailsLC(

   747         db,

   748         aClientUid,

   749         metadata.Identifier(),

   750         EFalse );

   751                 

   752     

   753     CNcdPurchaseInstallInfo* installInfo = CNcdPurchaseInstallInfo::NewLC();    

   754        

   755     const CNcdNodeContentInfo* contentInfo = NULL;                

   756     TRAPD( err, contentInfo = &metadata.ContentInfoL() );            

   757 

   758     LeaveIfNotErrorL( err, KErrNotFound );

   759     

   760     if ( aAppUids.Count() ) 

   761         {

   762         DLTRACE(("Updating installed application info"));

   763         // Use application UID from the protocol if it exists

   764         if ( contentInfo && contentInfo->Uid() != TUid::Null() ) 

   765             {

   766             DLINFO(( "Using UID from Content info: %x", 

   767                 contentInfo->Uid().iUid ));

   768             installInfo->SetApplicationUid( contentInfo->Uid() );

   769             }

   770         else

   771             {                

   772             DLINFO(( "Using UID from installer: %x", aAppUids[0].iUid ));

   773             installInfo->SetApplicationUid( aAppUids[0] );

   774             }

   775         

   776         // Theme version number's are not updated from sis registry

   777         if ( aInfo.Purpose() != ENcdItemPurposeTheme &&

   778              aInfo.FilePath().Length() ) 

   779             {

   780             DLTRACE(( _L("Got version number from sis registry: %S"), 

   781                 &aInfo.FilePath() ));

   782                 

   783             installInfo->SetApplicationVersionL(

   784                 aInfo.FilePath() );

   785             }

   786         else if ( contentInfo ) 

   787             {        

   788             DLTRACE(("Content info exists"));        

   789             // Use application version from the protocol

   790             DLINFO(( _L("Setting app version: %S"), 

   791                 &contentInfo->Version() ));

   792             installInfo->SetApplicationVersionL( 

   793                 contentInfo->Version() );

   794             }

   795             

   796         }

   797     else if ( aInfo.Purpose() == ENcdItemPurposeTheme )

   798         {

   799         DLTRACE(("Updating installed theme info"));

   800         installInfo->SetThemeNameL( aInfo.FilePath() );

   801         }

   802     else

   803         {

   804         DLTRACE(("Updating installed content info"));

   805         DLINFO(( _L("Installed file: %S"), &aInfo.FilePath() ));

   806         

   807         // Save the filename 

   808         installInfo->SetFilenameL( aInfo.FilePath() );

   809         }

   810     

   811     // update purpose to purchase history

   812     

   813     // if purpose in content info was unknown, we use the one gotten from installer

   814     // since it may have been updated to something more specific

   815     if ( contentInfo && contentInfo->Purpose() != ENcdItemPurposeUnknown )     

   816         {        

   817         TUint newPurpose = contentInfo->Purpose();

   818         if ( aInfo.Purpose() == ENcdItemPurposeApplication ) 

   819             {

   820             // This ensures that games etc. stuff that were installed like 

   821             // applications, are also handled like applications 

   822             newPurpose |= ENcdItemPurposeApplication;

   823             }

   824         DLTRACE(("Setting purpose as %d", newPurpose));

   825         purchase->SetItemPurpose( newPurpose );

   826         }

   827     else

   828         {        

   829         // backup in case we didn't get content info for some reason

   830         DLINFO(("Didn't get ContentInfo, updating purpose from FileInfo"));

   831         purchase->SetItemPurpose( purchase->ItemPurpose() | aInfo.Purpose() );

   832         }

   833     

   834     DLINFO(("Item purpose: %d", purchase->ItemPurpose() ));

   835     // Add install info to purchase details. Ownership is transferred

   836     

   837     if ( ReplaceInstallInfoL( *purchase, *installInfo ) )

   838         {

   839         CleanupStack::PopAndDestroy( installInfo );

   840         }

   841     else 

   842         {

   843         DLTRACE(("Adding install info to purchase details"));    

   844         purchase->AddInstallInfoL( installInfo );        

   845         CleanupStack::Pop( installInfo );

   846         }

   847 

   848     DLTRACE(("Saving purchase details"));                

   849     db.SavePurchaseL( *purchase, EFalse );    

   850     CleanupStack::PopAndDestroy( purchase );

   851     

   852     DLTRACEOUT((""));

   853     }

   854 

   855 

   856 // ---------------------------------------------------------------------------

   857 // Checks if the details already contain a matching info

   858 // ---------------------------------------------------------------------------

   859 //        

   860 TBool CNcdInstallOperation::ReplaceInstallInfoL( 

   861     MNcdPurchaseDetails& aDetails, 

   862     const MNcdPurchaseInstallInfo& aInfo )

   863     {

   864     DLTRACEIN((""));

   865     TArray< MNcdPurchaseInstallInfo* > installInfos( 

   866         aDetails.InstallInfoL() );

   867         

   868     TParsePtrC path( aInfo.Filename() );

   869     TPtrC installedFile( path.NameAndExt() );

   870     DLTRACE(("Going through %d install infos", installInfos.Count() ));

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

   872         {

   873         MNcdPurchaseInstallInfo& oldInfo( *installInfos[ i ] );

   874         

   875         if ( ( oldInfo.ApplicationUid() == aInfo.ApplicationUid() &&

   876                oldInfo.ApplicationVersion() == aInfo.ApplicationVersion() &&

   877                oldInfo.ThemeName() == aInfo.ThemeName() ) ||

   878                // also replace empty infos, hopefully this doesn't break anything

   879                // because this is needed in order to correctly handle cancelled

   880                // theme installations or more spefically successful theme installations

   881                // after a cancelled theme installation

   882              ( oldInfo.ApplicationUid() == KNullUid && 

   883                oldInfo.ApplicationVersion() == KNullDesC &&

   884                // replace the old info if theme name is empty or if the old theme name

   885                // is not empty but the new info is entirely empty == reinstalling a theme

   886                ( oldInfo.ThemeName() == KNullDesC || 

   887                 ( aInfo.ApplicationUid() == KNullUid &&

   888                   aInfo.ApplicationVersion() == KNullDesC &&

   889                   aInfo.ThemeName() == KNullDesC ) ) ) )

   890              

   891             {

   892             // Parse the filename from the file path

   893             TParsePtrC oldPath( oldInfo.Filename() );

   894             if ( oldPath.NameAndExt() == installedFile ) 

   895                 {                

   896                 DLTRACEOUT(("Info already exists"));

   897                 

   898                 // Update the filename in case the file has been installed

   899                 // to a different drive than before

   900                 CNcdPurchaseInstallInfo* modInfo = 

   901                     static_cast<CNcdPurchaseInstallInfo*>( installInfos[i] );

   902                 

   903                 // This updates the theme name in the following case:

   904                 // 1. theme was already installed when bought and installed with the client

   905                 // 2. user uninstalled the theme

   906                 // 3. user downloaded and installed the theme again

   907                 if ( oldInfo.ThemeName() == KNullDesC ) 

   908                     {

   909                     modInfo->SetThemeNameL( aInfo.ThemeName() );

   910                     }

   911                 modInfo->SetFilenameL( aInfo.Filename() );

   912                 return ETrue;

   913                 }

   914             }                    

   915         }

   916     

   917     // This tries to update an existing java app uid when we are reinstalling

   918     // java apps    

   919     TArray< MNcdPurchaseDownloadInfo* > downloadInfos(

   920         aDetails.DownloadInfoL() );        

   921         

   922     if ( installInfos.Count() &&

   923          aInfo.ApplicationUid() != KNullUid && 

   924          downloadInfos.Count() >= installInfos.Count() )        

   925         {   

   926         TBool isJava = EFalse;

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

   928             {

   929             if ( IsJava( downloadInfos[i]->ContentMimeType(), ETrue ) )

   930                 {

   931                 isJava = ETrue;

   932                 break;

   933                 }

   934             }

   935         

   936         if ( !isJava ) 

   937             {

   938             DLTRACEOUT(("No java app"));

   939             return EFalse;

   940             }

   941             

   942         DLTRACE(("Update the uid of the first existing app"));

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

   944             {

   945             MNcdPurchaseInstallInfo& oldInfo( *installInfos[ i ] );

   946             if ( oldInfo.ApplicationUid() != KNullUid ) 

   947                 {

   948                 DLTRACE(("Updating application uid from %x to %x",

   949                     oldInfo.ApplicationUid(), aInfo.ApplicationUid() ));

   950                 // Update the app uid for java app                

   951                 CNcdPurchaseInstallInfo* modInfo = 

   952                     static_cast<CNcdPurchaseInstallInfo*>( installInfos[i] );

   953                 

   954                 modInfo->SetApplicationUid( aInfo.ApplicationUid() );

   955                 modInfo->SetApplicationVersionL( aInfo.ApplicationVersion() );

   956                 return ETrue;

   957                 }                

   958             }

   959         }

   960         

   961     return EFalse;

   962     }

   963 

   964 

   965 // ---------------------------------------------------------------------------

   966 // Checks if the given mime type matches a java app

   967 // ---------------------------------------------------------------------------

   968 //        

   969 TBool CNcdInstallOperation::IsJava( 

   970     const TDesC& aMimeType, 

   971     TBool aAcceptJad ) const

   972     {

   973     DLTRACEIN(( _L("aMimeType: %S"), &aMimeType ));

   974     

   975     TBool matches = aMimeType.MatchF( KMimeTypeMatch1JavaApplication ) != KErrNotFound ||

   976                   aMimeType.MatchF( KMimeTypeMatch2JavaApplication ) != KErrNotFound;

   977 

   978     if ( !matches && aAcceptJad ) 

   979         {

   980         matches = aMimeType.MatchF( KMimeTypeMatchJad ) != KErrNotFound;

   981         }

   982     DLTRACEOUT(("Matched: %d", matches));

   983     return matches;    

   984     }

   985 

   986 

   987 // ---------------------------------------------------------------------------

   988 // Gets the path to the file indexed by the message

   989 // ---------------------------------------------------------------------------

   990 //        

   991 HBufC* CNcdInstallOperation::FilePathLC( 

   992     MCatalogsBaseMessage& aMessage )

   993     {

   994     DLTRACEIN((""));

   995     TInt fileIndex = ReadFileIndexL( aMessage );

   996     

   997     CNcdNode& node( iNodeManager->NodeL( *iNodeId ) );

   998     // Notice that in order the node to start install, the

   999     // node has to have some kind of metadata

  1000     CNcdNodeMetaData& metaData( node.NodeMetaDataL() );    

  1001     CNcdNodeInstall& install( metaData.InstallL() );

  1002     

  1003     // Check that file index is in the valid range

  1004     if ( fileIndex < 0 || fileIndex >= install.DownloadedFiles().MdcaCount() ) 

  1005         {

  1006         DLERROR(("Invalid index: %d", fileIndex ));

  1007         User::Leave( KErrArgument );

  1008         }

  1009                     

  1010     DLTRACEOUT(( _L("Filepath %S from index: %d"), 

  1011         &install.DownloadedFiles().MdcaPoint( fileIndex ), fileIndex ));

  1012 

  1013     return install.DownloadedFiles().MdcaPoint( fileIndex ).AllocLC();

  1014     }

  1015 

  1016 

  1017 // ---------------------------------------------------------------------------

  1018 // Opens a file

  1019 // ---------------------------------------------------------------------------

  1020 //  

  1021 void CNcdInstallOperation::OpenFileL( 

  1022     MCatalogsBaseMessage& aMessage )

  1023     {

  1024     DLTRACEIN((""));

  1025     RFs fs;

  1026     User::LeaveIfError( fs.Connect() );

  1027     CleanupClosePushL( fs );

  1028     

  1029     DLTRACE(("Sharing the file server"));

  1030     User::LeaveIfError( fs.ShareProtected() );

  1031     

  1032     DLTRACE(("Trying to open the file"));

  1033     RFile file;

  1034     CleanupClosePushL( file );

  1035     

  1036     // Ugly hackfix for handling JADs

  1037     if ( iJadFile ) 

  1038         {

  1039         User::LeaveIfError( file.Open( fs, 

  1040             *iJadFile,

  1041             NcdProviderDefines::KNcdSharableFileOpenFlags ) );                        

  1042         }

  1043     else

  1044         {

  1045         HBufC* path = FilePathLC( aMessage ); 

  1046         User::LeaveIfError( file.Open( fs, 

  1047             *path,

  1048             NcdProviderDefines::KNcdSharableFileOpenFlags ) );                

  1049         CleanupStack::PopAndDestroy( path );

  1050         }

  1051     DLTRACE(("File open, transferring to client"));

  1052     

  1053     aMessage.CompleteAndReleaseL( fs, file );

  1054     

  1055     DLTRACE(("File transferred"));

  1056     CleanupStack::PopAndDestroy( 2, &fs ); // file, fs    

  1057     }

  1058 

  1059 

  1060 // ---------------------------------------------------------------------------

  1061 // Does the actual message handling

  1062 // ---------------------------------------------------------------------------

  1063 //        

  1064 void CNcdInstallOperation::DoReceiveMessageL( 

  1065         MCatalogsBaseMessage* aMessage,

  1066         TInt aFunctionNumber )

  1067     {

  1068     DLTRACEIN((""));

  1069     switch ( aFunctionNumber )

  1070         {

  1071         case ENCDOperationFunctionGetData:

  1072             {

  1073             GetFileInfoL( *aMessage );

  1074             break;

  1075             }

  1076             

  1077         case ENCDOperationFunctionSetData:

  1078             {

  1079             UpdateInstalledFileInfoL( *aMessage );

  1080             break;

  1081             }

  1082 

  1083         case ENcdOperationFunctionOpenFile:

  1084             {

  1085             OpenFileL( *aMessage );

  1086             break;

  1087             }

  1088 

  1089         case ENcdOperationFunctionDeleteFile:

  1090             {

  1091             DeleteFileL( *aMessage );

  1092             break;

  1093             }

  1094 

  1095         case ENCDOperationFunctionReportStart:

  1096             {

  1097             StartReportL( *aMessage );

  1098             break;

  1099             }

  1100 

  1101         case ENCDOperationFunctionReportComplete:

  1102             {

  1103             CompleteReportL( *aMessage );

  1104             break;

  1105             }

  1106 

  1107         default:

  1108             {

  1109             DLTRACE(("Calling baseclass"));

  1110             // Call implementation in the base class

  1111             CNcdBaseOperation::ReceiveMessage( aMessage, aFunctionNumber );            

  1112             break;

  1113             }            

  1114         } 

  1115     DLTRACEOUT((""));

  1116     }

  1117 

  1118 

  1119 // ---------------------------------------------------------------------------

  1120 // Deletes a file index by the message. Also JAD is deleted if necessary

  1121 // ---------------------------------------------------------------------------

  1122 //        

  1123 void CNcdInstallOperation::DeleteFileL( MCatalogsBaseMessage& aMessage )

  1124     {

  1125     DLTRACEIN((""));

  1126     HBufC* path = FilePathLC( aMessage );

  1127     // Delete installed SIS/JAR/content file

  1128     User::LeaveIfError( iInstallService->DeleteFile( *path ) );      

  1129     

  1130     CleanupStack::PopAndDestroy( path );

  1131     // If we installed JAD+JAR we must delete JAD separately.

  1132     DeleteJad();

  1133     

  1134     aMessage.CompleteAndReleaseL( KErrNone, KErrNone );