filemanager/bkupengine/src/CMMCScBkupStateOpAware.cpp
branchRCL_3
changeset 38 491b3ed49290
parent 36 95243422089a
child 39 65326cf895ed
equal deleted inserted replaced
36:95243422089a 38:491b3ed49290
     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: CMMCScBkupStateOpAware implementation
       
    15 *
       
    16 *
       
    17 */
       
    18 
       
    19 #include "CMMCScBkupStateOpAware.h"
       
    20 
       
    21 
       
    22 
       
    23 
       
    24 // ========================= MEMBER FUNCTIONS ================================
       
    25 
       
    26 // ---------------------------------------------------------------------------
       
    27 // CMMCScBkupStateOpAware::CMMCScBkupStateOpAware()
       
    28 // 
       
    29 // C++ constructor.
       
    30 // ---------------------------------------------------------------------------
       
    31 CMMCScBkupStateOpAware::CMMCScBkupStateOpAware( MMMCScBkupDriver& aDriver, TInt aPriority )
       
    32 :   CMMCScBkupState( aDriver, aPriority )
       
    33     {
       
    34     }
       
    35 
       
    36 
       
    37 // ---------------------------------------------------------------------------
       
    38 // CMMCScBkupStateOpAware::NextStateId()
       
    39 // 
       
    40 // 
       
    41 // ---------------------------------------------------------------------------
       
    42 TMMCScBkupStateId CMMCScBkupStateOpAware::NextStateId() const
       
    43     {
       
    44     TMMCScBkupStateId state = KMMCScBkupStateIdOperationComplete;
       
    45     //
       
    46     const TMMCScBkupOperationType type = Driver().DrvOperation();
       
    47     switch(type)
       
    48         {
       
    49     case EMMCScBkupOperationTypeFullBackup:
       
    50     case EMMCScBkupOperationTypePartialBackup:
       
    51         state = NextStateBackupId( type == EMMCScBkupOperationTypePartialBackup );
       
    52         break;
       
    53     case EMMCScBkupOperationTypeFullRestore:
       
    54     case EMMCScBkupOperationTypePartialRestore:
       
    55         state = NextStateRestoreId( type == EMMCScBkupOperationTypePartialRestore );
       
    56         break;
       
    57     default:
       
    58         ASSERT( EFalse );
       
    59         break;
       
    60         }
       
    61     //
       
    62     return state;
       
    63     }
       
    64 
       
    65 
       
    66 // ---------------------------------------------------------------------------
       
    67 // CMMCScBkupStateOpAware::PerformAsynchronousStateStepBackupL()
       
    68 // 
       
    69 // 
       
    70 // ---------------------------------------------------------------------------
       
    71 void CMMCScBkupStateOpAware::PerformAsynchronousStateStepBackupL( TBool /*aPartial*/ )
       
    72     {
       
    73     }
       
    74 
       
    75 
       
    76 // ---------------------------------------------------------------------------
       
    77 // CMMCScBkupStateOpAware::PerformAsynchronousStateStepRestoreL()
       
    78 // 
       
    79 // 
       
    80 // ---------------------------------------------------------------------------
       
    81 void CMMCScBkupStateOpAware::PerformAsynchronousStateStepRestoreL( TBool /*aPartial*/ )
       
    82     {
       
    83     }
       
    84 
       
    85 
       
    86 // ---------------------------------------------------------------------------
       
    87 // CMMCScBkupStateOpAware::PerformAsynchronousCancellationBackup()
       
    88 // 
       
    89 // 
       
    90 // ---------------------------------------------------------------------------
       
    91 void CMMCScBkupStateOpAware::PerformAsynchronousCancellationBackup( TBool /*aPartial*/ )
       
    92     {
       
    93     }
       
    94 
       
    95 
       
    96 // ---------------------------------------------------------------------------
       
    97 // CMMCScBkupStateOpAware::PerformAsynchronousCancellationRestore()
       
    98 // 
       
    99 // 
       
   100 // ---------------------------------------------------------------------------
       
   101 void CMMCScBkupStateOpAware::PerformAsynchronousCancellationRestore( TBool /*aPartial*/ )
       
   102     {
       
   103     }
       
   104 
       
   105 
       
   106 // ---------------------------------------------------------------------------
       
   107 // CMMCScBkupStateOpAware::PerformLastRightsBackupL()
       
   108 // 
       
   109 // 
       
   110 // ---------------------------------------------------------------------------
       
   111 void CMMCScBkupStateOpAware::PerformLastRightsBackupL( TBool /*aPartial*/ )
       
   112     {
       
   113     }
       
   114 
       
   115 
       
   116 // ---------------------------------------------------------------------------
       
   117 // CMMCScBkupStateOpAware::PerformLastRightsRestoreL()
       
   118 // 
       
   119 // 
       
   120 // ---------------------------------------------------------------------------
       
   121 void CMMCScBkupStateOpAware::PerformLastRightsRestoreL( TBool /*aPartial*/ )
       
   122     {
       
   123     }
       
   124 
       
   125 
       
   126 // ---------------------------------------------------------------------------
       
   127 // CMMCScBkupStateOpAware::PerformAsynchronousErrorCleanupBackup()
       
   128 // 
       
   129 // 
       
   130 // ---------------------------------------------------------------------------
       
   131 TBool CMMCScBkupStateOpAware::PerformAsynchronousErrorCleanupBackup( TBool /*aPartial*/, TInt /*aError*/ )
       
   132     {
       
   133     return EFalse;
       
   134     }
       
   135 
       
   136 
       
   137 // ---------------------------------------------------------------------------
       
   138 // CMMCScBkupStateOpAware::PerformAsynchronousErrorCleanupRestore()
       
   139 // 
       
   140 // 
       
   141 // ---------------------------------------------------------------------------
       
   142 TBool CMMCScBkupStateOpAware::PerformAsynchronousErrorCleanupRestore( TBool /*aPartial*/, TInt /*aError*/ )
       
   143     {
       
   144     return EFalse;
       
   145     }
       
   146 
       
   147 
       
   148 // ---------------------------------------------------------------------------
       
   149 // CMMCScBkupStateOpAware::PerformStateInitL()
       
   150 // 
       
   151 // 
       
   152 // ---------------------------------------------------------------------------
       
   153 void CMMCScBkupStateOpAware::PerformStateInitL()
       
   154     {
       
   155     const TMMCScBkupOperationType type = Driver().DrvOperation();
       
   156     switch(type)
       
   157         {
       
   158     case EMMCScBkupOperationTypeFullBackup:
       
   159     case EMMCScBkupOperationTypePartialBackup:
       
   160         PerformStateInitBackupL( type == EMMCScBkupOperationTypePartialBackup );
       
   161         break;
       
   162     case EMMCScBkupOperationTypeFullRestore:
       
   163     case EMMCScBkupOperationTypePartialRestore:
       
   164         PerformStateInitRestoreL( type == EMMCScBkupOperationTypePartialRestore );
       
   165         break;
       
   166     default:
       
   167         ASSERT( EFalse );
       
   168         break;
       
   169         }
       
   170     }
       
   171 
       
   172 
       
   173 // ---------------------------------------------------------------------------
       
   174 // CMMCScBkupStateOpAware::PerformAsynchronousStateStepL()
       
   175 // 
       
   176 // 
       
   177 // ---------------------------------------------------------------------------
       
   178 void CMMCScBkupStateOpAware::PerformAsynchronousStateStepL()
       
   179     {
       
   180     const TMMCScBkupOperationType type = Driver().DrvOperation();
       
   181     switch(type)
       
   182         {
       
   183     case EMMCScBkupOperationTypeFullBackup:
       
   184     case EMMCScBkupOperationTypePartialBackup:
       
   185         PerformAsynchronousStateStepBackupL( type == EMMCScBkupOperationTypePartialBackup );
       
   186         break;
       
   187     case EMMCScBkupOperationTypeFullRestore:
       
   188     case EMMCScBkupOperationTypePartialRestore:
       
   189         PerformAsynchronousStateStepRestoreL( type == EMMCScBkupOperationTypePartialRestore );
       
   190         break;
       
   191     default:
       
   192         ASSERT( EFalse );
       
   193         break;
       
   194         }
       
   195     }
       
   196 
       
   197 
       
   198 // ---------------------------------------------------------------------------
       
   199 // CMMCScBkupStateOpAware::PerformAsynchronousCancellation()
       
   200 // 
       
   201 // 
       
   202 // ---------------------------------------------------------------------------
       
   203 void CMMCScBkupStateOpAware::PerformAsynchronousCancellation()
       
   204     {
       
   205     const TMMCScBkupOperationType type = Driver().DrvOperation();
       
   206     switch(type)
       
   207         {
       
   208     case EMMCScBkupOperationTypeFullBackup:
       
   209     case EMMCScBkupOperationTypePartialBackup:
       
   210         PerformAsynchronousCancellationBackup( type == EMMCScBkupOperationTypePartialBackup );
       
   211         break;
       
   212     case EMMCScBkupOperationTypeFullRestore:
       
   213     case EMMCScBkupOperationTypePartialRestore:
       
   214         PerformAsynchronousCancellationRestore( type == EMMCScBkupOperationTypePartialRestore );
       
   215         break;
       
   216     default:
       
   217         ASSERT( EFalse );
       
   218         break;
       
   219         }
       
   220     }
       
   221 
       
   222 
       
   223 // ---------------------------------------------------------------------------
       
   224 // CMMCScBkupStateOpAware::PerformLastRightsL()
       
   225 // 
       
   226 // 
       
   227 // ---------------------------------------------------------------------------
       
   228 void CMMCScBkupStateOpAware::PerformLastRightsL()
       
   229     {
       
   230     const TMMCScBkupOperationType type = Driver().DrvOperation();
       
   231     switch(type)
       
   232         {
       
   233     case EMMCScBkupOperationTypeFullBackup:
       
   234     case EMMCScBkupOperationTypePartialBackup:
       
   235         PerformLastRightsBackupL( type == EMMCScBkupOperationTypePartialBackup );
       
   236         break;
       
   237     case EMMCScBkupOperationTypeFullRestore:
       
   238     case EMMCScBkupOperationTypePartialRestore:
       
   239         PerformLastRightsRestoreL( type == EMMCScBkupOperationTypePartialRestore );
       
   240         break;
       
   241     default:
       
   242         ASSERT( EFalse );
       
   243         break;
       
   244         }
       
   245     }
       
   246 
       
   247 
       
   248 // ---------------------------------------------------------------------------
       
   249 // CMMCScBkupStateOpAware::PerformAsynchronousErrorCleanup()
       
   250 // 
       
   251 // 
       
   252 // ---------------------------------------------------------------------------
       
   253 TBool CMMCScBkupStateOpAware::PerformAsynchronousErrorCleanup( TInt aError )
       
   254     {
       
   255     TBool handled = EFalse;
       
   256     //
       
   257     const TMMCScBkupOperationType type = Driver().DrvOperation();
       
   258     switch(type)
       
   259         {
       
   260     case EMMCScBkupOperationTypeFullBackup:
       
   261     case EMMCScBkupOperationTypePartialBackup:
       
   262         handled = PerformAsynchronousErrorCleanupBackup( type == EMMCScBkupOperationTypePartialBackup, aError );
       
   263         break;
       
   264     case EMMCScBkupOperationTypeFullRestore:
       
   265     case EMMCScBkupOperationTypePartialRestore:
       
   266         handled = PerformAsynchronousErrorCleanupRestore( type == EMMCScBkupOperationTypePartialRestore, aError );
       
   267         break;
       
   268     default:
       
   269         ASSERT( EFalse );
       
   270         break;
       
   271         }
       
   272     //
       
   273     return handled;
       
   274     }
       
   275