--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/services/pcd/src/sconpcd.cpp Wed Sep 01 12:20:56 2010 +0100
@@ -0,0 +1,626 @@
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: CSConPCD implementation
+*
+*/
+
+
+// INCLUDE FILES
+
+#include "sconpcd.h"
+#include "sconpcdconsts.h"
+#include "sconinstqueue.h"
+#include "sconbrqueue.h"
+#include "sconmetadata.h"
+#include "sconsynchandler.h"
+#include "debug.h"
+
+// ============================= MEMBER FUNCTIONS ===============================
+
+
+// -----------------------------------------------------------------------------
+// CreateCSConPCDL()
+// Entry to CSConPCD
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CSConPCD* CreateCSConPCDL()
+ {
+ TRACE_FUNC;
+ return CSConPCD::NewL();
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::NewL()
+// Two-phase constructor
+// -----------------------------------------------------------------------------
+//
+CSConPCD* CSConPCD::NewL()
+ {
+ TRACE_FUNC_ENTRY;
+ CSConPCD* self = new (ELeave) CSConPCD();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ TRACE_FUNC_EXIT;
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::CSConPCD()
+// Constructor
+// -----------------------------------------------------------------------------
+//
+CSConPCD::CSConPCD() : iInstallerQueue( NULL ), iBackupRestoreQueue( NULL ),
+ iLatestReply(NULL), iTaskNumber( 0 ), iMaxObjectSize( 65536 ),
+ iLastOperation( ENoTask )
+ {
+ TRACE_FUNC;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::ConstructL()
+// Initializes member data
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::ConstructL()
+ {
+ TRACE_FUNC_ENTRY;
+ User::LeaveIfError( iFs.Connect() );
+ iInstallerQueue = CSConInstallerQueue::NewL( iFs );
+ iBackupRestoreQueue = CSConBackupRestoreQueue::NewL( iMaxObjectSize, iFs );
+ iInstallerQueue->QueueAddress( iBackupRestoreQueue );
+ iBackupRestoreQueue->QueueAddress( iInstallerQueue );
+
+ if ( !CActiveScheduler::Current() )
+ {
+ CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
+ CActiveScheduler::Install( scheduler );
+ }
+ CActiveScheduler::Add( iInstallerQueue );
+ CActiveScheduler::Add( iBackupRestoreQueue );
+ iSyncHandler = CSconSyncHandler::NewL( iFs );
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::~CSConPCD()
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSConPCD::~CSConPCD()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iInstallerQueue )
+ {
+ iInstallerQueue->Cancel();
+ delete iInstallerQueue;
+ iInstallerQueue = NULL;
+ }
+
+ if ( iBackupRestoreQueue )
+ {
+ iBackupRestoreQueue->Cancel();
+ delete iBackupRestoreQueue;
+ iBackupRestoreQueue = NULL;
+ }
+
+ if ( iLatestReply )
+ {
+ delete iLatestReply;
+ iLatestReply = NULL;
+ }
+
+ if ( iSyncHandler )
+ {
+ iSyncHandler->Cancel();
+ delete iSyncHandler;
+ iSyncHandler = NULL;
+ }
+ iFs.Close();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::PutTaskL( CSConTask* aTask )
+// Receives a new task
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::PutTaskL( CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+ TInt maxObjectSize( 0 );
+
+ if ( iLastOperation == EPutTask )
+ {
+ LOGGER_WRITE( "CSConPCD::PutTaskL() : Two Puts in a row -> Reset()" );
+ ResetPCD();
+ }
+ else
+ {
+ LOGGER_WRITE( "CSConPCD::PutTaskL() : Protocol procedure ok" );
+ iLastOperation = EPutTask;
+ }
+
+ switch( aTask->GetServiceId() )
+ {
+ case ECancel :
+ ret = CancelL( aTask->iCancelTaskId, aTask->iCancelTaskAll );
+ delete aTask;
+ break;
+ case EGetDataOwnerStatus :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case EGetDataSize :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case EGetStatus :
+ ret = GetStatusL( aTask->iGetStatusParams->iTaskId,
+ aTask->iGetStatusParams->iAll );
+ delete aTask;
+ break;
+ case EInstall :
+ ret = SupportedInstTaskL( aTask );
+ break;
+ case EListDataOwners :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case EListInstalledApps :
+ ret = SupportedInstTaskL( aTask );
+ break;
+ case EListPublicFiles :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case ERequestData :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case ESetBURMode :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case ESetInstParams :
+ ret = SupportedInstTaskL( aTask );
+ break;
+ case ESupplyData :
+ ret = SupportedBRTaskL( aTask );
+ break;
+ case EUninstall :
+ ret = SupportedInstTaskL( aTask );
+ break;
+ case EUpdateDeviceInfo :
+ maxObjectSize = aTask->iDevInfoParams->iMaxObjectSize;
+ ret = UpdateDeviceInfoL( maxObjectSize );
+ iTaskNumber++;
+ delete aTask;
+ break;
+ case EReboot :
+ RebootTaskL( aTask );
+ delete aTask;
+ break;
+ case EGetMetadata :
+ ret = KErrNone;
+ GetMetadataTaskL( *aTask );
+ delete aTask;
+ break;
+ default :
+ break;
+ }
+ LOGGER_WRITE_1( "CSConPCD::PutTaskL() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::GetReply()
+// Returns a reply to previous PutTaskL operation
+// -----------------------------------------------------------------------------
+//
+CSConStatusReply* CSConPCD::GetReply()
+ {
+ TRACE_FUNC_ENTRY;
+
+ if ( iLastOperation == EGetReply )
+ {
+ LOGGER_WRITE( "CSConPCD::GetReply() : Two Gets in a row -> Reset()" );
+ ResetPCD();
+ }
+ else
+ {
+ LOGGER_WRITE( "CSConPCD::GetReply() : Protocol procedure ok" );
+ iLastOperation = EGetReply;
+ }
+ CSConStatusReply* reply = iLatestReply;
+ iLatestReply = NULL;
+ TRACE_FUNC_EXIT;
+ return reply;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::ResetPCD()
+// Resets the module to the initial state
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::ResetPCD()
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iInstallerQueue )
+ {
+ LOGGER_WRITE( "CSConPCD::ResetPCD() : Reseting installer queue" );
+ iInstallerQueue->Reset();
+ }
+
+ if ( iBackupRestoreQueue )
+ {
+ LOGGER_WRITE( "CSConPCD::ResetPCD() : Reseting backup queue" );
+ iBackupRestoreQueue->Reset();
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::HandleGetSyncRequestL()
+//
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::HandleGetSyncRequestL( const TDesC8& aRequest, RWriteStream& aResult, TInt aMaxObjectSize )
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncHandler->HandleGetSyncRequestL( aRequest, aResult, aMaxObjectSize );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::HandlePutSyncRequestL()
+//
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::HandlePutSyncRequestL( const TDesC8& aRequest, RReadStream& aResult )
+ {
+ TRACE_FUNC_ENTRY;
+ iSyncHandler->HandlePutSyncRequestL( aRequest, aResult );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::SupportedInstTaskL( CSConTask* aTask )
+// Fills a reply with predefined supported task -information
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::SupportedInstTaskL( CSConTask* aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+ iTaskNumber++;
+ ret = iInstallerQueue->AddNewTask( aTask, iTaskNumber );
+
+ //Get status for this task
+ TBool all( EFalse );
+ CSConStatusReply* reply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( reply );
+ iInstallerQueue->GetQueueStatusL( iTaskNumber, all, reply );
+ CleanupStack::Pop( reply );
+
+ StoreReply( reply );
+
+ LOGGER_WRITE_1( "CSConPCD::SupportedInstTaskL() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::SupportedBRTask( CSConTask* aTask )
+// Fills a reply with predefined supported task -information
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::SupportedBRTaskL( CSConTask* aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+
+ TInt taskId;
+
+ taskId = ++iTaskNumber;
+
+ ret = iBackupRestoreQueue->AddNewTask( aTask, taskId );
+ LOGGER_WRITE_1( "iBackupRestoreQueue->AddNewTask : ret %d", ret );
+ //Get status for this task
+ TBool all( EFalse );
+ CSConStatusReply* reply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( reply );
+ iBackupRestoreQueue->GetQueueStatusL( iTaskNumber, all, reply );
+ CleanupStack::Pop( reply );
+
+ StoreReply( reply );
+
+ TRACE_FUNC_EXIT;
+ return ret;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSConPCD::RebootTask( const CSConTask* aTask )
+// Fills a reply with predefined unsupported task -information
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::RebootTaskL( const CSConTask* aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNotSupported );
+ iTaskNumber++;
+ TSConMethodName method( aTask->GetServiceId() );
+ CSConStatusReply* reply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( reply );
+ CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();
+ CleanupStack::PushL( taskReply );
+
+ TBool complete( ETrue );
+ taskReply->InitializeL( method, KSConCodeNotSupported, complete );
+ taskReply->iTaskId = iTaskNumber;
+
+ reply->iNoTasks = EFalse;
+ User::LeaveIfError( reply->iTasks.Append( taskReply ) );
+ CleanupStack::Pop( taskReply );
+
+ StoreReply( reply );
+ CleanupStack::Pop( reply );
+
+ LOGGER_WRITE_1( "CSConPCD::RebootTask() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::GetMetadataTask( const CSConTask* aTask )
+// Fills a reply with predefined GetMetadata task -information
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::GetMetadataTaskL( CSConTask& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+
+ aTask.iTaskId = ++iTaskNumber;
+
+ //Set progress value "task accepted for execution"
+ aTask.SetProgressValue( KSConCodeTaskCreated );
+ aTask.SetCompleteValue( EFalse );
+
+ SConMetadata::ProcessTask( aTask, iFs );
+
+ //Get status for this task
+
+ CSConStatusReply* reply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( reply );
+ CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();
+ CleanupStack::PushL( taskReply );
+ taskReply->InitializeL( aTask );
+ User::LeaveIfError( reply->iTasks.Append( taskReply ) );
+ CleanupStack::Pop( taskReply );
+
+ if ( !aTask.GetComplete() )
+ {
+ // clean all unneccessary data from the reply packet
+ taskReply->CleanTaskData();
+ }
+
+
+ StoreReply( reply );
+ CleanupStack::Pop( reply );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::GetStatus( TInt aTask, TBool aAll )
+// Collects a status of a specified task / all tasks
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::GetStatusL( TInt aTask, TBool aAll )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+
+ // create mergeReply object. Store installer and br replys here.
+ CSConStatusReply* mergeReply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( mergeReply );
+
+
+ CSConStatusReply* brReply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( brReply );
+ iBackupRestoreQueue->GetQueueStatusL( aTask, aAll, brReply );
+
+
+ // Create installerReply and populate it
+ CSConStatusReply* installerReply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( installerReply );
+ iInstallerQueue->GetQueueStatusL( aTask, aAll, installerReply );
+
+ if ( !installerReply->iNoTasks || !brReply->iNoTasks )
+ {
+ mergeReply->iNoTasks = EFalse;
+ }
+ else
+ {
+ mergeReply->iNoTasks = ETrue;
+ }
+
+ for ( TInt i = 0; i < installerReply->iTasks.Count(); i++ )
+ {
+ CSConTaskReply* temp = installerReply->iTasks[i]->CopyAndFreeL();
+ CleanupStack::PushL( temp );
+ mergeReply->iTasks.AppendL( temp );
+ CleanupStack::Pop( temp );
+ }
+
+ // installer replys are copied to mergereply, delete installerReply
+ CleanupStack::PopAndDestroy( installerReply );
+
+ // do same for br reply
+ for ( TInt i = 0; i < brReply->iTasks.Count(); i++ )
+ {
+ CSConTaskReply* temp = brReply->iTasks[i]->CopyAndFreeL();
+ CleanupStack::PushL( temp );
+ mergeReply->iTasks.AppendL( temp );
+ CleanupStack::Pop( temp );
+ }
+
+ CleanupStack::PopAndDestroy( brReply );
+
+ CleanupStack::Pop( mergeReply );
+ // store reply
+ StoreReply( mergeReply );
+
+ LOGGER_WRITE_1( "CSConPCD::GetStatus() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::Cancel( TInt aTask, TBool aAll )
+// Cancels a specified task / all tasks
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::CancelL( TInt aTask, TBool aAll )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+
+ CSConStatusReply* reply = new (ELeave) CSConStatusReply();
+ iInstallerQueue->CancelTask( aTask, aAll );
+ iBackupRestoreQueue->CancelTask( aTask, aAll );
+
+ reply->iNoTasks = ETrue;
+
+ StoreReply( reply );
+
+ LOGGER_WRITE_1( "CSConPCD::CancelL() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::StoreReply( CSConStatusReply*& aReply )
+// Stores a reply
+// -----------------------------------------------------------------------------
+//
+void CSConPCD::StoreReply( CSConStatusReply*& aReply )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( iLatestReply )
+ {
+ delete iLatestReply;
+ iLatestReply = NULL;
+ }
+
+ iLatestReply = aReply;
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::UpdateDeviceInfo( TInt aMaxObjectSize )
+// Creates a reply for UpdateDeviceInfo task
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::UpdateDeviceInfoL( TInt aMaxObjectSize )
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+ TSConMethodName method( EUpdateDeviceInfo );
+
+ CSConStatusReply* reply = new (ELeave) CSConStatusReply();
+ CleanupStack::PushL( reply );
+ CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();
+ CleanupStack::PushL( taskReply );
+
+
+ TBool complete( ETrue );
+ TInt progress( KSConCodeTaskCompleted );
+
+ taskReply->InitializeL( method, progress, complete );
+ taskReply->iTaskId = iTaskNumber;
+
+ TInt arrayLength = sizeof KSupportedMethods / sizeof KSupportedMethods[0];
+
+ for ( TInt i = 0; i < arrayLength; i++ )
+ {
+ switch( KSupportedMethods[i].method )
+ {
+ case EGetDataSize :
+ taskReply->iDevInfoParams->iGetSizeSupp =
+ KSupportedMethods[i].support;
+ break;
+ case EInstall :
+ taskReply->iDevInfoParams->iInstallSupp =
+ KSupportedMethods[i].support;
+ break;
+ case EListDataOwners :
+ taskReply->iDevInfoParams->iDataOwnersSupp =
+ KSupportedMethods[i].support;
+ break;
+ case EListInstalledApps :
+ taskReply->iDevInfoParams->iInstAppsSupp =
+ KSupportedMethods[i].support;
+ break;
+ case ERequestData :
+ taskReply->iDevInfoParams->iReqDataSupp =
+ KSupportedMethods[i].support;
+ break;
+ case ESetBURMode :
+ taskReply->iDevInfoParams->iSetBURModeSupp =
+ KSupportedMethods[i].support;
+ break;
+ case ESetInstParams :
+ taskReply->iDevInfoParams->iInstParamsSupp =
+ KSupportedMethods[i].support;
+ break;
+ case ESupplyData :
+ taskReply->iDevInfoParams->iSupplyDataSupp =
+ KSupportedMethods[i].support;
+ break;
+ case EUninstall :
+ taskReply->iDevInfoParams->iUninstallSupp =
+ KSupportedMethods[i].support;
+ break;
+ case EReboot :
+ taskReply->iDevInfoParams->iRebootSupp =
+ KSupportedMethods[i].support;
+ break;
+ default :
+ break;
+ }
+ }
+
+ taskReply->iDevInfoParams->iVersion.Copy( KCONMLVERSION );
+ taskReply->iDevInfoParams->iMaxObjectSize =
+ GetMaxObjectSize( aMaxObjectSize );
+
+ reply->iNoTasks = EFalse;
+
+ User::LeaveIfError( reply->iTasks.Append( taskReply ) );
+ StoreReply( reply );
+
+ CleanupStack::Pop( taskReply );
+ CleanupStack::Pop( reply );
+ LOGGER_WRITE_1( "CSConPCD::UpdateDeviceInfo() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConPCD::GetMaxObjectSize( TInt /*aClientObjectSize*/ ) const
+// Gets the current max object size
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCD::GetMaxObjectSize( TInt /*aClientObjectSize*/ ) const
+ {
+ LOGGER_WRITE_1( "CSConPCD::GetMaxObjectSize() : returned %d", iMaxObjectSize );
+ return iMaxObjectSize;
+ }
+
+// End of file