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() : iComplete( EFalse ), iProgress( 0 )

    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     copy->iType = iType;

    89     copy->iUid = iUid;

    90     copy->iDriveList.Copy( iDriveList );

    91     copy->iPackageName = iPackageName;

    92     copy->iReqReboot = iReqReboot;

    93     copy->iHasFiles = iHasFiles;

    94     copy->iSupportsInc = iSupportsInc;

    95     copy->iSupportsSel = iSupportsSel;

    96     copy->iDelayToPrep = iDelayToPrep;

    97     copy->iSize = iSize;

    98     copy->iDataOwnStatus = iDataOwnStatus;

    99     copy->iTransDataType = iTransDataType;

   100     

   101     if ( iJavaHash )

   102         {

   103         if ( copy->iJavaHash )

   104             {

   105             delete copy->iJavaHash;

   106             copy->iJavaHash = NULL;

   107             }

   108         copy->iJavaHash = iJavaHash->Alloc();

   109         }

   110                         

   111     return copy;

   112     }

   113     

   114 // -----------------------------------------------------------------------------

   115 // CSConUpdateDeviceInfo::CSConUpdateDeviceInfo()

   116 // 

   117 // -----------------------------------------------------------------------------

   118 //  

   119 CSConUpdateDeviceInfo::CSConUpdateDeviceInfo() : 

   120             iInstallSupp(EFalse), iUninstallSupp(EFalse), 

   121             iInstParamsSupp(EFalse), iInstAppsSupp(EFalse), 

   122             iDataOwnersSupp(EFalse), iSetBURModeSupp(EFalse),

   123             iGetSizeSupp(EFalse), iReqDataSupp(EFalse), 

   124             iSupplyDataSupp(EFalse), iRebootSupp(EFalse),

   125             iComplete( EFalse ), iProgress( 0 )

   126     {

   127     }

   128     

   129 // -----------------------------------------------------------------------------

   130 // CSConUpdateDeviceInfo::~CSConUpdateDeviceInfo()

   131 // 

   132 // -----------------------------------------------------------------------------

   133 //           

   134 CSConUpdateDeviceInfo::~CSConUpdateDeviceInfo()

   135     {

   136     }

   137 

   138 // -----------------------------------------------------------------------------

   139 // CSConUpdateDeviceInfo::Copy()

   140 // 

   141 // -----------------------------------------------------------------------------

   142 //          

   143 CSConUpdateDeviceInfo* CSConUpdateDeviceInfo::CopyL()

   144     {

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

   146     copy->iVersion.Copy( iVersion );

   147     copy->iInstallSupp = iInstallSupp;

   148     copy->iUninstallSupp = iUninstallSupp;

   149     copy->iInstParamsSupp = iInstParamsSupp;

   150     copy->iInstAppsSupp = iInstAppsSupp;

   151     copy->iDataOwnersSupp = iDataOwnersSupp;

   152     copy->iSetBURModeSupp = iSetBURModeSupp;

   153     copy->iGetSizeSupp = iGetSizeSupp;

   154     copy->iReqDataSupp = iReqDataSupp;

   155     copy->iSupplyDataSupp = iSupplyDataSupp;

   156     copy->iMaxObjectSize = iMaxObjectSize;

   157     copy->iRebootSupp = iRebootSupp;

   158     copy->iComplete = iComplete;

   159     copy->iProgress = iProgress;        

   160                 

   161     return copy;

   162     }

   163 

   164 CSConInstApp::~CSConInstApp()

   165     {

   166     delete iWidgetBundleId;

   167     }

   168 // -----------------------------------------------------------------------------

   169 // CSConInstApp::Copy()

   170 // 

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

   172 //  

   173 CSConInstApp* CSConInstApp::CopyL()

   174     {

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

   176             

   177     copy->iName.Copy( iName ); 

   178     copy->iParentName.Copy( iParentName );

   179     copy->iVendor.Copy( iVendor );

   180     copy->iVersion.Copy( iVersion );

   181     copy->iSize = iSize;

   182     copy->iType = iType;

   183     copy->iUid = iUid;

   184     if ( iWidgetBundleId )

   185         {

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

   187         }

   188     else

   189         {

   190         copy->iWidgetBundleId = NULL;

   191         }

   192 

   193     return copy;

   194     }

   195 

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

   197 // CSConListInstApps::CSConListInstApps()

   198 // 

   199 // -----------------------------------------------------------------------------

   200 //      

   201 CSConListInstApps::CSConListInstApps() : iComplete( EFalse ), iProgress( 0 )

   202     {

   203     //Initialize iDriveList with zeros

   204     iDriveList.Fill( '\x0' );

   205     }

   206 

   207 // -----------------------------------------------------------------------------

   208 // CSConListInstApps::~CSConListInstApps()

   209 // 

   210 // -----------------------------------------------------------------------------

   211 //      

   212 CSConListInstApps::~CSConListInstApps()

   213     {

   214     iApps.ResetAndDestroy();

   215     iApps.Close();

   216     }

   217 

   218 // -----------------------------------------------------------------------------

   219 // CSConListInstApps::CopyL()

   220 // 

   221 // -----------------------------------------------------------------------------

   222 //              

   223 CSConListInstApps* CSConListInstApps::CopyL()

   224     {

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

   226     copy->iAllApps = iAllApps;

   227     copy->iDriveList = iDriveList;

   228             

   229     copy->iComplete = iComplete;

   230     copy->iProgress = iProgress;            

   231         

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

   233         {

   234         copy->iApps.Append( iApps[i]->CopyL() );

   235         }

   236             

   237     return copy;

   238     }

   239 

   240 // -----------------------------------------------------------------------------

   241 // CSConFile::CSConFile

   242 // 

   243 // -----------------------------------------------------------------------------

   244 //  

   245 CSConFile::CSConFile()

   246     {

   247     }

   248     

   249 // -----------------------------------------------------------------------------

   250 // CSConFile::~CSConFile

   251 // 

   252 // -----------------------------------------------------------------------------

   253 //  

   254 CSConFile::~CSConFile()

   255     {

   256     

   257     }

   258     

   259 // -----------------------------------------------------------------------------

   260 // CSConFile::Copy()

   261 // 

   262 // -----------------------------------------------------------------------------

   263 //  

   264 CSConFile* CSConFile::CopyL()

   265     {

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

   267             

   268     copy->iPath.Copy( iPath ); 

   269     copy->iModified.Copy( iModified );

   270     copy->iSize = iSize;

   271     copy->iUserPerm = iUserPerm;

   272 

   273     return copy;

   274     }

   275 

   276 // -----------------------------------------------------------------------------

   277 // CSConInstall::CSConInstall()

   278 // 

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

   280 //      

   281 CSConInstall::CSConInstall() : iMode( EUnknown ), iComplete( EFalse ), iProgress( 0 ) 

   282     {

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // CSConInstall::~CSConInstall()

   287 // 

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

   289 //              

   290 CSConInstall::~CSConInstall()

   291     {

   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     return copy;

   309     }

   310 

   311 // -----------------------------------------------------------------------------

   312 // CSConUninstall::CSConUninstall()

   313 // 

   314 // -----------------------------------------------------------------------------

   315 //  

   316 CSConUninstall::CSConUninstall() : iMode( EUnknown ), iComplete( EFalse ), iProgress( 0 )

   317     {

   318     }

   319 

   320 // -----------------------------------------------------------------------------

   321 // CSConUninstall::~CSConUninstall()

   322 // 

   323 // -----------------------------------------------------------------------------

   324 //          

   325 CSConUninstall::~CSConUninstall()

   326     {

   327     }

   328 

   329 // -----------------------------------------------------------------------------

   330 // CSConUninstall::Copy()

   331 // 

   332 // -----------------------------------------------------------------------------

   333 //          

   334 CSConUninstall* CSConUninstall::CopyL()

   335     {

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

   337     copy->iName = iName;

   338     copy->iVendor = iVendor;

   339     copy->iUid = iUid;

   340     copy->iMode = iMode;

   341             

   342     copy->iComplete = iComplete;

   343     copy->iProgress = iProgress;

   344             

   345     return copy;

   346     }

   347 

   348 // -----------------------------------------------------------------------------

   349 // CSConListDataOwners::CSConListDataOwners()

   350 // 

   351 // -----------------------------------------------------------------------------

   352 //      

   353 CSConListDataOwners::CSConListDataOwners() : iComplete( EFalse ), iProgress( 0 )

   354     {

   355     }

   356     

   357 // -----------------------------------------------------------------------------

   358 // CSConListDataOwners::~CSConListDataOwners()

   359 // 

   360 // -----------------------------------------------------------------------------

   361 //          

   362 CSConListDataOwners::~CSConListDataOwners()

   363     {

   364     iDataOwners.ResetAndDestroy();

   365     iDataOwners.Close();

   366     }

   367 

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

   369 // CSConListDataOwners::CopyL()

   370 // 

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

   372 //              

   373 CSConListDataOwners* CSConListDataOwners::CopyL()

   374     {

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

   376     CleanupStack::PushL( copy );

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

   378         {

   379         copy->iDataOwners.Append( iDataOwners[i]->CopyL() );

   380         }

   381     CleanupStack::Pop( copy );

   382     

   383     copy->iComplete = iComplete;

   384     copy->iProgress = iProgress;

   385         

   386     return copy;

   387     }

   388     

   389 // -----------------------------------------------------------------------------

   390 // CSConListDataOwners::DeleteDataOwners()

   391 // 

   392 // -----------------------------------------------------------------------------

   393 //          

   394 void CSConListDataOwners::DeleteDataOwners()

   395     {

   396     iDataOwners.ResetAndDestroy();

   397     iDataOwners.Close();

   398     }

   399     

   400 // -----------------------------------------------------------------------------

   401 // CCSConSetBURMode::CSConSetBURMode()

   402 // 

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

   404 //      

   405 CSConSetBURMode::CSConSetBURMode() : iComplete( EFalse ), iProgress( 0 )

   406     {

   407     //Initialize iDriveList with zeros

   408     iDriveList.Fill( '\x0' );

   409     }

   410         

   411 // -----------------------------------------------------------------------------

   412 // CSConSetBURMode::~CSConSetBURMode()

   413 // 

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

   415 //      

   416 CSConSetBURMode::~CSConSetBURMode()

   417     {

   418     }

   419     

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

   421 // CSConSetBURMode::Copy()

   422 // 

   423 // -----------------------------------------------------------------------------

   424 //      

   425 CSConSetBURMode* CSConSetBURMode::CopyL()

   426     {

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

   428     copy->iDriveList.Copy( iDriveList );

   429     copy->iPartialType = iPartialType;

   430     copy->iIncType = iIncType;

   431             

   432     copy->iComplete = iComplete;

   433     copy->iProgress = iProgress;

   434 

   435     return copy;

   436     }

   437 

   438 // -----------------------------------------------------------------------------

   439 // CSConGetDataSize::CSConGetDataSize()

   440 // 

   441 // -----------------------------------------------------------------------------

   442 //          

   443 CSConGetDataSize::CSConGetDataSize() : iComplete( EFalse ), iProgress( 0 )

   444     {

   445     }

   446 

   447 // -----------------------------------------------------------------------------

   448 // CSConGetDataSize::~CSConGetDataSize()

   449 // 

   450 // -----------------------------------------------------------------------------

   451 //      

   452 CSConGetDataSize::~CSConGetDataSize()

   453     {

   454     iDataOwners.ResetAndDestroy();

   455     iDataOwners.Close();

   456     }

   457         

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

   459 // CSConGetDataSize::Copy()

   460 // 

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

   462 //      

   463 CSConGetDataSize* CSConGetDataSize::CopyL()

   464     {

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

   466     CleanupStack::PushL( copy );

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

   468         {

   469         copy->iDataOwners.Append( iDataOwners[i]->CopyL() );

   470         }

   471     CleanupStack::Pop( copy );

   472     copy->iComplete = iComplete;

   473     copy->iProgress = iProgress;

   474         

   475     return copy;

   476     }

   477     

   478 // -----------------------------------------------------------------------------

   479 // CSConGetDataSize::DeleteDataOwners()

   480 // 

   481 // -----------------------------------------------------------------------------

   482 //              

   483 void CSConGetDataSize::DeleteDataOwners()

   484     {

   485     iDataOwners.ResetAndDestroy();

   486     iDataOwners.Close();

   487     }   

   488     

   489 // -----------------------------------------------------------------------------

   490 // CSConListPublicFiles::CSConListPublicFiles()

   491 // 

   492 // -----------------------------------------------------------------------------

   493 //  

   494 CSConListPublicFiles::CSConListPublicFiles() : iComplete( EFalse ), iProgress( 0 )

   495     {

   496     }

   497     

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

   499 // CSConListPublicFiles::~CSConListPublicFiles()

   500 // 

   501 // -----------------------------------------------------------------------------

   502 //          

   503 CSConListPublicFiles::~CSConListPublicFiles()

   504     {

   505     iFiles.ResetAndDestroy();

   506     iFiles.Close();

   507     

   508     iDataOwners.ResetAndDestroy();

   509     iDataOwners.Close();

   510     }

   511 

   512 // -----------------------------------------------------------------------------

   513 // CSConListPublicFiles::CopyL()

   514 // 

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

   516 //              

   517 CSConListPublicFiles* CSConListPublicFiles::CopyL()

   518     {

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

   520     CleanupStack::PushL( copy );

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

   522         {

   523         copy->iFiles.Append( iFiles[i]->CopyL() );

   524         }

   525         

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

   527         {

   528         copy->iDataOwners.Append( iDataOwners[j]->CopyL() );

   529         }

   530     CleanupStack::Pop( copy );

   531     

   532     copy->iComplete = iComplete;

   533     copy->iProgress = iProgress;

   534         

   535     return copy;

   536     }

   537 

   538 // -----------------------------------------------------------------------------

   539 // CSConRequestData::CSConRequestData()

   540 // 

   541 // -----------------------------------------------------------------------------

   542 //

   543 CSConRequestData::CSConRequestData() : iDataOwner( NULL ), iBackupData( NULL ), 

   544     iMoreData( EFalse ), iComplete( EFalse ), iProgress( 0 )

   545     {

   546     iDataOwner = new CSConDataOwner();

   547     }

   548             

   549 // -----------------------------------------------------------------------------

   550 // CSConRequestData::~CSConRequestData()

   551 // 

   552 // -----------------------------------------------------------------------------

   553 //

   554 CSConRequestData::~CSConRequestData()

   555     {

   556     if ( iDataOwner )

   557         {

   558         delete iDataOwner;

   559         iDataOwner = NULL;

   560         }

   561         

   562     if ( iBackupData )

   563         {

   564         delete iBackupData;

   565         iBackupData = NULL;

   566         }

   567     }

   568     

   569 // -----------------------------------------------------------------------------

   570 // CSConRequestData::Copy()

   571 // 

   572 // -----------------------------------------------------------------------------

   573 //          

   574 CSConRequestData* CSConRequestData::CopyL()

   575     {

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

   577     

   578     if ( iDataOwner )

   579         {

   580         if ( copy->iDataOwner )

   581             {

   582             delete copy->iDataOwner;

   583             copy->iDataOwner = NULL;

   584             }

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

   586         }

   587     

   588     copy->iComplete = iComplete;

   589     copy->iProgress = iProgress;

   590         

   591     if ( iBackupData )

   592         {

   593         if ( copy->iBackupData )

   594             {

   595             delete copy->iBackupData;

   596             copy->iBackupData = NULL;

   597             }

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

   599         }

   600         

   601     copy->iMoreData = iMoreData;

   602     

   603     return copy;

   604     }

   605 

   606 // -----------------------------------------------------------------------------

   607 // CSConRequestData::DeleteDataAndDataOwner()

   608 // 

   609 // -----------------------------------------------------------------------------

   610 //          

   611 void CSConRequestData::DeleteDataAndDataOwner()

   612     {

   613     if ( iDataOwner )

   614         {

   615         delete iDataOwner;

   616         iDataOwner = NULL;

   617         }

   618     

   619     if ( iBackupData )

   620         {

   621         delete iBackupData;

   622         iBackupData = NULL;

   623         }

   624     }

   625 

   626 // -----------------------------------------------------------------------------

   627 // CSConGetDataOwnerStatus::CSConGetDataOwnerStatus()

   628 // 

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

   630 //      

   631 CSConGetDataOwnerStatus::CSConGetDataOwnerStatus() : iComplete( EFalse ), iProgress( 0 )

   632     {

   633     }

   634 

   635 // -----------------------------------------------------------------------------

   636 // CSConGetDataOwnerStatus::~CSConGetDataOwnerStatus()

   637 // 

   638 // -----------------------------------------------------------------------------

   639 //              

   640 CSConGetDataOwnerStatus::~CSConGetDataOwnerStatus()

   641     {

   642     iDataOwners.ResetAndDestroy();

   643     iDataOwners.Close();

   644     }

   645 

   646 // -----------------------------------------------------------------------------

   647 // CSConGetDataOwnerStatus::Copy()

   648 // 

   649 // -----------------------------------------------------------------------------

   650 //              

   651 CSConGetDataOwnerStatus* CSConGetDataOwnerStatus::CopyL()

   652     {

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

   654     CleanupStack::PushL( copy );

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

   656         {

   657         copy->iDataOwners.Append( iDataOwners[i]->CopyL() );

   658         }           

   659     CleanupStack::Pop( copy );

   660     

   661     copy->iComplete = iComplete;

   662     copy->iProgress = iProgress;

   663         

   664     return copy;

   665     }

   666 

   667 // -----------------------------------------------------------------------------

   668 // CSConGetDataOwnerStatus::DeleteDataOwners()

   669 // 

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

   671 //              

   672 void CSConGetDataOwnerStatus::DeleteDataOwners()

   673     {

   674     iDataOwners.ResetAndDestroy();

   675     iDataOwners.Close();

   676     }

   677     

   678 // -----------------------------------------------------------------------------

   679 // CSConSupplyData::CSConSupplyData()

   680 // 

   681 // -----------------------------------------------------------------------------

   682 //  

   683 CSConSupplyData::CSConSupplyData() : iDataOwner( NULL ), iRestoreData( NULL ),

   684     iComplete( EFalse ), iProgress( 0 )

   685     {

   686     iDataOwner = new CSConDataOwner();

   687     }

   688     

   689 // -----------------------------------------------------------------------------

   690 // CSConSupplyData::~CSConSupplyData()

   691 // 

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

   693 //          

   694 CSConSupplyData::~CSConSupplyData()

   695     {

   696     if ( iDataOwner )

   697         {

   698         delete iDataOwner;

   699         iDataOwner = NULL;

   700         }

   701     

   702     if ( iRestoreData )

   703         {

   704         delete iRestoreData;

   705         iRestoreData = NULL;

   706         }

   707     }

   708     

   709 // -----------------------------------------------------------------------------

   710 // CSConSupplyData::Copy()

   711 // 

   712 // -----------------------------------------------------------------------------

   713 //          

   714 CSConSupplyData* CSConSupplyData::CopyL()

   715     {

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

   717     CleanupStack::PushL( copy );

   718     

   719     copy->iComplete = iComplete;

   720     copy->iProgress = iProgress;

   721         

   722     if ( iDataOwner )

   723         {

   724         if ( copy->iDataOwner )

   725             {

   726             delete copy->iDataOwner;

   727             copy->iDataOwner = NULL;

   728             }

   729             

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

   731         }

   732     CleanupStack::Pop( copy ); 

   733         

   734     if ( iRestoreData )

   735         {

   736         if ( copy->iRestoreData )

   737             {

   738             delete copy->iRestoreData;

   739             copy->iRestoreData = NULL;

   740             }

   741             

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

   743         }

   744     

   745     copy->iMoreData = iMoreData;    

   746     

   747     return copy;

   748     }

   749 

   750 // -----------------------------------------------------------------------------

   751 // CSConGetMetadata::CSConGetMetadata()

   752 // 

   753 // -----------------------------------------------------------------------------

   754 //  

   755 CSConGetMetadata::CSConGetMetadata() : iData( NULL ),

   756     iMoreData( EFalse ), iComplete( EFalse ), iProgress( 0 )

   757     {

   758     }

   759     

   760 // -----------------------------------------------------------------------------

   761 // CSConGetMetadata::~CSConGetMetadata()

   762 // 

   763 // -----------------------------------------------------------------------------

   764 //          

   765 CSConGetMetadata::~CSConGetMetadata()

   766     {

   767     if ( iData )

   768         {

   769         delete iData;

   770         iData = NULL;

   771         }

   772     }

   773     

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

   775 // CSConGetMetadata::Copy()

   776 // 

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

   778 //          

   779 CSConGetMetadata* CSConGetMetadata::CopyL()

   780     {

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

   782     

   783     copy->iFilename = iFilename;

   784     

   785     if ( iData )

   786         {

   787         if ( copy->iData )

   788             {

   789             delete copy->iData;

   790             copy->iData = NULL;

   791             }

   792         

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

   794         }

   795     

   796     copy->iMoreData = iMoreData;

   797     copy->iComplete = iComplete;

   798     copy->iProgress = iProgress;

   799     

   800     return copy;

   801     }

   802 

   803 

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

   805 // CSConTask::NewL( TSConMethodName aMethod )

   806 // 

   807 // -----------------------------------------------------------------------------

   808 //

   809 CSConTask* CSConTask::NewL( TSConMethodName aMethod )

   810     {

   811     CSConTask* self = NewLC( aMethod );

   812     CleanupStack::Pop( self );

   813     return self;

   814     }

   815 

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

   817 // CSConTask::NewLC( TSConMethodName aMethod )

   818 // 

   819 // -----------------------------------------------------------------------------

   820 //

   821 CSConTask* CSConTask::NewLC( TSConMethodName aMethod )

   822     {

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

   824     CleanupStack::PushL( self );

   825     self->ConstructL( aMethod );

   826     return self;

   827     }

   828 

   829 // -----------------------------------------------------------------------------

   830 // CSConTask::ConstructL( TSConMethodName aMethod )

   831 // Initializes member data

   832 // -----------------------------------------------------------------------------

   833 //

   834 void CSConTask::ConstructL( TSConMethodName aMethod )

   835     {

   836     iMethod = aMethod;

   837     

   838     switch( aMethod )

   839         {

   840         case ECancel :

   841             break;

   842         case EGetDataOwnerStatus :

   843             iGetDataOwnerParams = new (ELeave) CSConGetDataOwnerStatus();

   844             break;

   845         case EGetDataSize :

   846             iGetDataSizeParams = new (ELeave) CSConGetDataSize();

   847             break;

   848         case EGetStatus :

   849             iGetStatusParams = new (ELeave) CSConGetStatus();

   850             break;

   851         case EInstall :

   852             iInstallParams = new (ELeave) CSConInstall();

   853             break;

   854         case EListDataOwners :

   855             iListDataOwnersParams = new (ELeave) CSConListDataOwners();

   856             break;

   857         case EListInstalledApps :

   858             iListAppsParams = new (ELeave) CSConListInstApps();

   859             break;

   860         case EListPublicFiles :

   861             iPubFilesParams = new (ELeave) CSConListPublicFiles();

   862             break;

   863         case ERequestData :

   864             iRequestDataParams = new (ELeave) CSConRequestData();

   865             break;

   866         case ESetBURMode :

   867             iBURModeParams = new (ELeave) CSConSetBURMode();

   868             break;

   869         case ESetInstParams :

   870             break;

   871         case ESupplyData :

   872             iSupplyDataParams = new (ELeave) CSConSupplyData();

   873             break;

   874         case EUninstall :

   875             iUninstallParams = new (ELeave) CSConUninstall();

   876             break;

   877         case EUpdateDeviceInfo :

   878             iDevInfoParams = new (ELeave) CSConUpdateDeviceInfo();

   879             break;

   880         case EReboot :

   881             iRebootParams = new (ELeave) CSConReboot();

   882             break;

   883         case EGetMetadata :

   884             iGetMetadataParams = new (ELeave) CSConGetMetadata();

   885             break;

   886         default :

   887             break;

   888         }

   889     }

   890 // -----------------------------------------------------------------------------

   891 // CSConTask::CSConTask()

   892 // 

   893 // -----------------------------------------------------------------------------

   894 //      

   895 CSConTask::CSConTask()

   896     {

   897     }

   898 

   899 // -----------------------------------------------------------------------------

   900 // CSConTask::~CSConTask()

   901 // 

   902 // -----------------------------------------------------------------------------

   903 //          

   904 CSConTask::~CSConTask()

   905     {

   906     delete iDevInfoParams;

   907     delete iListAppsParams;

   908     delete iGetStatusParams;

   909     delete iInstallParams;

   910     delete iUninstallParams;

   911     delete iBURModeParams;

   912     delete iGetDataSizeParams;

   913     delete iRequestDataParams;

   914     delete iGetDataOwnerParams;

   915     delete iSupplyDataParams;

   916     delete iPubFilesParams;

   917     delete iListDataOwnersParams;

   918     delete iRebootParams;

   919     delete iGetMetadataParams;

   920     }

   921 

   922 // -----------------------------------------------------------------------------

   923 // CSConTask::GetServiceId() const

   924 // 

   925 // -----------------------------------------------------------------------------

   926 //          

   927 TSConMethodName CSConTask::GetServiceId() const

   928     { 

   929     return iMethod; 

   930     }

   931 

   932 // -----------------------------------------------------------------------------

   933 // CSConTask::Copy() const

   934 // 

   935 // -----------------------------------------------------------------------------

   936 //          

   937 CSConTask* CSConTask::CopyL() const

   938     {

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

   940     copy->iMethod = iMethod;

   941     

   942     if ( iDevInfoParams )

   943         {

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

   945         }

   946     if ( iListAppsParams )

   947         {

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

   949         }

   950     if ( iGetStatusParams ) 

   951         {

   952         

   953         }

   954     if ( iInstallParams )

   955         {

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

   957         }

   958     if ( iUninstallParams )

   959         {

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

   961         }

   962     if ( iBURModeParams )

   963         {

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

   965         }

   966     if ( iGetDataSizeParams )

   967         {

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

   969         }

   970     if ( iRequestDataParams )

   971         {

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

   973         }

   974     if ( iGetDataOwnerParams )

   975         {

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

   977         }

   978     if ( iSupplyDataParams )

   979         {

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

   981         }

   982     if ( iPubFilesParams )

   983         {

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

   985         }

   986     if ( iListDataOwnersParams )

   987         {

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

   989         }

   990     if ( iRebootParams )

   991         {

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

   993         }

   994     if ( iGetMetadataParams )

   995         {

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

   997         }

   998     

   999     return copy;

  1000     }

  1001             

  1002 // -----------------------------------------------------------------------------

  1003 // CSConTask::GetComplete()

  1004 // 

  1005 // -----------------------------------------------------------------------------

  1006 //  

  1007 TBool CSConTask::GetComplete()

  1008     {

  1009     TBool complete( EFalse );

  1010     

  1011     switch( iMethod )

  1012         {

  1013         case EInstall :

  1014             complete = this->iInstallParams->iComplete;

  1015             break;

  1016         case EUninstall :

  1017             complete =  this->iUninstallParams->iComplete;

  1018             break;

  1019         case EListInstalledApps :

  1020             complete =  this->iListAppsParams->iComplete;

  1021             break;

  1022         case ESetInstParams :

  1023             break;

  1024         case ESetBURMode :

  1025             complete = this->iBURModeParams->iComplete;

  1026             break;

  1027         case EListPublicFiles :

  1028             complete = this->iPubFilesParams->iComplete;

  1029             break;

  1030         case EListDataOwners :

  1031             complete = this->iListDataOwnersParams->iComplete;

  1032             break;

  1033         case EGetDataSize :

  1034             complete = this->iGetDataSizeParams->iComplete;

  1035             break;

  1036         case EReboot :

  1037             complete = this->iRebootParams->iComplete;

  1038             break;

  1039         case ERequestData :

  1040             //If task is partially completed, 

  1041             //it can be removed from the queue

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

  1043                 {

  1044                 complete = ETrue;

  1045                 }

  1046             else

  1047                 {

  1048                 complete = this->iRequestDataParams->iComplete;

  1049                 }

  1050             

  1051             break;

  1052         case EGetDataOwnerStatus :

  1053             complete = this->iGetDataOwnerParams->iComplete;

  1054             break;

  1055         case ESupplyData :

  1056             //If task is partially completed, 

  1057             //it can be removed from the queue

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

  1059                 {

  1060                 complete = ETrue;

  1061                 }

  1062             else

  1063                 {

  1064                 complete = this->iSupplyDataParams->iComplete;

  1065                 }

  1066             

  1067             break;

  1068         case EGetMetadata :

  1069             complete = this->iGetMetadataParams->iComplete;

  1070             break;

  1071         default :

  1072             break;                      

  1073         }

  1074     

  1075     return complete;

  1076     }

  1077     

  1078 // -----------------------------------------------------------------------------

  1079 // CSConTask::SetCompleteValue( TBool aValue )

  1080 // 

  1081 // -----------------------------------------------------------------------------

  1082 //          

  1083 void CSConTask::SetCompleteValue( TBool aValue )   

  1084     {

  1085     switch( iMethod )

  1086         {

  1087         case EInstall :

  1088             this->iInstallParams->iComplete = aValue;

  1089             break;

  1090         case EUninstall :

  1091             this->iUninstallParams->iComplete = aValue;         

  1092             break;

  1093         case EListInstalledApps :

  1094             this->iListAppsParams->iComplete = aValue;

  1095             break;

  1096         case ESetInstParams :

  1097             this->iInstallParams->iComplete = aValue;

  1098             break;

  1099         case ESetBURMode :

  1100             this->iBURModeParams->iComplete = aValue;

  1101             break;

  1102         case EListPublicFiles :

  1103             this->iPubFilesParams->iComplete = aValue;

  1104             break;

  1105         case EListDataOwners :

  1106             this->iListDataOwnersParams->iComplete = aValue;

  1107             break;

  1108         case EGetDataSize :

  1109             this->iGetDataSizeParams->iComplete = aValue;

  1110             break;

  1111         case EReboot :

  1112             this->iRebootParams->iComplete = aValue;

  1113             break;

  1114         case ERequestData :

  1115             this->iRequestDataParams->iComplete = aValue;

  1116             break;

  1117         case EGetDataOwnerStatus :

  1118             this->iGetDataOwnerParams->iComplete = aValue;

  1119             break;

  1120         case ESupplyData :

  1121             this->iSupplyDataParams->iComplete = aValue;

  1122             break;

  1123         case EGetMetadata :

  1124             this->iGetMetadataParams->iComplete = aValue;

  1125             break;

  1126         default:

  1127             break;      

  1128         }

  1129     }

  1130         

  1131 // -----------------------------------------------------------------------------

  1132 // CSConTask::GetCompleteValue()

  1133 // 

  1134 // -----------------------------------------------------------------------------