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:  CSConBackupRestore implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <pathinfo.h>

    21 

    22 #include "sconbackuprestore.h"

    23 #include "sconsbeclient.h"

    24 #include "sconbrqueue.h"

    25 #include "sconpcdconsts.h"

    26 

    27 #include "debug.h"

    28 

    29 // ============================= MEMBER FUNCTIONS ===============================

    30 

    31 

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

    33 // CSConBackupRestore* CSConBackupRestore::NewL( CSConBackupRestoreQueue* aQueue,

    34 //                                          cost TInt& aMaxObjectSize )

    35 // Two-phase constructor

    36 // -----------------------------------------------------------------------------

    37 //

    38 CSConBackupRestore* CSConBackupRestore::NewL( CSConBackupRestoreQueue* aQueue,

    39                                               RFs& aFs )

    40     {

    41     CSConBackupRestore* self = new (ELeave) CSConBackupRestore( aQueue, aFs );

    42     CleanupStack::PushL( self );

    43     self->ConstructL();

    44     CleanupStack::Pop( self );

    45     return self;

    46     }

    47 

    48 // -----------------------------------------------------------------------------

    49 // CSConBackupRestore::CSConBackupRestore( CSConBackupRestoreQueue* aQueue )

    50 // Constructor

    51 // -----------------------------------------------------------------------------

    52 //

    53 CSConBackupRestore::CSConBackupRestore( CSConBackupRestoreQueue* aQueue, RFs& aFs ) : 

    54             CActive( EPriorityStandard ), iQueue( aQueue ), iFs( aFs )

    55     {

    56     CActiveScheduler::Add( this );

    57     }

    58     

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

    60 // CSConBackupRestore::ConstructL( const TInt aMaxObjectSize )

    61 // Initializes member data

    62 // -----------------------------------------------------------------------------

    63 //

    64 void CSConBackupRestore::ConstructL()

    65     {

    66     iSBEClient = CSConSBEClient::NewL( iFs );

    67     }   

    68     

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

    70 // CSConBackupRestore::~CSConBackupRestore()

    71 // Destructor

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

    73 //

    74 CSConBackupRestore::~CSConBackupRestore()

    75     {

    76     if( iSBEClient )

    77         {

    78         iSBEClient->Cancel();

    79         delete iSBEClient;

    80         iSBEClient = NULL;

    81         }

    82     }

    83     

    84 // -----------------------------------------------------------------------------

    85 // CSConBackupRestore::StartBackupRestore( TInt aTaskId )

    86 // Starts backup-restore task

    87 // -----------------------------------------------------------------------------

    88 //

    89 void CSConBackupRestore::StartBackupRestore( TInt aTaskId )

    90     {

    91     iBackupRestoreActive = ETrue;

    92     CSConTask* task = NULL;

    93     

    94     TInt ret = iQueue->GetTask( aTaskId, task );

    95 

    96     if( aTaskId > 0 && ret != KErrNotFound )

    97         {

    98         iCurrentTask = aTaskId;

    99         iQueue->SetTaskProgress( aTaskId, KSConCodeProcessingStarted );

   100         }

   101     

   102     switch( task->GetServiceId() )

   103         {

   104         case ESetBURMode :

   105             iQueue->ChangeQueueProcessStatus();

   106             iSBEClient->SetBURMode( iStatus, task );

   107             break;

   108         case EListPublicFiles :

   109             iSBEClient->ListPublicFiles( iStatus, task );

   110             break;

   111         case EListDataOwners :

   112             iSBEClient->ListDataOwners( iStatus, task );

   113             break;

   114         case EGetDataSize :

   115             iSBEClient->GetDataSize( iStatus, task );

   116             break;

   117         case ERequestData :

   118             iSBEClient->RequestData( iStatus, task );

   119             break;

   120         case EGetDataOwnerStatus :

   121             iSBEClient->GetDataOwnerStatus( iStatus, task );

   122             break;

   123         case ESupplyData :

   124             iSBEClient->SupplyData( iStatus, task );

   125             break;      

   126         default :

   127             break;

   128         }

   129     

   130     SetActive();    

   131     }

   132 

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

   134 // CSConBackupRestore::StopBackupRestore( TInt aTaskId )

   135 // Stops executing backup-restore task

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

   137 //

   138 void CSConBackupRestore::StopBackupRestore( TInt aTaskId )

   139     {

   140     TRACE_FUNC_ENTRY;

   141      //if the task is active, do cancel

   142      if( iCurrentTask == aTaskId )

   143         {

   144         iBackupRestoreActive = EFalse;

   145         iSBEClient->Cancel();

   146         }

   147     TRACE_FUNC_EXIT;

   148     }

   149 

   150 // -----------------------------------------------------------------------------

   151 // CSConBackupRestore::Reset()

   152 // Resets backup

   153 // -----------------------------------------------------------------------------

   154 //  

   155 void CSConBackupRestore::Reset()

   156     {

   157     TRACE_FUNC_ENTRY;

   158     if( iSBEClient )

   159         {

   160         iSBEClient->Cancel();

   161         delete iSBEClient;

   162         iSBEClient = NULL;

   163         }

   164         

   165     TRAP_IGNORE( iSBEClient = CSConSBEClient::NewL( iFs ) );

   166     

   167     iBackupRestoreActive = EFalse;

   168     TRACE_FUNC_EXIT;

   169     }

   170 

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

   172 // CSConBackupRestore::BackupRestoreActive()

   173 // returns backup-restore activity status

   174 // -----------------------------------------------------------------------------

   175 //

   176 TBool CSConBackupRestore::BackupRestoreActive() const

   177 	{

   178 	return iBackupRestoreActive;

   179 	}

   180 // -----------------------------------------------------------------------------

   181 // CSConBackupRestore::DoCancel()

   182 // Implementation of CActive::DoCancel()

   183 // -----------------------------------------------------------------------------

   184 //  

   185 void CSConBackupRestore::DoCancel()

   186     {

   187     TRACE_FUNC;

   188     }

   189 

   190 // -----------------------------------------------------------------------------

   191 // CSConBackupRestore::RunL()

   192 // Implementation of CActive::RunL()

   193 // -----------------------------------------------------------------------------

   194 //          

   195 void CSConBackupRestore::RunL()

   196     {

   197     TRACE_FUNC;

   198     iQueue->CompleteTask( iCurrentTask, iStatus.Int() );

   199     iBackupRestoreActive = EFalse;

   200     }

   201     

   202 // End of file