--- a/homesync/contentmanager/cmserver/cmserver/src/client/cmclientsession.cpp Mon Nov 01 13:44:24 2010 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,938 +0,0 @@
-/*
-* 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.AppendL( 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