--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/homesync/contentmanager/cmserver/cmserver/src/client/cmclientsession.cpp Thu Dec 17 08:52:00 2009 +0200
@@ -0,0 +1,938 @@
+/*
+* Copyright (c) 2008 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: Content Manager server's client
+*
+*/
+
+
+
+// INCLUDE FILES
+
+#include <s32mem.h>
+#include <badesca.h>
+
+#include "cmfillrulecontainer.h"
+#include "cmstorerulecontainer.h"
+#include "cmbaselistitem.h"
+#include "cmmediaserverfull.h"
+#include "cmsqlpropertyitem.h"
+#include "cmsqlpropertycontainer.h"
+#include "cmsqlpropertycollector.h"
+#include "cmdriveinfo.h"
+#include "cmactive.h"
+#include "msdebug.h"
+
+
+// CONSTANTS
+// Number of retries to start server
+const TInt KServerRetries = 2;
+// wizard executed state
+const TInt KAppWizardExecuted = 1;
+
+// ---------------------------------------------------------------------------
+// StartServer
+// Creates a new process for the server and starts it up.
+// ---------------------------------------------------------------------------
+//
+static TInt StartServer()
+ {
+ LOG(_L("[Cm Server]\t StartServer begin"));
+
+ TInt result( KErrNone );
+ // create server - if one of this name does not already exist
+ TFindServer findServer( KCmServerName );
+ TFullName name;
+ if ( findServer.Next( name ) != KErrNone ) // we don't exist already
+ {
+
+ TRequestStatus status( KRequestPending );
+ RProcess server;
+ // Create the server process
+ result = server.Create( KCmServerExe, KNullDesC );
+ if( result != KErrNone )
+ {
+ return result;
+ }
+
+ // Process created successfully
+ server.Resume(); // start it going
+ server.Rendezvous( status );
+
+ // Wait until the completion of the server creation
+ // server signals us when it's up
+ User::WaitForRequest( status );
+
+ if( status != KErrNone )
+ {
+ server.Close();
+ return status.Int();
+ }
+
+ // Server created successfully
+ server.Close(); // we can close the handle to server process now
+ }
+
+ LOG(_L("[Cm Server]\t StartServer end"));
+
+ return result;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::RContentManager
+// ---------------------------------------------------------------------------
+//
+EXPORT_C RContentManager::RContentManager()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::RContentManager"));
+
+ iClientRequest = NULL;
+ iTargetContainer = NULL;
+ iBuffer = NULL;
+ iAo = NULL;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::Close
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt RContentManager::Close()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::Close"));
+
+ // Base call
+ RSessionBase::Close();
+
+ if ( iAo )
+ {
+ delete iAo; iAo = NULL;
+ }
+
+ if( iBuffer )
+ {
+ delete iBuffer;
+ iBuffer = NULL;
+ }
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::Connect
+// Starts and creates a session of Content Manager
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt RContentManager::Connect()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::Connect"));
+
+ iCanceled = EFalse;
+
+ TInt tryLoop( 0 );
+ TInt errCode( KErrNone );
+
+ for ( tryLoop = 0; tryLoop < KServerRetries; tryLoop++ )
+ {
+ errCode = CreateSession(KCmServerName,
+ TVersion( KCmServerMajor, KCmServerMinor,
+ KCmServerBuild ) );
+ //gives MessageSlots of -1
+ //this uses global pool rather than local pool
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager::Connect New Session \
+ created with status %d\n"), errCode));
+
+ if( errCode == KErrNotSupported )
+ {
+ TRACE(Print(_L("[Cm Server]\t Version not supported!\n")));
+ return errCode;
+ }
+ if ( errCode != KErrNotFound && errCode != KErrServerTerminated)
+ {
+ return errCode;
+ }
+
+ errCode = StartServer();
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager::Connect Start server \
+ errCode %d\n"), errCode));
+
+ if ( errCode != KErrNone && errCode != KErrAlreadyExists )
+ {
+ return errCode;
+ }
+
+ }
+ return errCode;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::OperationCompletedL
+// ---------------------------------------------------------------------------
+//
+TInt RContentManager::OperationCompletedL( TInt aErr )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::OperationCompletedL"));
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager::OperationCompletedL \
+ aErr = %d, iCanceled = %d\n"), aErr, iCanceled));
+
+ if ( !aErr && !iCanceled )
+ {
+ // Items are changed so we don't want to keep old ones
+ // Containers cannot be deleted because application
+ // looses their address
+ for ( TInt i = 0;
+ i < (*iTargetContainer)->PropertyContainerCount();
+ i++ )
+ {
+ CCmSqlPropertyContainer* container =
+ (*iTargetContainer)->PropertyContainer( i );
+ for ( TInt j = 0; j < container->PropertyItemCount(); j++ )
+ {
+ container->DeletePropertyItem(j--);
+ }
+ }
+
+ TInt size( 0 );
+ TPckg<TInt> sizePckg( size );
+ SendReceive( ECmGetDataFieldSize, TIpcArgs( &sizePckg ));
+
+ if ( size > 0 )
+ {
+ HBufC8* buffer = HBufC8::NewLC( size );
+
+ TPtr8 bufferPointer = buffer->Des();
+ SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );
+
+ RDesReadStream stream;
+ stream.Open( bufferPointer );
+ CleanupClosePushL( stream );
+
+ // copy items to application side containers
+ CopyItemsL( stream );
+
+ CleanupStack::PopAndDestroy( 2, buffer );
+ }
+
+
+ }
+ User::RequestComplete( iClientRequest, aErr );
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::CopyItemsL
+// ---------------------------------------------------------------------------
+//
+void RContentManager::CopyItemsL( RDesReadStream& aStream )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::CopyItemsL"));
+
+ CCmSqlPropertyCollector* collector = CCmSqlPropertyCollector::NewLC();
+ collector->InternalizeL( aStream );
+
+ // append internalized items to containers
+ for ( TInt k = 0; k < collector->PropertyContainerCount(); k++ )
+ {
+ CCmSqlPropertyContainer* container =
+ collector->PropertyContainer( k );
+ CCmSqlPropertyContainer* targetContainer =
+ (*iTargetContainer)->PropertyContainer(k);
+ for ( TInt l = 0; l < container->PropertyItemCount(); l++ )
+ {
+ // copy item
+ // must be done so that we can destroy collector
+ CCmSqlPropertyItem* item = new ( ELeave )
+ CCmSqlPropertyItem( *container->PropertyItem(l));
+ CleanupStack::PushL( item );
+ // add copied item
+ targetContainer->AddPropertyItemL( item );
+ CleanupStack::Pop( item );
+ // delete original item
+ container->DeletePropertyItem( l );
+ // itemcount decreased so index must be updated also
+ l--;
+ }
+ }
+ CleanupStack::PopAndDestroy( collector );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::Cancel
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::Cancel()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::Cancel\n"));
+
+ // iCanceled is set ETrue if user is closing the application
+ // We don't want to cancel asynchronous process
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager::Cancel value is %d\n"),
+ iCanceled));
+ if ( !iCanceled )
+ {
+ SendReceive( ECmCancel, TIpcArgs() );
+ }
+
+ if ( iAo )
+ {
+ iAo->Deque();
+ delete iAo; iAo = NULL;
+ }
+
+ LOG(_L("[Cm Server]\t RContentManager::Cancel end\n"));
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::ServerState
+// ---------------------------------------------------------------------------
+EXPORT_C TCmServerState RContentManager::ServerState() const
+ {
+ LOG(_L("[Cm Server]\t RContentManager::ServerState\n"));
+
+ TCmServerState state;
+ TPckg<TCmServerState> pckg( state );
+ SendReceive( ECmGetServerState, TIpcArgs( &pckg ) );
+
+ return state;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetServiceState
+// ---------------------------------------------------------------------------
+EXPORT_C TInt RContentManager::SetServiceState( const TCmService aService,
+ const TCmServiceState aNewState )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetServiceState\n"));
+
+ TRACE(Print(_L("[Cm Server]\t service %d state %d \n"),
+ aService, (TInt)aNewState ));
+
+ SendReceive( ECmSetServiceState, TIpcArgs( aService, aNewState ) );
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::ServiceState
+// ---------------------------------------------------------------------------
+EXPORT_C TCmServiceState RContentManager::ServiceState
+ ( const TCmService aService ) const
+ {
+ LOG(_L("[Cm Server]\t RContentManager::ServiceState\n"));
+
+ TCmServiceState state;
+ TPckg<TCmServiceState> pckg( state );
+ SendReceive( ECmGetServiceState, TIpcArgs( aService, &pckg ) );
+
+ return state;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::ExecuteService
+// ---------------------------------------------------------------------------
+EXPORT_C TInt RContentManager::ExecuteService( const TCmService aService,
+ TRequestStatus& aStatus )
+ {
+ TRACE( Print (_L("[Cm Server]\t RContentManager::ExecuteServiceL \
+ aService = %d\n"), aService ));
+
+ SendReceive( ECmExecuteService, TIpcArgs( aService ), aStatus );
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::GetItemCountsL
+// ---------------------------------------------------------------------------
+
+EXPORT_C TInt RContentManager::GetItemCountsL( const TCmService aService,
+ const TDesC8& aListName,
+ TInt& aCount,
+ TInt64& aSize ) const
+ {
+ TRACE( Print( _L("[Cm Server]\t RContentManager::GetItemCountsL \
+ service = %d\n"), aService ));
+
+ if ( aService != ECmServiceFill &&
+ aService != ECmServiceStore )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::ItemCount wrong argument\n"));
+ User::Leave( KErrArgument );
+ }
+ TPckg<TInt> countPckg( aCount );
+ TPckg<TInt64> sizePckg( aSize );
+
+ SendReceive( ECmGetItemCount,
+ TIpcArgs( &countPckg, &sizePckg, aService, &aListName ) );
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// Get filled files size
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::GetFilledFilesSize( TInt64& aSize, const TInt aID ) const
+ {
+ TPckg<TInt64> sizePckg( aSize );
+ SendReceive( ECmGetFilledFilesSize, TIpcArgs( &sizePckg, aID ) );
+ }
+
+// RContentManager::GetTransferInfo
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::GetTransferInfo( const TCmService aService,
+ TInt& aItemCount,
+ TInt& aTimeInSec ) const
+ {
+ TRACE( Print( _L("[Cm Server]\t RContentManager::GetTransferInfo \
+ service = %d\n"), aService ));
+ TPckg<TInt> countPckg( aItemCount );
+ TPckg<TInt> timePckg( aTimeInSec );
+ SendReceive( ECmGetTransferInfo,
+ TIpcArgs( aService, &countPckg, &timePckg ) );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::GetFilteredMetadataL
+// ---------------------------------------------------------------------------
+EXPORT_C TInt RContentManager::GetFilteredMetadataL(
+ const TCmService aService,
+ CCmSqlPropertyCollector*& aCollector,
+ TRequestStatus& aStatus )
+ {
+ TRACE( Print( _L("[Cm Server]\t RContentManager::GetFilteredMetadataL \
+ service = %d\n"), aService ));
+
+ if ( aService != ECmServiceFill &&
+ aService != ECmServiceStore )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::GetFilteredMetadataL \
+ wrong argument\n"));
+ User::Leave( KErrArgument );
+ }
+
+ iCanceled = EFalse;
+
+ if ( iAo )
+ {
+ delete iAo; iAo = NULL;
+ }
+ iAo = CCmActive::NewL( *this );
+
+ iBuffer = CBufFlat::NewL( KKilo );
+ RBufWriteStream stream;
+ stream.Open( *iBuffer );
+ CleanupClosePushL( stream );
+ aCollector->ExternalizeL( stream );
+
+ iBufferPointer.Set( iBuffer->Ptr(0) );
+ SendReceive( ECmGetDataFields,
+ TIpcArgs( &iBufferPointer ),
+ iAo->iStatus);
+
+ CleanupStack::PopAndDestroy(); // stream
+
+ iAo->RunL();
+
+ aStatus = KRequestPending;
+ iTargetContainer = &aCollector;
+
+ iClientRequest = &aStatus;
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::DeleteMetadataL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::UpdateFillListsL( TRequestStatus& aStatus )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::UpdateFillListsL\n"));
+ SendReceive( ECmUpdateFillLists, aStatus );
+ }
+
+// ---------------------------------------------------------------------------
+// Deleting metadata harvested from unselected servers
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::DeleteMetadataL(
+ TRequestStatus& aStatus )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::DeleteMetadataL\n"));
+ if( iBuffer )
+ {
+ delete iBuffer;
+ iBuffer = NULL;
+ }
+ iBuffer = CBufFlat::NewL( KKilo );
+ RBufWriteStream stream;
+ stream.Open( *iBuffer );
+ CleanupClosePushL( stream );
+
+ iBufferPointer.Set( iBuffer->Ptr(0) );
+ SendReceive( ECmDeleteMetadata,
+ TIpcArgs( &iBufferPointer ),
+ aStatus );
+ CleanupStack::PopAndDestroy( &stream );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::LastSyncTime
+// ---------------------------------------------------------------------------
+EXPORT_C TTime RContentManager::LastSyncTime() const
+ {
+ LOG(_L("[Cm Server]\t RContentManager::LastSyncTime\n"));
+ TTime syncTime( 0 );
+ TPckg<TTime> timePckg( syncTime );
+ SendReceive( ECmGetSyncTime, TIpcArgs( &timePckg ) );
+ return syncTime;
+ }
+
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetFillFileStatusesL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::SetFillFileStatusesL(
+ const RPointerArray<CCmBaseListItem>& aItems )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetFillFileStatusesL\n"));
+
+ CBufFlat* buffer = CBufFlat::NewL( KKilo );
+ CleanupStack::PushL( buffer );
+ RBufWriteStream stream;
+ stream.Open( *buffer );
+ CleanupClosePushL( stream );
+ for ( TInt i = 0; i < aItems.Count(); i++ )
+ {
+ aItems[ i ]->ExternalizeL( stream );
+ }
+
+ TPtrC8 bufferPointer = buffer->Ptr(0);
+ SendReceive( ECmSetFillFileStatuses,
+ TIpcArgs( &bufferPointer, aItems.Count() ) );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::AppWizardState
+// ---------------------------------------------------------------------------
+
+EXPORT_C TBool RContentManager::AppWizardState() const
+ {
+ LOG(_L("[Cm Server]\t RContentManager::AppWizardState\n"));
+
+ TInt appWizardState(0);
+ TPckg<TInt> wizardStatepckg( appWizardState );
+ SendReceive( ECmGetAppWizardState, TIpcArgs( &wizardStatepckg ) );
+
+ TBool returnvalue = EFalse;
+ if ( appWizardState == KAppWizardExecuted )
+ {
+ returnvalue = ETrue;
+ }
+ return returnvalue;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetAppWizardState
+// ---------------------------------------------------------------------------
+
+EXPORT_C TInt RContentManager::SetAppWizardState()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetAppWizardState\n"));
+
+ SendReceive( ECmSetAppWizardState );
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetFillRulesL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::SetFillRulesL(
+ const CCmFillRuleContainer& aFillRules )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetFillRulesL\n"));
+
+#ifdef _DEBUG
+ CCmFillRuleContainer* temp = (CCmFillRuleContainer*) &aFillRules;
+ TInt count = temp->FillRuleCount();
+ TRACE(Print(_L("[Cm Server]\t fill rule count is %d\n"), count));
+#endif
+
+ CBufFlat* buffer = CBufFlat::NewL( KKilo );
+ CleanupStack::PushL( buffer );
+ RBufWriteStream stream;
+ stream.Open( *buffer );
+ CleanupClosePushL( stream );
+ aFillRules.ExternalizeL( stream );
+ TPtrC8 bufferPointer = buffer->Ptr(0);
+ SendReceive( ECmSetFillRules, TIpcArgs( &bufferPointer ) );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::FillRulesL
+// ---------------------------------------------------------------------------
+EXPORT_C CCmFillRuleContainer* RContentManager::FillRulesL()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::FillRulesL\n"));
+ TInt size( 0 );
+ TPckg<TInt> pckg( size );
+ SendReceive( ECmGetFillRulesSize, TIpcArgs( &pckg ));
+ // for some reason the sendreceive sometimes leaves size as negative.
+ // leave if this is the case.
+ if ( size < 0 )
+ {
+ User::Leave( KErrArgument );
+ }
+ TRACE(Print(_L("[Cm Server]\t RContentManager: buffer size is %d\n"),
+ size) );
+ HBufC8* buffer = HBufC8::NewLC( size );
+ TPtr8 bufferPointer = buffer->Des();
+ SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );
+
+ RDesReadStream stream;
+ stream.Open( bufferPointer );
+ CleanupClosePushL( stream );
+ CCmFillRuleContainer* container = CCmFillRuleContainer::NewLC();
+ container->InternalizeL( stream );
+ CleanupStack::Pop( container );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ return container;
+ }
+
+
+// ---------------------------------------------------------------------------
+// RContentManager::ListItemsL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C RPointerArray<CCmBaseListItem>*
+ RContentManager::ListItemsL( const TDesC8& aListName,
+ TCmService aService )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::ListItemsL"));
+
+#ifdef _DEBUG
+ HBufC* listName16 = HBufC::NewLC( aListName.Length() );
+ listName16->Des().Copy( aListName );
+ TRACE( Print(_L("[Cm Server]\t RContentManager::FillListItemsL \
+ list name %S"), listName16 ) );
+ CleanupStack::PopAndDestroy( listName16 );
+#endif
+
+ TInt size( 0 );
+ TInt itemCount( 0 );
+ TPckg<TInt> sizePckg( size );
+ TPckg<TInt> countPckg( itemCount );
+
+ // Switch statement ensures that SendReceive is not called with other
+ // services that ECmGetFillItemsSize and ECmGetStoreItemsSize
+ switch ( aService )
+ {
+ case ECmServiceFill:
+ {
+ SendReceive( ECmGetFillItemsSize,
+ TIpcArgs( &aListName, &sizePckg, &countPckg ) );
+
+ break;
+ }
+ case ECmServiceStore:
+ {
+ SendReceive( ECmGetStoreItemsSize,
+ TIpcArgs( &aListName, &sizePckg, &countPckg ) );
+ break;
+ }
+ default:
+ {
+ LOG(_L("[Cm Server]\t RContentManager::ListItemsL \
+ service not supported"));
+ break;
+ }
+
+ }
+
+ TRACE( Print( _L("[Cm Server]\t RContentManager::ListItemsL \
+ size = %d, itemCount = %d"), size, itemCount ));
+
+ // Sendreceive leaves size or itemCount as negative
+ if ( size < 0 || itemCount < 0 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ HBufC8* buffer = HBufC8::NewLC( size );
+ TPtr8 bufferPointer = buffer->Des();
+ SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );
+ RDesReadStream stream;
+ stream.Open( bufferPointer );
+ CleanupClosePushL( stream );
+
+ RPointerArray<CCmBaseListItem>* itemArray =
+ new (ELeave)RPointerArray<CCmBaseListItem>();
+ CleanupStack::PushL( itemArray );
+ for( TInt i = 0; i < itemCount; i++ )
+ {
+ CCmBaseListItem* item = CCmBaseListItem::NewLC();
+ item->InternalizeL( stream );
+ itemArray->AppendL( item );
+ CleanupStack::Pop( item );
+ }
+
+ CleanupStack::Pop( itemArray );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ return itemArray;
+
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::PreProcessFillList
+// ---------------------------------------------------------------------------
+EXPORT_C TInt RContentManager::PreProcessFillList( const TDesC8& aListName,
+ TRequestStatus& aStatus )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::PreProcessFillList\n"));
+
+ SendReceive( ECmPreProcessFillList, TIpcArgs( &aListName ), aStatus );
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::MediaserversL
+// ---------------------------------------------------------------------------
+
+EXPORT_C RPointerArray<CCmMediaServerFull>*
+ RContentManager::MediaserversL() const
+ {
+ LOG(_L("[Cm Server]\t RContentManager::MediaServersL\n"));
+ TInt size( 0 );
+ TInt amount( 0 );
+ TPckg<TInt> pckg( size );
+ TPckg<TInt> pckg2( amount );
+
+ SendReceive( ECmGetMediaserversSize, TIpcArgs( &pckg, &pckg2 ) );
+ // Sendreceive leaves size or amount as negative
+ if ( size < 0 || amount < 0 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager: \
+ buffer size is %d, amount %d\n"), size, amount));
+
+ HBufC8* buffer = HBufC8::NewLC( size );
+ TPtr8 bufferPointer = buffer->Des();
+ SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );
+
+ RDesReadStream stream;
+ stream.Open( bufferPointer );
+ CleanupClosePushL( stream );
+
+ RPointerArray<CCmMediaServerFull>* mediaServers =
+ new (ELeave) RPointerArray<CCmMediaServerFull>();
+ CleanupStack::PushL( mediaServers );
+
+ for ( TInt i = 0; i < amount; i++ )
+ {
+ CCmMediaServerFull* tempServer = CCmMediaServerFull::NewLC();
+ tempServer->InternalizeL( stream );
+ mediaServers->Append( tempServer );
+ CleanupStack::Pop( tempServer );
+ }
+ CleanupStack::Pop( mediaServers );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ return mediaServers;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetMediaserversL
+// ---------------------------------------------------------------------------
+EXPORT_C TInt RContentManager::SetMediaserversL(
+ RPointerArray<CCmMediaServerFull>& aMediaServers )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetMediaserversL\n"));
+
+ CBufFlat* buffer = CBufFlat::NewL( KKilo );
+ CleanupStack::PushL( buffer );
+ RBufWriteStream stream;
+ stream.Open( *buffer );
+ CleanupClosePushL( stream );
+ for ( TInt i = 0; i < aMediaServers.Count(); i++ )
+ {
+ aMediaServers[ i ]->ExternalizeL( stream );
+ }
+
+ TPtrC8 bufferPointer = buffer->Ptr(0);
+ SendReceive( ECmSetMediaServers,
+ TIpcArgs( &bufferPointer, aMediaServers.Count() ) );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::DeleteDeletedMediaserversL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::DeleteDeletedMediaserversL()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::DeleteDeletedMediaserversL\n"));
+ SendReceive( ECmDeleteDeletedMediaServers );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetStoreRulesL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::SetStoreRulesL(
+ const CCmStoreRuleContainer& aStoreRules )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetStoreRulesL\n"));
+
+#ifdef _DEBUG
+ CCmStoreRuleContainer* temp = (CCmStoreRuleContainer*) &aStoreRules;
+ TInt count = temp->StoreRuleCount();
+ TRACE(Print(_L("[Cm Server]\t store rule count is %d\n"), count));
+#endif
+
+ CBufFlat* buffer = CBufFlat::NewL( KKilo );
+ CleanupStack::PushL( buffer );
+ RBufWriteStream stream;
+ stream.Open( *buffer );
+ CleanupClosePushL( stream );
+ aStoreRules.ExternalizeL( stream );
+ TPtrC8 bufferPointer = buffer->Ptr(0);
+ SendReceive( ECmSetStoreRules, TIpcArgs( &bufferPointer ) );
+ CleanupStack::PopAndDestroy( 2, buffer );
+
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::StoreRulesL
+// ---------------------------------------------------------------------------
+EXPORT_C CCmStoreRuleContainer* RContentManager::StoreRulesL()
+ {
+ LOG(_L("[Cm Server]\t RContentManager::StoreRulesL\n"));
+ TInt size( 0 );
+ TPckg<TInt> pckg( size );
+ SendReceive( ECmGetStoreRulesSize, TIpcArgs( &pckg ) );
+ // Sendreceive leaves size as negative
+ if ( size < 0 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager: buffer size is %d\n"),
+ size));
+
+ HBufC8* buffer = HBufC8::NewLC( size );
+ TPtr8 bufferPointer = buffer->Des();
+ SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );
+
+ RDesReadStream stream;
+ stream.Open( bufferPointer );
+ CleanupClosePushL( stream );
+ CCmStoreRuleContainer* container = CCmStoreRuleContainer::NewLC();
+ container->InternalizeL( stream );
+ CleanupStack::Pop( container );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ return container;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::SetDrivesL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::SetDrivesL(
+ RPointerArray<CCmDriveInfo> aDrives )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::SetDrivesL\n"));
+
+ CBufFlat* buffer = CBufFlat::NewL( KKilo );
+ CleanupStack::PushL( buffer );
+ RBufWriteStream stream;
+ stream.Open( *buffer );
+ CleanupClosePushL( stream );
+
+ for ( TInt i = 0; i < aDrives.Count(); i++ )
+ {
+ aDrives[ i ]->ExternalizeL( stream );
+ }
+
+ TPtrC8 bufferPointer = buffer->Ptr(0);
+ SendReceive( ECmSetDrives,
+ TIpcArgs( &bufferPointer, aDrives.Count() ) );
+ CleanupStack::PopAndDestroy( 2, buffer );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::GetDrivesL
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::GetDrivesL(
+ RPointerArray<CCmDriveInfo>& aDrives )
+ {
+ LOG(_L("[Cm Server]\t RContentManager::GetDrivesL\n"));
+ TInt size( 0 );
+ TInt amount( 0 );
+ TPckg<TInt> pckg( size );
+ TPckg<TInt> pckg2( amount );
+ SendReceive( ECmGetDrivesSize, TIpcArgs( &pckg, &pckg2 ) );
+ // Sendreceive leaves size or amount as negative
+ if ( size < 0 || amount < 0 )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TRACE(Print(_L("[Cm Server]\t RContentManager: \
+ buffer size is %d, amount %d\n"), size, amount));
+
+ HBufC8* buffer = HBufC8::NewLC( size );
+ TPtr8 bufferPointer = buffer->Des();
+ SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );
+
+ RDesReadStream stream;
+ stream.Open( bufferPointer );
+ CleanupClosePushL( stream );
+
+ for ( TInt i = 0; i < amount; i++ )
+ {
+ CCmDriveInfo* tempDrive = CCmDriveInfo::NewLC();
+ tempDrive->InternalizeL( stream );
+ aDrives.Append( tempDrive );
+ CleanupStack::Pop( tempDrive );
+ }
+ CleanupStack::PopAndDestroy( 2, buffer );
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::DriveSelectionStatus
+// ---------------------------------------------------------------------------
+EXPORT_C TBool RContentManager::DriveSelectionStatus()
+ {
+ LOG(_L("[Cm Server]\t RContentManager: DriveSelectionStatus\n"));
+
+ TBool status( EFalse );
+ TPckg<TBool> pckg( status );
+
+ SendReceive( ECmGetDriveSelectionStatus, TIpcArgs( &pckg ) );
+ return status;
+ }
+
+// ---------------------------------------------------------------------------
+// RContentManager::ApplicationExit
+// ---------------------------------------------------------------------------
+EXPORT_C void RContentManager::ApplicationExit()
+ {
+ LOG(_L("[Cm Server]\t RContentManager: ApplicationExit\n"));
+ iCanceled = ETrue;
+
+ SendReceive( ECmApplicationExit, TIpcArgs() );
+ }
+
+// End of file