1 /*

     2 * Copyright (c) 2005-2010 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:  ConML Task implementations

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include "sconconmltask.h"

    22 

    23 // -----------------------------------------------------------------------------

    24 // CSConReboot::CSConReboot()

    25 // 

    26 // -----------------------------------------------------------------------------

    27 //

    28 CSConReboot::CSConReboot()

    29     {

    30     }

    31         

    32 // -----------------------------------------------------------------------------

    33 // CSConReboot::~CSConReboot()

    34 // 

    35 // -----------------------------------------------------------------------------

    36 //  

    37 CSConReboot::~CSConReboot()

    38     {

    39     }

    40 

    41 // -----------------------------------------------------------------------------

    42 // CSConReboot::Copy()

    43 // 

    44 // -----------------------------------------------------------------------------

    45 //          

    46 CSConReboot* CSConReboot::CopyL()

    47     {

    48     CSConReboot* copy = new (ELeave) CSConReboot();

    49     copy->iComplete = iComplete;

    50     copy->iProgress = iProgress;

    51     return copy;

    52     }

    53     

    54 // -----------------------------------------------------------------------------

    55 // CSConDataOwner::CSConDataOwner()

    56 // 

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

    58 //  

    59 CSConDataOwner::CSConDataOwner()

    60     {

    61     iHasFiles = ENoFiles;

    62     iJavaHash = NULL;

    63     iUid.iUid = 0;

    64     

    65     //Initialize iDriveList with zeros

    66     iDriveList.Fill( '\x0' );

    67     }

    68     

    69 // -----------------------------------------------------------------------------

    70 // CSConDataOwner::~CSConDataOwner()

    71 // 

    72 // -----------------------------------------------------------------------------

    73 //  

    74 CSConDataOwner::~CSConDataOwner()

    75     {

    76     delete iJavaHash;

    77     iJavaHash = NULL;

    78     }

    79     

    80 // -----------------------------------------------------------------------------

    81 // CSConDataOwner::Copy()

    82 // 

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

    84 //          

    85 CSConDataOwner* CSConDataOwner::CopyL()

    86     {

    87     CSConDataOwner* copy = new (ELeave) CSConDataOwner();

    88     CleanupStack::PushL( copy );

    89     copy->iType = iType;

    90     copy->iUid = iUid;

    91     copy->iDriveList.Copy( iDriveList );

    92     copy->iPackageName = iPackageName;

    93     copy->iReqReboot = iReqReboot;

    94     copy->iHasFiles = iHasFiles;

    95     copy->iSupportsInc = iSupportsInc;

    96     copy->iSupportsSel = iSupportsSel;

    97     copy->iDelayToPrep = iDelayToPrep;

    98     copy->iSize = iSize;

    99     copy->iDataOwnStatus = iDataOwnStatus;

   100     copy->iTransDataType = iTransDataType;

   101     

   102     if ( iJavaHash )

   103         {

   104         if ( copy->iJavaHash )

   105             {

   106             delete copy->iJavaHash;

   107             copy->iJavaHash = NULL;

   108             }

   109         copy->iJavaHash = iJavaHash->AllocL();

   110         }

   111     CleanupStack::Pop( copy );

   112     return copy;

   113     }

   114     

   115 // -----------------------------------------------------------------------------

   116 // CSConUpdateDeviceInfo::CSConUpdateDeviceInfo()

   117 // 

   118 // -----------------------------------------------------------------------------

   119 //  

   120 CSConUpdateDeviceInfo::CSConUpdateDeviceInfo()

   121     {

   122     }

   123     

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

   125 // CSConUpdateDeviceInfo::~CSConUpdateDeviceInfo()

   126 // 

   127 // -----------------------------------------------------------------------------

   128 //           

   129 CSConUpdateDeviceInfo::~CSConUpdateDeviceInfo()

   130     {

   131     }

   132 

   133 // -----------------------------------------------------------------------------

   134 // CSConUpdateDeviceInfo::Copy()

   135 // 

   136 // -----------------------------------------------------------------------------

   137 //          

   138 CSConUpdateDeviceInfo* CSConUpdateDeviceInfo::CopyL()

   139     {

   140     CSConUpdateDeviceInfo* copy = new (ELeave) CSConUpdateDeviceInfo();

   141     copy->iVersion.Copy( iVersion );

   142     copy->iInstallSupp = iInstallSupp;

   143     copy->iUninstallSupp = iUninstallSupp;

   144     copy->iInstParamsSupp = iInstParamsSupp;

   145     copy->iInstAppsSupp = iInstAppsSupp;

   146     copy->iDataOwnersSupp = iDataOwnersSupp;

   147     copy->iSetBURModeSupp = iSetBURModeSupp;

   148     copy->iGetSizeSupp = iGetSizeSupp;

   149     copy->iReqDataSupp = iReqDataSupp;

   150     copy->iSupplyDataSupp = iSupplyDataSupp;

   151     copy->iMaxObjectSize = iMaxObjectSize;

   152     copy->iRebootSupp = iRebootSupp;

   153     copy->iComplete = iComplete;

   154     copy->iProgress = iProgress;        

   155                 

   156     return copy;

   157     }

   158 

   159 CSConInstApp::~CSConInstApp()

   160     {

   161     delete iWidgetBundleId;

   162     }

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

   164 // CSConInstApp::Copy()

   165 // 

   166 // -----------------------------------------------------------------------------

   167 //  

   168 CSConInstApp* CSConInstApp::CopyL()

   169     {

   170     CSConInstApp* copy = new (ELeave) CSConInstApp();

   171             

   172     copy->iName.Copy( iName ); 

   173     copy->iParentName.Copy( iParentName );

   174     copy->iVendor.Copy( iVendor );

   175     copy->iVersion.Copy( iVersion );

   176     copy->iSize = iSize;

   177     copy->iType = iType;

   178     copy->iUid = iUid;

   179     if ( iWidgetBundleId )

   180         {

   181         copy->iWidgetBundleId = iWidgetBundleId->AllocL();

   182         }

   183     else

   184         {

   185         copy->iWidgetBundleId = NULL;

   186         }

   187 

   188     return copy;

   189     }

   190 

   191 // -----------------------------------------------------------------------------

   192 // CSConListInstApps::CSConListInstApps()

   193 // 

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

   195 //      

   196 CSConListInstApps::CSConListInstApps()

   197     {

   198     //Initialize iDriveList with zeros

   199     iDriveList.Fill( '\x0' );

   200     }

   201 

   202 // -----------------------------------------------------------------------------

   203 // CSConListInstApps::~CSConListInstApps()

   204 // 

   205 // -----------------------------------------------------------------------------

   206 //      

   207 CSConListInstApps::~CSConListInstApps()

   208     {

   209     iApps.ResetAndDestroy();

   210     iApps.Close();

   211     }

   212 

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

   214 // CSConListInstApps::CopyL()

   215 // 

   216 // -----------------------------------------------------------------------------

   217 //              

   218 CSConListInstApps* CSConListInstApps::CopyL()

   219     {

   220     CSConListInstApps* copy = new (ELeave) CSConListInstApps();

   221     CleanupStack::PushL( copy );

   222     copy->iAllApps = iAllApps;

   223     copy->iDriveList = iDriveList;

   224             

   225     copy->iComplete = iComplete;

   226     copy->iProgress = iProgress;            

   227         

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

   229         {

   230         CSConInstApp* temp = iApps[i]->CopyL();

   231         CleanupStack::PushL( temp );

   232         copy->iApps.AppendL( temp );

   233         CleanupStack::Pop( temp );

   234         }

   235     CleanupStack::Pop( copy );

   236     return copy;

   237     }

   238 

   239 // -----------------------------------------------------------------------------

   240 // CSConFile::CSConFile

   241 // 

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

   243 //  

   244 CSConFile::CSConFile()

   245     {

   246     }

   247     

   248 // -----------------------------------------------------------------------------

   249 // CSConFile::~CSConFile

   250 // 

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

   252 //  

   253 CSConFile::~CSConFile()

   254     {

   255     

   256     }

   257     

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

   259 // CSConFile::Copy()

   260 // 

   261 // -----------------------------------------------------------------------------

   262 //  

   263 CSConFile* CSConFile::CopyL()

   264     {

   265     CSConFile* copy = new (ELeave) CSConFile();

   266             

   267     copy->iPath.Copy( iPath ); 

   268     copy->iModified.Copy( iModified );

   269     copy->iSize = iSize;

   270     copy->iUserPerm = iUserPerm;

   271 

   272     return copy;

   273     }

   274 

   275 // -----------------------------------------------------------------------------

   276 // CSConInstall::CSConInstall()

   277 // 

   278 // -----------------------------------------------------------------------------

   279 //      

   280 CSConInstall::CSConInstall() : iMode( EUnknown ) 

   281     {

   282     }

   283 

   284 // -----------------------------------------------------------------------------

   285 // CSConInstall::~CSConInstall()

   286 // 

   287 // -----------------------------------------------------------------------------

   288 //              

   289 CSConInstall::~CSConInstall()

   290     {

   291     delete iData;

   292     }

   293 

   294 // -----------------------------------------------------------------------------

   295 // CSConInstall::CopyL()

   296 // 

   297 // -----------------------------------------------------------------------------

   298 //              

   299 CSConInstall* CSConInstall::CopyL()

   300     {

   301     CSConInstall* copy = new (ELeave) CSConInstall();

   302     copy->iPath = iPath;

   303     copy->iMode = iMode;

   304             

   305     copy->iComplete = iComplete;

   306     copy->iProgress = iProgress;

   307     

   308     if ( iData )

   309         {

   310         copy->iData = iData->Alloc();

   311         }

   312             

   313     return copy;

   314     }

   315 

   316 // -----------------------------------------------------------------------------

   317 // CSConUninstall::CSConUninstall()

   318 // 

   319 // -----------------------------------------------------------------------------

   320 //  

   321 CSConUninstall::CSConUninstall() : iMode( EUnknown )

   322     {

   323     }

   324 

   325 // -----------------------------------------------------------------------------

   326 // CSConUninstall::~CSConUninstall()

   327 // 

   328 // -----------------------------------------------------------------------------

   329 //          

   330 CSConUninstall::~CSConUninstall()

   331     {

   332     delete iData;

   333     }

   334 

   335 // -----------------------------------------------------------------------------

   336 // CSConUninstall::Copy()

   337 // 

   338 // -----------------------------------------------------------------------------

   339 //          

   340 CSConUninstall* CSConUninstall::CopyL()

   341     {

   342     CSConUninstall* copy = new (ELeave) CSConUninstall();

   343     copy->iName = iName;

   344     copy->iVendor = iVendor;

   345     copy->iUid = iUid;

   346     copy->iMode = iMode;

   347             

   348     copy->iComplete = iComplete;

   349     copy->iProgress = iProgress;

   350     

   351     if ( iData )

   352         {

   353         copy->iData = iData->Alloc();

   354         }

   355             

   356     return copy;

   357     }

   358 

   359 // -----------------------------------------------------------------------------

   360 // CSConListDataOwners::CSConListDataOwners()

   361 // 

   362 // -----------------------------------------------------------------------------

   363 //      

   364 CSConListDataOwners::CSConListDataOwners()

   365     {

   366     }

   367     

   368 // -----------------------------------------------------------------------------

   369 // CSConListDataOwners::~CSConListDataOwners()

   370 // 

   371 // -----------------------------------------------------------------------------

   372 //          

   373 CSConListDataOwners::~CSConListDataOwners()

   374     {

   375     iDataOwners.ResetAndDestroy();

   376     iDataOwners.Close();

   377     }

   378 

   379 // -----------------------------------------------------------------------------

   380 // CSConListDataOwners::CopyL()

   381 // 

   382 // -----------------------------------------------------------------------------

   383 //              

   384 CSConListDataOwners* CSConListDataOwners::CopyL()

   385     {

   386     CSConListDataOwners* copy = new (ELeave) CSConListDataOwners();

   387     CleanupStack::PushL( copy );

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

   389         {

   390         CSConDataOwner* temp = iDataOwners[i]->CopyL();

   391         CleanupStack::PushL( temp );

   392         copy->iDataOwners.AppendL( temp );

   393         CleanupStack::Pop( temp );

   394         }

   395     CleanupStack::Pop( copy );

   396     

   397     copy->iComplete = iComplete;

   398     copy->iProgress = iProgress;

   399         

   400     return copy;

   401     }

   402     

   403 // -----------------------------------------------------------------------------

   404 // CSConListDataOwners::DeleteDataOwners()

   405 // 

   406 // -----------------------------------------------------------------------------

   407 //          

   408 void CSConListDataOwners::DeleteDataOwners()

   409     {

   410     iDataOwners.ResetAndDestroy();

   411     iDataOwners.Close();

   412     }

   413     

   414 // -----------------------------------------------------------------------------

   415 // CCSConSetBURMode::CSConSetBURMode()

   416 // 

   417 // -----------------------------------------------------------------------------

   418 //      

   419 CSConSetBURMode::CSConSetBURMode()

   420     {

   421     //Initialize iDriveList with zeros

   422     iDriveList.Fill( '\x0' );

   423     }

   424         

   425 // -----------------------------------------------------------------------------

   426 // CSConSetBURMode::~CSConSetBURMode()

   427 // 

   428 // -----------------------------------------------------------------------------

   429 //      

   430 CSConSetBURMode::~CSConSetBURMode()

   431     {

   432     }

   433     

   434 // -----------------------------------------------------------------------------

   435 // CSConSetBURMode::Copy()

   436 // 

   437 // -----------------------------------------------------------------------------

   438 //      

   439 CSConSetBURMode* CSConSetBURMode::CopyL()

   440     {

   441     CSConSetBURMode* copy = new (ELeave) CSConSetBURMode();

   442     copy->iDriveList.Copy( iDriveList );

   443     copy->iPartialType = iPartialType;

   444     copy->iIncType = iIncType;

   445             

   446     copy->iComplete = iComplete;

   447     copy->iProgress = iProgress;

   448 

   449     return copy;

   450     }

   451 

   452 // -----------------------------------------------------------------------------

   453 // CSConGetDataSize::CSConGetDataSize()

   454 // 

   455 // -----------------------------------------------------------------------------

   456 //          

   457 CSConGetDataSize::CSConGetDataSize()

   458     {

   459     }

   460 

   461 // -----------------------------------------------------------------------------

   462 // CSConGetDataSize::~CSConGetDataSize()

   463 // 

   464 // -----------------------------------------------------------------------------

   465 //      

   466 CSConGetDataSize::~CSConGetDataSize()

   467     {

   468     iDataOwners.ResetAndDestroy();

   469     iDataOwners.Close();

   470     }

   471         

   472 // -----------------------------------------------------------------------------

   473 // CSConGetDataSize::Copy()

   474 // 

   475 // -----------------------------------------------------------------------------

   476 //      

   477 CSConGetDataSize* CSConGetDataSize::CopyL()

   478     {

   479     CSConGetDataSize* copy = new (ELeave) CSConGetDataSize();

   480     CleanupStack::PushL( copy );

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

   482         {

   483         CSConDataOwner* temp = iDataOwners[i]->CopyL();

   484         CleanupStack::PushL( temp );

   485         copy->iDataOwners.AppendL( temp );

   486         CleanupStack::Pop( temp );

   487         }

   488     CleanupStack::Pop( copy );

   489     copy->iComplete = iComplete;

   490     copy->iProgress = iProgress;

   491         

   492     return copy;

   493     }

   494     

   495 // -----------------------------------------------------------------------------

   496 // CSConGetDataSize::DeleteDataOwners()

   497 // 

   498 // -----------------------------------------------------------------------------

   499 //              

   500 void CSConGetDataSize::DeleteDataOwners()

   501     {

   502     iDataOwners.ResetAndDestroy();

   503     iDataOwners.Close();

   504     }   

   505     

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

   507 // CSConListPublicFiles::CSConListPublicFiles()

   508 // 

   509 // -----------------------------------------------------------------------------

   510 //  

   511 CSConListPublicFiles::CSConListPublicFiles()

   512     {

   513     }

   514     

   515 // -----------------------------------------------------------------------------

   516 // CSConListPublicFiles::~CSConListPublicFiles()

   517 // 

   518 // -----------------------------------------------------------------------------

   519 //          

   520 CSConListPublicFiles::~CSConListPublicFiles()

   521     {

   522     iFiles.ResetAndDestroy();

   523     iFiles.Close();

   524     

   525     iDataOwners.ResetAndDestroy();

   526     iDataOwners.Close();

   527     }

   528 

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

   530 // CSConListPublicFiles::CopyL()

   531 // 

   532 // -----------------------------------------------------------------------------

   533 //              

   534 CSConListPublicFiles* CSConListPublicFiles::CopyL()

   535     {

   536     CSConListPublicFiles* copy = new (ELeave) CSConListPublicFiles();

   537     CleanupStack::PushL( copy );

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

   539         {

   540         CSConFile* temp = iFiles[i]->CopyL();

   541         CleanupStack::PushL( temp );

   542         copy->iFiles.AppendL( temp );

   543         CleanupStack::Pop( temp );

   544         }

   545         

   546     for( TInt j = 0; j < iDataOwners.Count(); j++ )

   547         {

   548         CSConDataOwner* temp = iDataOwners[j]->CopyL();

   549         CleanupStack::PushL( temp );

   550         copy->iDataOwners.AppendL( temp );

   551         CleanupStack::Pop( temp );

   552         }

   553     CleanupStack::Pop( copy );

   554     

   555     copy->iComplete = iComplete;

   556     copy->iProgress = iProgress;

   557         

   558     return copy;

   559     }

   560 

   561 // -----------------------------------------------------------------------------

   562 // CSConRequestData::CSConRequestData()

   563 // 

   564 // -----------------------------------------------------------------------------

   565 //

   566 CSConRequestData::CSConRequestData()

   567     {

   568     iDataOwner = new CSConDataOwner();

   569     }

   570             

   571 // -----------------------------------------------------------------------------

   572 // CSConRequestData::~CSConRequestData()

   573 // 

   574 // -----------------------------------------------------------------------------

   575 //

   576 CSConRequestData::~CSConRequestData()

   577     {

   578     if ( iDataOwner )

   579         {

   580         delete iDataOwner;

   581         iDataOwner = NULL;

   582         }

   583         

   584     if ( iBackupData )

   585         {

   586         delete iBackupData;

   587         iBackupData = NULL;

   588         }

   589     }

   590     

   591 // -----------------------------------------------------------------------------

   592 // CSConRequestData::Copy()

   593 // 

   594 // -----------------------------------------------------------------------------

   595 //          

   596 CSConRequestData* CSConRequestData::CopyL()

   597     {

   598     CSConRequestData* copy = new (ELeave) CSConRequestData();

   599     

   600     if ( iDataOwner )

   601         {

   602         if ( copy->iDataOwner )

   603             {

   604             delete copy->iDataOwner;

   605             copy->iDataOwner = NULL;

   606             }

   607         copy->iDataOwner = iDataOwner->CopyL();

   608         }

   609     

   610     copy->iComplete = iComplete;

   611     copy->iProgress = iProgress;

   612         

   613     if ( iBackupData )

   614         {

   615         if ( copy->iBackupData )

   616             {

   617             delete copy->iBackupData;

   618             copy->iBackupData = NULL;

   619             }

   620         copy->iBackupData = iBackupData->Alloc();

   621         }

   622         

   623     copy->iMoreData = iMoreData;

   624     

   625     return copy;

   626     }

   627 

   628 // -----------------------------------------------------------------------------

   629 // CSConRequestData::DeleteDataAndDataOwner()

   630 // 

   631 // -----------------------------------------------------------------------------

   632 //          

   633 void CSConRequestData::DeleteDataAndDataOwner()

   634     {

   635     if ( iDataOwner )

   636         {

   637         delete iDataOwner;

   638         iDataOwner = NULL;

   639         }

   640     

   641     if ( iBackupData )

   642         {

   643         delete iBackupData;

   644         iBackupData = NULL;

   645         }

   646     }

   647 

   648 // -----------------------------------------------------------------------------

   649 // CSConGetDataOwnerStatus::CSConGetDataOwnerStatus()

   650 // 

   651 // -----------------------------------------------------------------------------

   652 //      

   653 CSConGetDataOwnerStatus::CSConGetDataOwnerStatus()

   654     {

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CSConGetDataOwnerStatus::~CSConGetDataOwnerStatus()

   659 // 

   660 // -----------------------------------------------------------------------------

   661 //              

   662 CSConGetDataOwnerStatus::~CSConGetDataOwnerStatus()

   663     {

   664     iDataOwners.ResetAndDestroy();

   665     iDataOwners.Close();

   666     }

   667 

   668 // -----------------------------------------------------------------------------

   669 // CSConGetDataOwnerStatus::Copy()

   670 // 

   671 // -----------------------------------------------------------------------------

   672 //              

   673 CSConGetDataOwnerStatus* CSConGetDataOwnerStatus::CopyL()

   674     {

   675     CSConGetDataOwnerStatus* copy = new (ELeave) CSConGetDataOwnerStatus();

   676     CleanupStack::PushL( copy );

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

   678         {

   679         CSConDataOwner* temp = iDataOwners[i]->CopyL();

   680         CleanupStack::PushL( temp );

   681         copy->iDataOwners.AppendL( temp );

   682         CleanupStack::Pop( temp );

   683         }           

   684     CleanupStack::Pop( copy );

   685     

   686     copy->iComplete = iComplete;

   687     copy->iProgress = iProgress;

   688         

   689     return copy;

   690     }

   691 

   692 // -----------------------------------------------------------------------------

   693 // CSConGetDataOwnerStatus::DeleteDataOwners()

   694 // 

   695 // -----------------------------------------------------------------------------

   696 //              

   697 void CSConGetDataOwnerStatus::DeleteDataOwners()

   698     {

   699     iDataOwners.ResetAndDestroy();

   700     iDataOwners.Close();

   701     }

   702     

   703 // -----------------------------------------------------------------------------

   704 // CSConSupplyData::CSConSupplyData()

   705 // 

   706 // -----------------------------------------------------------------------------

   707 //  

   708 CSConSupplyData::CSConSupplyData()

   709     {

   710     iDataOwner = new CSConDataOwner();

   711     }

   712     

   713 // -----------------------------------------------------------------------------

   714 // CSConSupplyData::~CSConSupplyData()

   715 // 

   716 // -----------------------------------------------------------------------------

   717 //          

   718 CSConSupplyData::~CSConSupplyData()

   719     {

   720     if ( iDataOwner )

   721         {

   722         delete iDataOwner;

   723         iDataOwner = NULL;

   724         }

   725     

   726     if ( iRestoreData )

   727         {

   728         delete iRestoreData;

   729         iRestoreData = NULL;

   730         }

   731     }

   732     

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

   734 // CSConSupplyData::Copy()

   735 // 

   736 // -----------------------------------------------------------------------------

   737 //          

   738 CSConSupplyData* CSConSupplyData::CopyL()

   739     {

   740     CSConSupplyData* copy = new (ELeave) CSConSupplyData();

   741     CleanupStack::PushL( copy );

   742     

   743     copy->iComplete = iComplete;

   744     copy->iProgress = iProgress;

   745         

   746     if ( iDataOwner )

   747         {

   748         if ( copy->iDataOwner )

   749             {

   750             delete copy->iDataOwner;

   751             copy->iDataOwner = NULL;

   752             }

   753             

   754         copy->iDataOwner = iDataOwner->CopyL();

   755         }

   756     CleanupStack::Pop( copy ); 

   757         

   758     if ( iRestoreData )

   759         {

   760         if ( copy->iRestoreData )

   761             {

   762             delete copy->iRestoreData;

   763             copy->iRestoreData = NULL;

   764             }

   765             

   766         copy->iRestoreData = iRestoreData->Alloc();

   767         }

   768     

   769     copy->iMoreData = iMoreData;    

   770     

   771     return copy;

   772     }

   773 

   774 // -----------------------------------------------------------------------------

   775 // CSConGetMetadata::CSConGetMetadata()

   776 // 

   777 // -----------------------------------------------------------------------------

   778 //  

   779 CSConGetMetadata::CSConGetMetadata()

   780     {

   781     }

   782     

   783 // -----------------------------------------------------------------------------

   784 // CSConGetMetadata::~CSConGetMetadata()

   785 // 

   786 // -----------------------------------------------------------------------------

   787 //          

   788 CSConGetMetadata::~CSConGetMetadata()

   789     {

   790     delete iData;

   791     }

   792     

   793 // -----------------------------------------------------------------------------

   794 // CSConGetMetadata::Copy()

   795 // 

   796 // -----------------------------------------------------------------------------

   797 //          

   798 CSConGetMetadata* CSConGetMetadata::CopyL()

   799     {

   800     CSConGetMetadata* copy = new (ELeave) CSConGetMetadata();

   801     

   802     copy->iFilename = iFilename;

   803     

   804     if ( iData )

   805         {

   806         if ( copy->iData )

   807             {

   808             delete copy->iData;

   809             copy->iData = NULL;

   810             }

   811         

   812         copy->iData = iData->Alloc();

   813         }

   814     

   815     copy->iMoreData = iMoreData;

   816     copy->iComplete = iComplete;

   817     copy->iProgress = iProgress;

   818     

   819     return copy;

   820     }

   821 

   822 

   823 // -----------------------------------------------------------------------------

   824 // CSConTask::NewL( TSConMethodName aMethod )

   825 // 

   826 // -----------------------------------------------------------------------------

   827 //

   828 CSConTask* CSConTask::NewL( TSConMethodName aMethod )

   829     {

   830     CSConTask* self = NewLC( aMethod );

   831     CleanupStack::Pop( self );

   832     return self;

   833     }

   834 

   835 // -----------------------------------------------------------------------------

   836 // CSConTask::NewLC( TSConMethodName aMethod )

   837 // 

   838 // -----------------------------------------------------------------------------

   839 //

   840 CSConTask* CSConTask::NewLC( TSConMethodName aMethod )

   841     {

   842     CSConTask* self = new (ELeave) CSConTask();

   843     CleanupStack::PushL( self );

   844     self->ConstructL( aMethod );

   845     return self;

   846     }

   847 

   848 // -----------------------------------------------------------------------------

   849 // CSConTask::ConstructL( TSConMethodName aMethod )

   850 // Initializes member data

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

   852 //

   853 void CSConTask::ConstructL( TSConMethodName aMethod )

   854     {

   855     iMethod = aMethod;

   856     

   857     switch( aMethod )

   858         {

   859         case ECancel :

   860             break;

   861         case EGetDataOwnerStatus :

   862             iGetDataOwnerParams = new (ELeave) CSConGetDataOwnerStatus();

   863             break;

   864         case EGetDataSize :

   865             iGetDataSizeParams = new (ELeave) CSConGetDataSize();

   866             break;

   867         case EGetStatus :

   868             iGetStatusParams = new (ELeave) CSConGetStatus();

   869             break;

   870         case EInstall :

   871             iInstallParams = new (ELeave) CSConInstall();

   872             break;

   873         case EListDataOwners :

   874             iListDataOwnersParams = new (ELeave) CSConListDataOwners();

   875             break;

   876         case EListInstalledApps :

   877             iListAppsParams = new (ELeave) CSConListInstApps();

   878             break;

   879         case EListPublicFiles :

   880             iPubFilesParams = new (ELeave) CSConListPublicFiles();

   881             break;

   882         case ERequestData :

   883             iRequestDataParams = new (ELeave) CSConRequestData();

   884             break;

   885         case ESetBURMode :

   886             iBURModeParams = new (ELeave) CSConSetBURMode();

   887             break;

   888         case ESetInstParams :

   889             break;

   890         case ESupplyData :

   891             iSupplyDataParams = new (ELeave) CSConSupplyData();

   892             break;

   893         case EUninstall :

   894             iUninstallParams = new (ELeave) CSConUninstall();

   895             break;

   896         case EUpdateDeviceInfo :

   897             iDevInfoParams = new (ELeave) CSConUpdateDeviceInfo();

   898             break;

   899         case EReboot :

   900             iRebootParams = new (ELeave) CSConReboot();

   901             break;

   902         case EGetMetadata :

   903             iGetMetadataParams = new (ELeave) CSConGetMetadata();

   904             break;

   905         default :

   906             break;

   907         }

   908     }

   909 // -----------------------------------------------------------------------------

   910 // CSConTask::CSConTask()

   911 // 

   912 // -----------------------------------------------------------------------------

   913 //      

   914 CSConTask::CSConTask()

   915     {

   916     }

   917 

   918 // -----------------------------------------------------------------------------

   919 // CSConTask::~CSConTask()

   920 // 

   921 // -----------------------------------------------------------------------------

   922 //          

   923 CSConTask::~CSConTask()

   924     {

   925     delete iDevInfoParams;

   926     delete iListAppsParams;

   927     delete iGetStatusParams;

   928     delete iInstallParams;

   929     delete iUninstallParams;

   930     delete iBURModeParams;

   931     delete iGetDataSizeParams;

   932     delete iRequestDataParams;

   933     delete iGetDataOwnerParams;

   934     delete iSupplyDataParams;

   935     delete iPubFilesParams;

   936     delete iListDataOwnersParams;

   937     delete iRebootParams;

   938     delete iGetMetadataParams;

   939     }

   940 

   941 // -----------------------------------------------------------------------------

   942 // CSConTask::GetServiceId() const

   943 // 

   944 // -----------------------------------------------------------------------------

   945 //          

   946 TSConMethodName CSConTask::GetServiceId() const

   947     { 

   948     return iMethod; 

   949     }

   950 

   951 // -----------------------------------------------------------------------------

   952 // CSConTask::Copy() const

   953 // 

   954 // -----------------------------------------------------------------------------

   955 //          

   956 CSConTask* CSConTask::CopyL() const

   957     {

   958     CSConTask* copy = new (ELeave) CSConTask();

   959     copy->iMethod = iMethod;

   960     

   961     if ( iDevInfoParams )

   962         {

   963         copy->iDevInfoParams = iDevInfoParams->CopyL();

   964         }

   965     if ( iListAppsParams )

   966         {

   967         copy->iListAppsParams = iListAppsParams->CopyL();

   968         }

   969     if ( iGetStatusParams ) 

   970         {

   971         

   972         }

   973     if ( iInstallParams )

   974         {

   975         copy->iInstallParams = iInstallParams->CopyL();

   976         }

   977     if ( iUninstallParams )

   978         {

   979         copy->iUninstallParams = iUninstallParams->CopyL();

   980         }

   981     if ( iBURModeParams )

   982         {

   983         copy->iBURModeParams = iBURModeParams->CopyL();

   984         }

   985     if ( iGetDataSizeParams )

   986         {

   987         copy->iGetDataSizeParams = iGetDataSizeParams->CopyL();

   988         }

   989     if ( iRequestDataParams )

   990         {

   991         copy->iRequestDataParams = iRequestDataParams->CopyL();

   992         }

   993     if ( iGetDataOwnerParams )

   994         {

   995         copy->iGetDataOwnerParams = iGetDataOwnerParams->CopyL();

   996         }

   997     if ( iSupplyDataParams )

   998         {

   999         copy->iSupplyDataParams = iSupplyDataParams->CopyL();

  1000         }

  1001     if ( iPubFilesParams )

  1002         {

  1003         copy->iPubFilesParams = iPubFilesParams->CopyL();

  1004         }

  1005     if ( iListDataOwnersParams )

  1006         {

  1007         copy->iListDataOwnersParams = iListDataOwnersParams->CopyL();

  1008         }

  1009     if ( iRebootParams )

  1010         {

  1011         copy->iRebootParams = iRebootParams->CopyL();

  1012         }

  1013     if ( iGetMetadataParams )

  1014         {

  1015         copy->iGetMetadataParams = iGetMetadataParams->CopyL();

  1016         }

  1017     

  1018     return copy;

  1019     }

  1020             

  1021 // -----------------------------------------------------------------------------

  1022 // CSConTask::GetComplete()

  1023 // 

  1024 // -----------------------------------------------------------------------------

  1025 //  

  1026 TBool CSConTask::GetComplete()

  1027     {

  1028     TBool complete( EFalse );

  1029     

  1030     switch( iMethod )

  1031         {

  1032         case EInstall :

  1033             complete = this->iInstallParams->iComplete;

  1034             break;

  1035         case EUninstall :

  1036             complete =  this->iUninstallParams->iComplete;

  1037             break;

  1038         case EListInstalledApps :

  1039             complete =  this->iListAppsParams->iComplete;

  1040             break;

  1041         case ESetInstParams :

  1042             break;

  1043         case ESetBURMode :

  1044             complete = this->iBURModeParams->iComplete;

  1045             break;

  1046         case EListPublicFiles :

  1047             complete = this->iPubFilesParams->iComplete;

  1048             break;

  1049         case EListDataOwners :

  1050             complete = this->iListDataOwnersParams->iComplete;

  1051             break;

  1052         case EGetDataSize :

  1053             complete = this->iGetDataSizeParams->iComplete;

  1054             break;

  1055         case EReboot :

  1056             complete = this->iRebootParams->iComplete;

  1057             break;

  1058         case ERequestData :

  1059             //If task is partially completed, 

  1060             //it can be removed from the queue

  1061             if ( this->iRequestDataParams->iProgress == KSConTaskPartiallyCompleted )

  1062                 {

  1063                 complete = ETrue;

  1064                 }

  1065             else

  1066                 {

  1067                 complete = this->iRequestDataParams->iComplete;

  1068                 }

  1069             

  1070             break;

  1071         case EGetDataOwnerStatus :

  1072             complete = this->iGetDataOwnerParams->iComplete;

  1073             break;

  1074         case ESupplyData :

  1075             //If task is partially completed, 

  1076             //it can be removed from the queue

  1077             if ( this->iSupplyDataParams->iProgress == KSConTaskPartiallyCompleted )

  1078                 {

  1079                 complete = ETrue;

  1080                 }

  1081             else

  1082                 {

  1083                 complete = this->iSupplyDataParams->iComplete;

  1084                 }

  1085             

  1086             break;

  1087         case EGetMetadata :

  1088             complete = this->iGetMetadataParams->iComplete;

  1089             break;

  1090         default :

  1091             break;                      

  1092         }

  1093     

  1094     return complete;

  1095     }

  1096     

  1097 // -----------------------------------------------------------------------------

  1098 // CSConTask::SetCompleteValue( TBool aValue )

  1099 // 

  1100 // -----------------------------------------------------------------------------

  1101 //          

  1102 void CSConTask::SetCompleteValue( TBool aValue )   

  1103     {

  1104     switch( iMethod )

  1105         {

  1106         case EInstall :

  1107             this->iInstallParams->iComplete = aValue;

  1108             break;

  1109         case EUninstall :

  1110             this->iUninstallParams->iComplete = aValue;         

  1111             break;

  1112         case EListInstalledApps :

  1113             this->iListAppsParams->iComplete = aValue;

  1114             break;

  1115         case ESetInstParams :

  1116             this->iInstallParams->iComplete = aValue;

  1117             break;

  1118         case ESetBURMode :

  1119             this->iBURModeParams->iComplete = aValue;

  1120             break;

  1121         case EListPublicFiles :

  1122             this->iPubFilesParams->iComplete = aValue;

  1123             break;

  1124         case EListDataOwners :

  1125             this->iListDataOwnersParams->iComplete = aValue;

  1126             break;

  1127         case EGetDataSize :

  1128             this->iGetDataSizeParams->iComplete = aValue;

  1129             break;

  1130         case EReboot :

  1131             this->iRebootParams->iComplete = aValue;

  1132             break;

  1133         case ERequestData :

  1134             this->iRequestDataParams->iComplete = aValue;