Mercurial Mercurial > oss > FCL > sf > app > contentcontrol / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
connectivitymodules/SeCon/services/pcd/src/sconsbeclient.cpp
changeset 40 b63e67867dcd
parent 20 e1de7d03f843
equal deleted inserted replaced
39:9905f7d46607 40:b63e67867dcd 
     1 /*
 
     1 /*
 
     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     2 * Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3 * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4 * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6 * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    22 #include <mmf/common/mmfcontrollerpluginresolver.h>
 
    22 #include <mmf/common/mmfcontrollerpluginresolver.h>
 
    23 
    23 
    24 #include "sconsbeclient.h"
 
    24 #include "sconsbeclient.h"
 
    25 #include "debug.h"
 
    25 #include "debug.h"
 
    26 
    26 
    27 
    27 const TInt KDataBufExpandSize( 1024 );
 
       
    28 const TInt KMaxObjectSize( 1048576 - 1024 ); // Max chunk size is 1MB, but give some space for ConML wbxml
 
    28 _LIT( KSConNoDrive, "\x0" );
 
    29 _LIT( KSConNoDrive, "\x0" );
 
    29 _LIT( KSConDriveExists, "\x1" );
 
    30 _LIT( KSConDriveExists, "\x1" );
 
    30 // ============================= MEMBER FUNCTIONS ==============================
 
    31 // ============================= MEMBER FUNCTIONS ==============================
 
    31 
    32 
    32 // -----------------------------------------------------------------------------
 
    33 // -----------------------------------------------------------------------------
 
    33 // CSConSBEClient::NewL( cosnt TInt aMaxObjectSize )
 
    34 // CSConSBEClient::NewL( cosnt TInt aMaxObjectSize )
 
    34 // Two-phase constructor
 
    35 // Two-phase constructor
 
    35 // -----------------------------------------------------------------------------
 
    36 // -----------------------------------------------------------------------------
 
    36 //  
    37 //  
    37 CSConSBEClient* CSConSBEClient::NewL( const TInt aMaxObjectSize, RFs& aFs )
 
    38 CSConSBEClient* CSConSBEClient::NewL( RFs& aFs )
 
    38     {
 
    39     {
 
    39     TRACE_FUNC;
 
    40     TRACE_FUNC;
 
    40     CSConSBEClient* self = new (ELeave) CSConSBEClient( aMaxObjectSize, aFs );
 
    41     CSConSBEClient* self = new (ELeave) CSConSBEClient( aFs );
 
    41     return self;
 
    42     return self;
 
    42     }
 
    43     }
 
    43     
    44     
    44 // -----------------------------------------------------------------------------
 
    45 // -----------------------------------------------------------------------------
 
    45 // CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize )
 
    46 // CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize )
 
    46 // Constructor
 
    47 // Constructor
 
    47 // -----------------------------------------------------------------------------
 
    48 // -----------------------------------------------------------------------------
 
    48 //
 
    49 //
 
    49 CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize, RFs& aFs ) : 
    50 CSConSBEClient::CSConSBEClient( RFs& aFs ) : 
    50         CActive( EPriorityStandard ), iSBEClient(NULL), 
    51         CActive( EPriorityStandard ), iBURModeNormal( ETrue ), iFs( aFs )
 
    51         iProcessComplete(EFalse), iProcessIndex( 0 ), iDataPos( 0 ),
 
    52     {
 
    52         iDataLeft( EFalse ), iBURModeNormal( ETrue ),
 
    53     CActiveScheduler::Add( this );
 
    53         iRestoreMode( EFalse ), iFs( aFs )
 
       
    54     {
 
       
    55     iMaxObjectSize = aMaxObjectSize;
 
       
    56     }
 
    54     }
 
    57 
    55 
    58 // -----------------------------------------------------------------------------
 
    56 // -----------------------------------------------------------------------------
 
    59 // CSConSBEClient::~CSConSBEClient()
 
    57 // CSConSBEClient::~CSConSBEClient()
 
    60 // Initializes member data
 
    58 // Initializes member data
 
    61 // -----------------------------------------------------------------------------
 
    59 // -----------------------------------------------------------------------------
 
    62 //  
    60 //  
    63 CSConSBEClient::~CSConSBEClient()
 
    61 CSConSBEClient::~CSConSBEClient()
 
    64     {
 
    62     {
 
    65     TRACE_FUNC_ENTRY;
 
    63     TRACE_FUNC_ENTRY;
 
       
    64     Cancel();
 
    66     TInt err( KErrNone );
 
    65     TInt err( KErrNone );
 
    67     
    66     
    68     if( !iBURModeNormal && iSBEClient )
 
    67     if( !iBURModeNormal && iSBEClient )
 
    69         {
 
    68         {
 
    70         TDriveList driveList;
 
    69         TDriveList driveList;
 
    87     if( iSBEClient )
 
    86     if( iSBEClient )
 
    88         {
 
    87         {
 
    89         delete iSBEClient;
 
    88         delete iSBEClient;
 
    90         iSBEClient = NULL;
 
    89         iSBEClient = NULL;
 
    91         }
 
    90         }
 
       
    91     
       
    92     delete iDataBuffer;
 
    92     TRACE_FUNC_EXIT;
 
    93     TRACE_FUNC_EXIT;
 
    93     }
 
    94     }
 
    94 
    95 
    95 // -----------------------------------------------------------------------------
 
    96 // -----------------------------------------------------------------------------
 
    96 // CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )
 
    97 // CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )
 
   261         {
 
   262         {
 
   262         case ESetBURMode :
 
   263         case ESetBURMode :
 
   263             LOGGER_WRITE( "CSConSBEClient::RunL() : ESetBURMode" );
 
   264             LOGGER_WRITE( "CSConSBEClient::RunL() : ESetBURMode" );
 
   264             TRAP( err, ProcessSetBURModeL() );
 
   265             TRAP( err, ProcessSetBURModeL() );
 
   265             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessSetBURModeL() : returned %d", err );
 
   266             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessSetBURModeL() : returned %d", err );
 
   266             HandleSBEErrorL( err );
 
       
   267             User::RequestComplete( iCallerStatus, err );
 
       
   268             break;
 
   267             break;
 
   269         case EListPublicFiles :
 
   268         case EListPublicFiles :
 
   270             LOGGER_WRITE( "CSConSBEClient::RunL() : EListPublicFiles" );
 
   269             LOGGER_WRITE( "CSConSBEClient::RunL() : EListPublicFiles" );
 
   271             TRAP( err, ProcessListPublicFilesL() );
 
   270             TRAP( err, ProcessListPublicFilesL() );
 
   272             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListPublicFilesL() : returned %d", err );
 
   271             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListPublicFilesL() : returned %d", err );
 
   273             HandleSBEErrorL( err );
 
       
   274             User::RequestComplete( iCallerStatus, err );
 
       
   275             break;
 
   272             break;
 
   276         case EListDataOwners :
 
   273         case EListDataOwners :
 
   277             LOGGER_WRITE( "CSConSBEClient::RunL() : EListDataOwners" ); 
   274             LOGGER_WRITE( "CSConSBEClient::RunL() : EListDataOwners" ); 
   278             TRAP( err, ProcessListDataOwnersL() );
 
   275             TRAP( err, ProcessListDataOwnersL() );
 
   279             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListDataOwnersL() : returned %d", err );
 
   276             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListDataOwnersL() : returned %d", err );
 
   280             HandleSBEErrorL( err );
 
       
   281             User::RequestComplete( iCallerStatus, err );
 
       
   282             break;
 
   277             break;
 
   283         case EGetDataSize :
 
   278         case EGetDataSize :
 
   284             LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataSize" );    
   279             LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataSize" );    
   285             TRAP( err, ProcessGetDataSizeL() );
 
   280             TRAP( err, ProcessGetDataSizeL() );
 
   286             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataSizeL() : returned %d", err );
 
   281             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataSizeL() : returned %d", err );
 
   287             HandleSBEErrorL( err );
 
       
   288             User::RequestComplete( iCallerStatus, err );
 
       
   289             break;
 
   282             break;
 
   290         case ERequestData :
 
   283         case ERequestData :
 
   291             LOGGER_WRITE( "CSConSBEClient::RunL() : ERequestData" );
 
   284             LOGGER_WRITE( "CSConSBEClient::RunL() : ERequestData" );
 
   292             TRAP( err, ret = ProcessRequestDataL() );
 
   285             TRAP( err, ret = ProcessRequestDataL() );
 
   293             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessRequestDataL() : returned %d", err );
 
   286             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessRequestDataL() : returned %d", err );
 
   294             HandleSBEErrorL( err );
 
       
   295             
       
   296             if( err == KErrNone )
 
       
   297                 {
 
       
   298                 err = ret;
 
       
   299                 }
 
       
   300             
       
   301             User::RequestComplete( iCallerStatus, err );
 
       
   302             break;  
   287             break;  
   303         case EGetDataOwnerStatus :
 
   288         case EGetDataOwnerStatus :
 
   304             LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataOwnerStatus" );
 
   289             LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataOwnerStatus" );
 
   305             TRAP( err, ProcessGetDataOwnerStatusL() );
 
   290             TRAP( err, ProcessGetDataOwnerStatusL() );
 
   306             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataOwnerStatusL() : returned %d", err );
 
   291             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataOwnerStatusL() : returned %d", err );
 
   307             HandleSBEErrorL( err );
 
       
   308             User::RequestComplete( iCallerStatus, err );
 
       
   309             break;
 
   292             break;
 
   310         case ESupplyData :
 
   293         case ESupplyData :
 
   311             LOGGER_WRITE( "CSConSBEClient::RunL() : ESupplyData" ); 
   294             LOGGER_WRITE( "CSConSBEClient::RunL() : ESupplyData" ); 
   312             TRAP( err, ret = ProcessSupplyDataL() );
 
   295             TRAP( err, ret = ProcessSupplyDataL() );
 
   313             LOGGER_WRITE_1( "CSConSBEClient::RunL() : SupplyDataL() : returned %d", err );
 
   296             LOGGER_WRITE_1( "CSConSBEClient::RunL() : SupplyDataL() : returned %d", err );
 
   314             HandleSBEErrorL( err );
 
       
   315             
       
   316             if( err == KErrNone )
 
       
   317                 {
 
       
   318                 err = ret;
 
       
   319                 }
 
       
   320             
       
   321             User::RequestComplete( iCallerStatus, err );
 
       
   322             break;
 
   297             break;
 
   323         default :
 
   298         default :
 
       
   299             err = KErrNotSupported;
 
   324             LOGGER_WRITE( "CSConSBEClient::RunL() : ERROR! Unknown!" ); 
   300             LOGGER_WRITE( "CSConSBEClient::RunL() : ERROR! Unknown!" ); 
   325             break;
 
   301             break;
 
   326         }
 
   302         }
 
       
   303     
       
   304     if ( err )
 
       
   305         {
 
       
   306         HandleSBEErrorL( err );
 
       
   307         }
 
       
   308     else
 
       
   309         {
 
       
   310         err = ret;
 
       
   311         }
 
       
   312     User::RequestComplete( iCallerStatus, err );
 
   327             
   313             
   328     TRACE_FUNC_EXIT;
 
   314     TRACE_FUNC_EXIT;
 
   329     }
 
   315     }
 
   330     
   316     
   331 // -----------------------------------------------------------------------------
 
   317 // -----------------------------------------------------------------------------
 
   336 void CSConSBEClient::ProcessSetBURModeL()
 
   322 void CSConSBEClient::ProcessSetBURModeL()
 
   337     {
 
   323     {
 
   338     TRACE_FUNC_ENTRY;
 
   324     TRACE_FUNC_ENTRY;
 
   339     
   325     
   340     iAllSnapshotsSuppliedCalled = EFalse;
 
   326     iAllSnapshotsSuppliedCalled = EFalse;
 
       
   327     iLastChunk = EFalse;
 
   341     
   328     
   342     TDriveList driveList = iCurrentTask->iBURModeParams->iDriveList;
 
   329     TDriveList driveList = iCurrentTask->iBURModeParams->iDriveList;
 
   343     
   330     
   344     TBURPartType partialType = EBURUnset;
 
   331     TBURPartType partialType = EBURUnset;
 
   345     iRestoreMode = EFalse;
 
   332     iRestoreMode = EFalse;
 
   364             iRestoreMode = ETrue;
 
   351             iRestoreMode = ETrue;
 
   365             break;
 
   352             break;
 
   366         default :
 
   353         default :
 
   367             partialType = EBURUnset;
 
   354             partialType = EBURUnset;
 
   368             break;
 
   355             break;
 
       
   356         }
 
       
   357     
       
   358     if ( partialType == EBURBackupFull || partialType == ESConBurBackupPartial )
 
       
   359         {
 
       
   360         // initialize buffer
 
       
   361         if ( !iDataBuffer )
 
       
   362             iDataBuffer = CBufFlat::NewL( KDataBufExpandSize );
 
       
   363         else
 
       
   364             iDataBuffer->Reset();
 
       
   365         iDataBufferSize=0;
 
       
   366         }
 
       
   367     else
 
       
   368         {
 
       
   369         delete iDataBuffer;
 
       
   370         iDataBuffer = 0;
 
   369         }
 
   371         }
 
   370     
   372     
   371     TBackupIncType incType = ENoBackup;
 
   373     TBackupIncType incType = ENoBackup;
 
   372     
   374     
   373     switch( iCurrentTask->iBURModeParams->iIncType )    
   375     switch( iCurrentTask->iBURModeParams->iIncType )    
   717             //Clear package name
 
   719             //Clear package name
 
   718             packageDataOwner->iPackageName = KNullDesC();
 
   720             packageDataOwner->iPackageName = KNullDesC();
 
   719             //Add sid
 
   721             //Add sid
 
   720             packageDataOwner->iUid.iUid = sid.iId;
 
   722             packageDataOwner->iUid.iUid = sid.iId;
 
   721             iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( packageDataOwner );
 
   723             iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( packageDataOwner );
 
   722             CleanupStack::PopAndDestroy( packageDataOwner );
 
   724             CleanupStack::Pop( packageDataOwner );
 
   723             }
 
   725             }
 
   724         
   726         
   725         if( !includeToList )
 
   727         if( !includeToList )
 
   726             {
 
   728             {
 
   727             //Not included to list => delete memory allocation
 
   729             //Not included to list => delete memory allocation
 
   840 //      
   842 //      
   841 TInt CSConSBEClient::ProcessRequestDataL()
 
   843 TInt CSConSBEClient::ProcessRequestDataL()
 
   842     {
 
   844     {
 
   843     TRACE_FUNC_ENTRY;
 
   845     TRACE_FUNC_ENTRY;
 
   844     TInt ret( KErrNone );
 
   846     TInt ret( KErrNone );
 
   845     
       
   846     if( iMaxObjectSize <= 1 )
 
       
   847         {
 
       
   848         User::Leave( KErrGeneral );
 
       
   849         }
 
       
   850         
   847         
   851     TBool packageData = EFalse;
 
   848     TBool packageData = EFalse;
 
   852     TTransferDataType transferDataType( ERegistrationData );
 
   849     TTransferDataType transferDataType( ERegistrationData );
 
   853     TPackageDataType packageDataType( ESystemSnapshotData );    
   850     TPackageDataType packageDataType( ESystemSnapshotData );    
   854     LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() iTransDataType: %d",
 
   851     LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() iTransDataType: %d",
 
   919     else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
 
   916     else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
 
   920         {
 
   917         {
 
   921         sid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;
 
   918         sid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;
 
   922         LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() sid: 0x%08x", sid.iId);
 
   919         LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() sid: 0x%08x", sid.iId);
 
   923         }
 
   920         }
 
   924             
   921     
   925     CSBPackageTransferType* ptt( NULL );
 
   922 
   926     CSBSIDTransferType* stt( NULL );
 
       
   927     CSBJavaTransferType* jtt( NULL );
 
       
   928     
       
   929     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
       
   930     Begin - Data left: %d", iDataLeft );
 
       
   931     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
   923     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
   932     Begin - Package data: %d", packageData );
 
   924     Begin - Package data: %d", packageData );
 
   933     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
   925 
   934     Begin - iDataPos: %d", iDataPos );
 
   926     LOGGER_WRITE_1("iLastChunk: %d", (TInt) iLastChunk );
 
   935         
   927     LOGGER_WRITE_1("iDataBufferSize: %d", iDataBufferSize );
 
   936     //Are there old data left to be transfered?
 
   928         
   937     if( !iDataLeft ) 
   929     // if was't last chunk and there are free space left on our packet
 
       
   930     if( !iLastChunk && iDataBufferSize < KMaxObjectSize ) 
   938         {
 
   931         {
 
   939         //No data left, request more from the server
 
   932         //No data left, request more from the server
 
   940         if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
 
   933         if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
 
   941             {
 
   934             {
 
   942             ptt = CSBPackageTransferType::NewL( uid, driveNumber, 
   935             CSBPackageTransferType* ptt = CSBPackageTransferType::NewL(
 
   943                 packageDataType );
 
   936                     uid, driveNumber, packageDataType );
 
   944             CleanupStack::PushL( ptt );
 
   937             CleanupStack::PushL( ptt );
 
   945             LOGGER_WRITE( "iSBEClient->RequestDataL( ptt ) : start" );
 
   938             
   946             TRequestStatus status;
 
   939             RequestDataL( *ptt );
 
   947             iSBEClient->RequestDataL( *ptt, status );
 
   940             
   948             User::WaitForRequest( status );
 
       
   949             LOGGER_WRITE( "iSBEClint->RequestDataL( ptt ) : stop" );
 
       
   950             
       
   951             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : status.Int() %d", status.Int() );
 
       
   952             User::LeaveIfError( status.Int() );
 
       
   953                                     
       
   954             //Get the data and store the handle
 
       
   955             CSBGenericTransferType* gtt = NULL;
 
       
   956             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );
 
       
   957             iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );
 
       
   958             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : stop" );
 
       
   959             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   960              Received data size %d", iDataPtr.Length() );
 
       
   961             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   962              Received from DO 0x%08x", uid );
 
       
   963             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   964              Is last chunk %d", iLastChunk );
 
       
   965             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   966              Transfertype %d", iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );
 
       
   967              
       
   968              if( gtt )
 
       
   969                 {
 
       
   970                 delete gtt;
 
       
   971                 }
 
       
   972              
       
   973             CleanupStack::PopAndDestroy( ptt );
 
   941             CleanupStack::PopAndDestroy( ptt );
 
   974             }
 
   942             }
 
   975         else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
 
   943         else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
 
   976             {
 
   944             {
 
   977             stt = CSBSIDTransferType::NewL( sid, driveNumber, transferDataType );
 
   945             CSBSIDTransferType* stt = CSBSIDTransferType::NewL(
 
       
   946                     sid, driveNumber, transferDataType );
 
   978             CleanupStack::PushL( stt );
 
   947             CleanupStack::PushL( stt );
 
   979             LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : start" );
 
   948             
   980             TRequestStatus status;
 
   949             RequestDataL( *stt );
 
   981             iSBEClient->RequestDataL( *stt, status );
 
   950             
   982             User::WaitForRequest( status );
 
       
   983             LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : stop" );
 
       
   984             
       
   985             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   986              status.Int() %d", status.Int() );
 
       
   987             User::LeaveIfError( status.Int() );
 
       
   988                         
       
   989             //Get the data and store the handle
 
       
   990             CSBGenericTransferType* gtt = NULL;
 
       
   991             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );
 
       
   992             iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );
 
       
   993             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : stop" );
 
       
   994             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   995              Received data size %d", iDataPtr.Length() );
 
       
   996             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   997              Is last chunk %d", iLastChunk );
 
       
   998             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
   999              Transfertype %d", 
       
  1000              iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );
 
       
  1001              
       
  1002             if( gtt )
 
       
  1003                 {
 
       
  1004                 delete gtt;
 
       
  1005                 }
 
       
  1006              
       
  1007             CleanupStack::PopAndDestroy( stt );
 
   951             CleanupStack::PopAndDestroy( stt );
 
  1008             }
 
   952             }
 
  1009         else
 
   953         else
 
  1010             {
 
   954             {
 
  1011             TPtr javaHashPtr = iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash->Des();
 
   955             TPtr javaHashPtr = iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash->Des();
 
  1012             
   956             CSBJavaTransferType* jtt( NULL );
 
  1013             //When ESystemData is requested, request EJavaMIDlet
 
   957             //When ESystemData is requested, request EJavaMIDlet
 
  1014             if( packageDataType == ESystemData )
 
   958             if( packageDataType == ESystemData )
 
  1015                 {
 
   959                 {
 
  1016                 jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDlet );
 
   960                 jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDlet );
 
  1017                 }
 
   961                 }
 
  1022                 }
 
   966                 }
 
  1023                         
   967                         
  1024             if( packageDataType == ESystemData || transferDataType == EPassiveBaseData )
 
   968             if( packageDataType == ESystemData || transferDataType == EPassiveBaseData )
 
  1025                 {
 
   969                 {
 
  1026                 CleanupStack::PushL( jtt );
 
   970                 CleanupStack::PushL( jtt );
 
  1027                 LOGGER_WRITE( "iSBEClient->RequestDataL( jtt ) : start" );
 
       
  1028                 TRequestStatus status;
 
       
  1029                 iSBEClient->RequestDataL( *jtt, status );
 
       
  1030                 User::WaitForRequest( status );
 
       
  1031                 LOGGER_WRITE( "iSBEClient->RequestDataL( jtt ) : stop" );
 
       
  1032                 
   971                 
  1033                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
   972                 RequestDataL( *jtt );
 
  1034                  status.Int() %d", status.Int() );
 
   973                 
  1035                 User::LeaveIfError( status.Int() );
 
       
  1036                             
       
  1037                 //Get the data and store the handle
 
       
  1038                 CSBGenericTransferType* gtt = NULL;
 
       
  1039                 LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );
 
       
  1040                 iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );
 
       
  1041                 LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ): stop" );
 
       
  1042                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
  1043                  Received data size %d", iDataPtr.Length() );
 
       
  1044                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
  1045                  Is last chunk %d", iLastChunk );
 
       
  1046                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\
 
       
  1047                  Transfertype %d", 
       
  1048                  iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );
 
       
  1049                  
       
  1050                 if( gtt )
 
       
  1051                     {
 
       
  1052                     delete gtt;
 
       
  1053                     }
 
       
  1054                  
       
  1055                 CleanupStack::PopAndDestroy( jtt );   
   974                 CleanupStack::PopAndDestroy( jtt );   
  1056                 }
 
   975                 }
 
  1057             else
 
   976             else
 
  1058                 {
 
   977                 {
 
  1059                 //No data
 
   978                 //No data
 
  1060                 iDataPtr.Set( KNullDesC8 );
 
   979                 iDataBuffer->Reset();
 
       
   980                 iDataBufferSize = 0;
 
  1061                 iLastChunk = ETrue;
 
   981                 iLastChunk = ETrue;
 
  1062                 }
 
   982                 }
 
  1063             }
 
   983             }
 
  1064         }   
   984         }
 
  1065         
   985     
  1066     TInt dataBufLength = iDataPtr.Length();
 
   986     LOGGER_WRITE_1("readed iLastChunk: %d", (TInt) iLastChunk );
 
  1067     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
   987     LOGGER_WRITE_1("readed iDataBufferSize: %d", iDataBufferSize );
 
  1068     Data received: %d", dataBufLength );
 
   988         
  1069     
   989     
  1070     TInt maxLength = iMaxObjectSize - 1024;
 
       
  1071     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
       
  1072     Max length: %d", maxLength );
 
       
  1073     
   990     
  1074     if( iCurrentTask->iRequestDataParams->iBackupData )
 
   991     if( iCurrentTask->iRequestDataParams->iBackupData )
 
  1075         {
 
   992         {
 
  1076         delete iCurrentTask->iRequestDataParams->iBackupData;
 
   993         delete iCurrentTask->iRequestDataParams->iBackupData;
 
  1077         iCurrentTask->iRequestDataParams->iBackupData = NULL;
 
   994         iCurrentTask->iRequestDataParams->iBackupData = NULL;
 
  1078         }
 
   995         }
 
  1079     
   996     
       
   997     TInt dataToRead = KMaxObjectSize;
 
       
   998     if ( dataToRead > iDataBufferSize )
 
       
   999         dataToRead = iDataBufferSize;
 
       
  1000     
  1080     //Initialize the task data buffer
 
  1001     //Initialize the task data buffer
 
  1081     iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( maxLength );
 
  1002     iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( dataToRead );
 
  1082     //Get descriptor task's buffer
 
  1003     //Get descriptor task's buffer
 
  1083     TPtr8 backupDataPtr = iCurrentTask->iRequestDataParams->iBackupData->Des();
 
  1004     TPtr8 backupDataPtr = iCurrentTask->iRequestDataParams->iBackupData->Des();
 
  1084     
  1005     
  1085     TInt copyPos = 0;
 
  1006     
  1086     
  1007     iDataBuffer->Read(0, backupDataPtr, dataToRead );
 
  1087     //Copy data to task buffer
 
  1008     iDataBuffer->Delete(0, dataToRead);
 
  1088     for( ; iDataPos < dataBufLength && copyPos < maxLength;
 
  1009     iDataBufferSize -= dataToRead;
 
  1089      iDataPos++ )
 
  1010     
  1090         {
 
  1011     if ( !iLastChunk || iDataBufferSize>0 )
 
  1091         backupDataPtr.Append( iDataPtr[iDataPos] );
 
  1012         {
 
  1092         copyPos++;
 
  1013         LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : There are more data available" );
 
  1093         }
 
       
  1094         
       
  1095     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
       
  1096     End - copyPos: %d", copyPos );
 
       
  1097     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
 
       
  1098     End - iDataPos: %d", iDataPos );
 
       
  1099             
       
  1100     //Are there more data left in the buffer
 
       
  1101     if( iDataPos < dataBufLength )
 
       
  1102         {
 
       
  1103         LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : There is more data in buffer" );
 
       
  1104         iDataLeft = ETrue;
 
       
  1105         iCurrentTask->iRequestDataParams->iMoreData = ETrue;
 
  1014         iCurrentTask->iRequestDataParams->iMoreData = ETrue;
 
  1106         //Another task is needed to transfer the data to the client
 
  1015         //Another task is needed to transfer the data to the client
 
  1107         ret = KErrCompletion;
 
  1016         ret = KErrCompletion;
 
  1108         }
 
  1017         }
 
  1109     else
 
  1018     else
 
  1110         {
 
  1019         {
 
  1111         //Check if the backup server has more data from the dataowner
 
  1020         LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : All data readed" );
 
  1112         if( !iLastChunk )
 
  1021         iDataBuffer->Reset();
 
  1113             {
 
  1022         iDataBufferSize = 0;
 
  1114             iCurrentTask->iRequestDataParams->iMoreData = ETrue; 
  1023         // task will be completed, initialize iLastChunk value for next operation
 
  1115             //Another task is needed to transfer the data to the client
 
  1024         iLastChunk = EFalse;
 
  1116             ret = KErrCompletion;
 
  1025         }
 
  1117             LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : There are more data available from SBE" );
 
  1026     
  1118             }
 
       
  1119         else
 
       
  1120             {
 
       
  1121             iCurrentTask->iRequestDataParams->iMoreData = EFalse;
 
       
  1122             }
 
       
  1123             
       
  1124         iDataPos = 0;   
       
  1125         iDataLeft = EFalse; 
       
  1126         }
 
       
  1127         
  1027         
  1128     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :  returned %d", ret );
 
  1028     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :  returned %d", ret );
 
  1129     return ret;
 
  1029     return ret;
 
       
  1030     }
 
       
  1031 
       
  1032 void CSConSBEClient::RequestDataL( CSBGenericTransferType& aGenericTransferType )
 
       
  1033     {
 
       
  1034     TRACE_FUNC_ENTRY;
 
       
  1035     if ( !iDataBuffer )
 
       
  1036         User::Leave( KErrArgument );
 
       
  1037     
       
  1038     do
 
       
  1039         {
 
       
  1040         LOGGER_WRITE( "iSBEClient->RequestDataL() : start" );
 
       
  1041         TRequestStatus status;
 
       
  1042         iSBEClient->RequestDataL( aGenericTransferType, status );
 
       
  1043         User::WaitForRequest( status );
 
       
  1044         LOGGER_WRITE_1( "iSBEClient->RequestDataL() : status.Int() %d", status.Int() );
 
       
  1045         User::LeaveIfError( status.Int() );
 
       
  1046                     
       
  1047         //Get the data and store the handle
 
       
  1048         CSBGenericTransferType* gtt = NULL;
 
       
  1049         const TPtrC8& dataPtr = iSBEClient->TransferDataInfoL( gtt, iLastChunk );
 
       
  1050         LOGGER_WRITE_1("data size: %d", dataPtr.Length());
 
       
  1051         delete gtt;
 
       
  1052         iDataBuffer->ExpandL( iDataBufferSize, dataPtr.Length() );
 
       
  1053         iDataBuffer->Write(iDataBufferSize, dataPtr);
 
       
  1054         iDataBufferSize += dataPtr.Length();
 
       
  1055         LOGGER_WRITE_1("total buffer size: %d", iDataBufferSize);
 
       
  1056         }
 
       
  1057     // Continue if there are more data, and our packet is not full
 
       
  1058     while ( !iLastChunk && iDataBufferSize < KMaxObjectSize );
 
       
  1059     
       
  1060     TRACE_FUNC_EXIT;
 
  1130     }
 
  1061     }
 
  1131     
  1062     
  1132 // -----------------------------------------------------------------------------
 
  1063 // -----------------------------------------------------------------------------
 
  1133 // CSConSBEClient::ProcessGetDataOwnerStatusL()
 
  1064 // CSConSBEClient::ProcessGetDataOwnerStatusL()
 
  1134 // Executes GetDataOwnerStatus task
 
  1065 // Executes GetDataOwnerStatus task
 
  1400     LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() : returned %d", ret );
 
  1331     LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() : returned %d", ret );
 
  1401     return ret;
 
  1332     return ret;
 
  1402     }
 
  1333     }
 
  1403 
  1334 
  1404 // -----------------------------------------------------------------------------
 
  1335 // -----------------------------------------------------------------------------
 
  1405 // CSConSBEClient::GetDriveNumber( const TInt& aDrive ) const
 
  1336 // CSConSBEClient::GetDriveNumber( TInt aDrive ) const
 
  1406 // Maps TInt drive number to TDriveNumber
 
  1337 // Maps TInt drive number to TDriveNumber
 
  1407 // -----------------------------------------------------------------------------
 
  1338 // -----------------------------------------------------------------------------
 
  1408 //  
  1339 //  
  1409 TDriveNumber CSConSBEClient::GetDriveNumber( const TInt& aDrive ) const
 
  1340 TDriveNumber CSConSBEClient::GetDriveNumber( TInt aDrive ) const
 
  1410     {
 
  1341     {
 
  1411     TDriveNumber driveNumber;
 
  1342     TDriveNumber driveNumber;
 
  1412     switch( aDrive )
 
  1343     switch( aDrive )
 
  1413         {
 
  1344         {
 
  1414         case 0 :
 
  1345         case 0 :
 
  1557         LOGGER_WRITE( "Re-connecting to SBE..." );
 
  1488         LOGGER_WRITE( "Re-connecting to SBE..." );
 
  1558         //Session has been terminated, recreate it..
 
  1489         //Session has been terminated, recreate it..
 
  1559         delete iSBEClient;
 
  1490         delete iSBEClient;
 
  1560         iSBEClient = NULL;
 
  1491         iSBEClient = NULL;
 
  1561         iSBEClient = CSBEClient::NewL();
 
  1492         iSBEClient = CSBEClient::NewL();
 
       
  1493         }
 
       
  1494     else if ( aErr ) // error
 
       
  1495         {
 
       
  1496         if ( iDataBuffer )
 
       
  1497             {
 
       
  1498             iDataBuffer->Reset();
 
       
  1499             iDataBufferSize = 0;
 
       
  1500             }
 
       
  1501         iLastChunk = EFalse;
 
  1562         }
 
  1502         }
 
  1563     TRACE_FUNC_EXIT;
 
  1503     TRACE_FUNC_EXIT;
 
  1564     }
 
  1504     }
 
  1565 
  1505 
  1566 // -----------------------------------------------------------------------------
 
  1506 // -----------------------------------------------------------------------------
FCL/sf/app/contentcontrol