1 /*

     2 * Copyright (c) 2005 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: MMCScBkupSBEUtils implementation

    15 *

    16 *

    17 */

    18 

    19 #include "MMCScBkupSBEUtils.h"

    20 

    21 // System includes

    22 #include <e32property.h>

    23 #include <connect/sbdefs.h>

    24 #include "CMMCScBkupDataOwnerInfo.h"

    25 

    26 // Namespaces

    27 using namespace conn;

    28 

    29 

    30 

    31 // ========================= MEMBER FUNCTIONS ================================

    32 

    33 // ---------------------------------------------------------------------------

    34 // MMCScBkupSBEUtils::SecureIdFromGenericL()

    35 // 

    36 // 

    37 // ---------------------------------------------------------------------------

    38 TSecureId MMCScBkupSBEUtils::SecureIdFromGenericL(const CSBGenericDataType& aGeneric)

    39     {

    40     TSecureId ret = 0;

    41     CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aGeneric);

    42     const TSBDerivedType type = aGeneric.DerivedTypeL();

    43     //

    44     switch(type)

    45         {

    46     case ESIDDerivedType:

    47         {

    48         CSBSecureId* temp = CSBSecureId::NewL( nonConstOriginal );

    49         CleanupStack::PushL( temp );

    50         ret = temp->SecureIdL();

    51         CleanupStack::PopAndDestroy( temp );

    52         break;

    53         }

    54     case ESIDTransferDerivedType:

    55         {

    56         // First make a generic transfer type object...

    57         CSBGenericTransferType* transferTypeTemp = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

    58         CleanupStack::PushL(transferTypeTemp);

    59 

    60         // Now make instance transfer type

    61         CSBSIDTransferType* temp = CSBSIDTransferType::NewL( transferTypeTemp );

    62         CleanupStack::PushL(temp);

    63 

    64         // Now get the result

    65         ret = temp->SecureIdL();

    66 

    67         // Tidy up

    68         CleanupStack::PopAndDestroy(2, transferTypeTemp);

    69         break;

    70         }

    71     case EPackageDerivedType:

    72         {

    73         CSBPackageId* temp = CSBPackageId::NewL( nonConstOriginal );

    74         CleanupStack::PushL( temp );

    75         ret = temp->SecureIdL();

    76         CleanupStack::PopAndDestroy( temp );

    77         break;

    78         }

    79     case EPackageTransferDerivedType:

    80     case EJavaDerivedType:

    81     case EJavaTransferDerivedType:

    82     default:

    83         __BREAKPOINT();

    84         User::Leave(KErrNotSupported);

    85         break;

    86        }

    87     //

    88     return ret;

    89     }

    90 

    91 

    92 // ---------------------------------------------------------------------------

    93 // MMCScBkupSBEUtils::PackageIdFromGenericL()

    94 // 

    95 // 

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

    97 TUid MMCScBkupSBEUtils::PackageIdFromGenericL(const CSBGenericDataType& aGeneric)

    98     {

    99     TUid ret = KNullUid;

   100     CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aGeneric);

   101     const TSBDerivedType type = aGeneric.DerivedTypeL();

   102     //

   103     switch(type)

   104         {

   105     case EPackageDerivedType:

   106         {

   107         CSBPackageId* temp = CSBPackageId::NewL( nonConstOriginal );

   108         CleanupStack::PushL(temp);

   109         ret = temp->PackageIdL();

   110         CleanupStack::PopAndDestroy(temp);

   111         break;

   112         }

   113     case EPackageTransferDerivedType:

   114         {

   115         // First make a generic transfer type object...

   116         CSBGenericTransferType* transferTypeTemp = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

   117         CleanupStack::PushL(transferTypeTemp);

   118 

   119         // Now make instance transfer type

   120         CSBPackageTransferType* temp = CSBPackageTransferType::NewL( transferTypeTemp );

   121         CleanupStack::PushL(temp);

   122 

   123         // Now get the result

   124         ret = temp->PackageIdL();

   125 

   126         // Tidy up

   127         CleanupStack::PopAndDestroy(2, transferTypeTemp);

   128         break;

   129         }

   130     case ESIDDerivedType:

   131     case ESIDTransferDerivedType:

   132     case EJavaDerivedType:

   133     case EJavaTransferDerivedType:

   134     default:

   135         __BREAKPOINT();

   136         User::Leave(KErrNotSupported);

   137         break;

   138        }

   139     //

   140     return ret;

   141     }

   142 

   143 

   144 // ---------------------------------------------------------------------------

   145 // MMCScBkupSBEUtils::JavaHashFromGenericLC()

   146 // 

   147 // 

   148 // ---------------------------------------------------------------------------

   149 HBufC* MMCScBkupSBEUtils::JavaHashFromGenericLC(const CSBGenericDataType& aGeneric)

   150     {

   151     HBufC* ret = NULL;

   152     CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aGeneric);

   153     const TSBDerivedType type = aGeneric.DerivedTypeL();

   154     //

   155     switch(type)

   156         {

   157     case EJavaDerivedType:

   158         {

   159         CSBJavaId* temp = CSBJavaId::NewL( nonConstOriginal );

   160         CleanupStack::PushL(temp);

   161         ret = temp->SuiteHashL().AllocL();

   162         CleanupStack::PopAndDestroy(temp);

   163         CleanupStack::PushL( ret );

   164         break;

   165         }

   166     case EJavaTransferDerivedType:

   167         {

   168         // First make a generic transfer type object...

   169         CSBGenericTransferType* transferTypeTemp = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

   170         CleanupStack::PushL(transferTypeTemp);

   171 

   172         // Now make a instance transfer type

   173         CSBJavaTransferType* temp = CSBJavaTransferType::NewL( transferTypeTemp );

   174         CleanupStack::PushL(temp);

   175 

   176         // Now get the result

   177         ret = temp->SuiteHashL().AllocL();

   178 

   179         // Tidy up

   180         CleanupStack::PopAndDestroy(2, transferTypeTemp);

   181         CleanupStack::PushL( ret );

   182         break;

   183         }

   184     case ESIDDerivedType:

   185     case ESIDTransferDerivedType:

   186     case EPackageDerivedType:

   187     case EPackageTransferDerivedType:

   188     default:

   189         __BREAKPOINT();

   190         User::Leave(KErrNotSupported);

   191         break;

   192        }

   193     //

   194     if  ( ret == NULL )

   195         {

   196         ret = KNullDesC().AllocLC();

   197         }

   198     //

   199     return ret;

   200     }

   201 

   202 

   203 // ---------------------------------------------------------------------------

   204 // MMCScBkupSBEUtils::CopyLC()

   205 // 

   206 // 

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

   208 CSBGenericDataType* MMCScBkupSBEUtils::CopyLC(const CSBGenericDataType& aToBeCopied)

   209     {

   210     CSBGenericDataType* ret = NULL;

   211 

   212     // Have to do this through poor implementation of SBE API 

   213     CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aToBeCopied);

   214     //

   215     const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

   216     switch(type)

   217         {

   218     case ESIDDerivedType:

   219         ret = CSBSecureId::NewL(nonConstOriginal);

   220         break;

   221     case EPackageDerivedType:

   222         ret = CSBPackageId::NewL(nonConstOriginal);

   223         break;

   224     case EJavaDerivedType:

   225         ret = CSBJavaId::NewL(nonConstOriginal);

   226         break;

   227     case ESIDTransferDerivedType:

   228     case EPackageTransferDerivedType:

   229     case EJavaTransferDerivedType:

   230         {

   231         // Must first create a generic transfer type object... sigh...

   232         CSBGenericTransferType* transferType = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

   233         CleanupStack::PushL( transferType );

   234         switch(type)

   235             {

   236         case ESIDTransferDerivedType:

   237             ret = CSBSIDTransferType::NewL( transferType );

   238             break;

   239         case EPackageTransferDerivedType:

   240             ret = CSBPackageTransferType::NewL( transferType );

   241             break;

   242         case EJavaTransferDerivedType:

   243             ret = CSBJavaTransferType::NewL( transferType );

   244             break;

   245         default:

   246             break;

   247             }

   248         CleanupStack::PopAndDestroy( transferType );

   249         }

   250     default:

   251         break;

   252        }

   253     //

   254     if  (!ret)

   255         {

   256         __BREAKPOINT();

   257         User::Leave(KErrNotSupported);

   258         }

   259     CleanupStack::PushL(ret);

   260     return ret;

   261     }

   262 

   263 

   264 // ---------------------------------------------------------------------------

   265 // MMCScBkupSBEUtils::TransferTypeLC()

   266 // 

   267 // 

   268 // ---------------------------------------------------------------------------

   269 CSBGenericTransferType* MMCScBkupSBEUtils::TransferTypeLC( const CSBGenericDataType& aDT, TDriveNumber aDrive, 

   270     TTransferDataType aTransferType, TInt aVersion )

   271     {

   272     CSBGenericTransferType* ret = NULL;

   273 

   274     // Have to do this through poor implementation of SBE API 

   275     CSBGenericDataType* nonConstOriginal = const_cast< CSBGenericDataType* >( &aDT );

   276     //

   277     const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

   278     switch( type )

   279         {

   280     case ESIDDerivedType:

   281     case ESIDTransferDerivedType:

   282         {

   283         const TSecureId secureId = SecureIdFromGenericL( aDT );

   284         ret = CSBSIDTransferType::NewL( secureId, aDrive, aTransferType );

   285         break;

   286         }

   287 

   288     case EPackageDerivedType:

   289         {

   290         TSecureId secureId = SecureIdFromGenericL( aDT );

   291         if( secureId.iId == KNullUid.iUid && aVersion > CMMCScBkupDataOwnerInfo::EStreamFormatVersionFirst )

   292             {

   293             secureId = MMCScBkupSBEUtils::PackageIdFromGenericL( aDT );

   294             }

   295         ret = CSBSIDTransferType::NewL( secureId, aDrive, aTransferType );

   296         break;

   297         }

   298 

   299     default:

   300     case EPackageTransferDerivedType:

   301     case EJavaDerivedType:

   302     case EJavaTransferDerivedType:

   303         __BREAKPOINT();

   304         User::Leave( KErrNotSupported );

   305         break;

   306         }

   307     //

   308     CleanupStack::PushL( ret );

   309     return ret;

   310     }

   311 

   312 

   313 // ---------------------------------------------------------------------------

   314 // MMCScBkupSBEUtils::TransferTypeLC()

   315 // 

   316 // 

   317 // ---------------------------------------------------------------------------

   318 CSBGenericTransferType* MMCScBkupSBEUtils::TransferTypeLC(const CSBGenericDataType& aDT, TDriveNumber aDrive, 

   319     TPackageDataType aDataType, TInt /*aVersion*/)

   320     {

   321     CSBGenericTransferType* ret = NULL;

   322 

   323     // Have to do this through poor implementation of SBE API 

   324     CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aDT);

   325     //

   326     const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

   327     switch(type)

   328         {

   329     case EPackageDerivedType:

   330     case EPackageTransferDerivedType:

   331         {

   332         const TUid packageId = PackageIdFromGenericL(aDT);

   333         ret = CSBPackageTransferType::NewL(packageId, aDrive, aDataType);

   334         break;

   335         }

   336 

   337     default:

   338     case ESIDDerivedType:

   339     case ESIDTransferDerivedType:

   340     case EJavaDerivedType:

   341     case EJavaTransferDerivedType:

   342         __BREAKPOINT();

   343         User::Leave(KErrNotSupported);

   344         break;

   345         }

   346     //

   347     CleanupStack::PushL(ret);

   348     return ret;

   349     }

   350 

   351 

   352 // ---------------------------------------------------------------------------

   353 // MMCScBkupSBEUtils::TransferTypeLC()

   354 // 

   355 // 

   356 // ---------------------------------------------------------------------------

   357 CSBGenericTransferType* MMCScBkupSBEUtils::TransferTypeLC(const CSBGenericDataType& aDT, TDriveNumber aDrive, 

   358     TJavaTransferType aDataType, TInt /*aVersion*/)

   359     {

   360     CSBGenericTransferType* ret = NULL;

   361 

   362     // Have to do this through poor implementation of SBE API 

   363     CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aDT);

   364     //

   365     const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

   366     switch(type)

   367         {

   368     case EJavaDerivedType:

   369     case EJavaTransferDerivedType:

   370         {

   371         HBufC* hash = JavaHashFromGenericLC( aDT );

   372         ret = CSBJavaTransferType::NewL( *hash, aDrive, aDataType );

   373         CleanupStack::PopAndDestroy( hash );

   374         break;

   375         }

   376 

   377     default:

   378     case ESIDDerivedType:

   379     case ESIDTransferDerivedType:

   380     case EPackageDerivedType:

   381     case EPackageTransferDerivedType:

   382         __BREAKPOINT();

   383         User::Leave(KErrNotSupported);

   384         break;

   385         }

   386     //

   387     CleanupStack::PushL(ret);

   388     return ret;

   389     }

   390 

   391 

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

   393 // MMCScBkupSBEUtils::PhoneIsInBackupOrRestoreModeL()

   394 // 

   395 // 

   396 // ---------------------------------------------------------------------------

   397 TBool MMCScBkupSBEUtils::PhoneIsInBackupOrRestoreModeL()

   398     {

   399     TBool backupInProgress = EFalse;

   400     //

   401     TInt value = 0;

   402     const TInt error = RProperty::Get( KUidSystemCategory, KUidBackupRestoreKey, value );

   403     User::LeaveIfError( error );

   404     //

   405     const TBURPartType partType = static_cast< TBURPartType >( value & KBURPartTypeMask );

   406     if  (value != 0)

   407         {

   408         switch(partType)

   409             {

   410         case EBURUnset:

   411         case EBURNormal:

   412             break;

   413         case EBURBackupFull:

   414         case EBURBackupPartial:

   415         case EBURRestoreFull:

   416         case EBURRestorePartial:

   417             backupInProgress = ETrue;

   418             break;

   419             }

   420         }

   421     //

   422     return backupInProgress;

   423     }

   424 

   425 

   426 // ---------------------------------------------------------------------------

   427 // MMCScBkupSBEUtils::EndBackupOrRestoreL()

   428 // 

   429 // 

   430 // ---------------------------------------------------------------------------

   431 void MMCScBkupSBEUtils::EndBackupOrRestoreL( CSBEClient& aSBEClient )

   432     {

   433     TDriveList nullDriveList;

   434     aSBEClient.SetBURModeL( nullDriveList, EBURNormal, ENoBackup);

   435     }

   436 

   437 

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

   439 // MMCScBkupSBEUtils::HasSystemDataL()

   440 // 

   441 // 

   442 // ---------------------------------------------------------------------------

   443 TBool MMCScBkupSBEUtils::HasSystemDataL( const CDataOwnerInfo& aDataOwner )

   444     {

   445     const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

   446     const TBool systemDataType = ( type == EPackageDerivedType || 

   447                                    type == EPackageTransferDerivedType );

   448     const TBool hasSystemData = ( aDataOwner.CommonSettings() & EHasSystemFiles );

   449     //

   450     return ( systemDataType && hasSystemData );

   451     }

   452 

   453 

   454 // ---------------------------------------------------------------------------

   455 // MMCScBkupSBEUtils::HasJavaDataL()

   456 // 

   457 // 

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

   459 TBool MMCScBkupSBEUtils::HasJavaDataL( const CDataOwnerInfo& aDataOwner )

   460     {

   461     const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

   462     const TBool javaDataType = ( type == EJavaDerivedType || 

   463                                  type == EJavaTransferDerivedType );

   464     const TBool hasSystemData = ( aDataOwner.CommonSettings() & EHasSystemFiles );

   465 

   466     // Java abuses the "has system files flag" - this has been confirmed

   467     // with Symbian.

   468     return ( javaDataType && hasSystemData );

   469     }

   470 

   471 

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

   473 // MMCScBkupSBEUtils::HasPassiveDataL()

   474 // 

   475 // 

   476 // ---------------------------------------------------------------------------

   477 TBool MMCScBkupSBEUtils::HasPassiveDataL( const CDataOwnerInfo& aDataOwner )

   478     {

   479     const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

   480     const TBool passiveDataType = ( type == ESIDDerivedType || 

   481                                     type == ESIDTransferDerivedType ||

   482                                     type == EPackageDerivedType || 

   483                                     type == EPackageTransferDerivedType );

   484     const TBool hasPassiveData = ( aDataOwner.CommonSettings() & EPassiveBUR );

   485     //

   486     return ( passiveDataType && hasPassiveData );

   487     }

   488 

   489 

   490 // ---------------------------------------------------------------------------

   491 // MMCScBkupSBEUtils::HasActiveDataL()

   492 // 

   493 // 

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

   495 TBool MMCScBkupSBEUtils::HasActiveDataL( const CDataOwnerInfo& aDataOwner )

   496     {

   497     const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

   498     const TBool activeDataType = ( type == ESIDDerivedType || 

   499                                    type == ESIDTransferDerivedType ||

   500                                    type == EPackageDerivedType || 

   501                                    type == EPackageTransferDerivedType );

   502     const TBool hasActiveData = ( aDataOwner.CommonSettings() & EActiveBUR );

   503     //

   504     return ( activeDataType && hasActiveData );

   505     }

   506 

   507 

   508 // ---------------------------------------------------------------------------

   509 // MMCScBkupSBEUtils::HasPublicDataL()

   510 // 

   511 // 

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

   513 TBool MMCScBkupSBEUtils::HasPublicDataL( const CDataOwnerInfo& aDataOwner )

   514     {

   515     const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

   516     const TBool publicDataType = ( type == ESIDDerivedType || 

   517                                    type == ESIDTransferDerivedType ||

   518                                    type == EPackageDerivedType || 

   519                                    type == EPackageTransferDerivedType );

   520     const TBool hasPublicData = ( aDataOwner.PassiveSettings() & EHasPublicFiles );

   521     //

   522     return ( hasPublicData && publicDataType );

   523     }

   524