diff -r 6369bfd1b60d -r 08b5eae9f9ff homesync/contentmanager/cmserver/cmserver/src/client/cmclientsession.cpp --- 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 -#include - -#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 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 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 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 countPckg( aCount ); - TPckg 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 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 countPckg( aItemCount ); - TPckg 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 timePckg( syncTime ); - SendReceive( ECmGetSyncTime, TIpcArgs( &timePckg ) ); - return syncTime; - } - - -// --------------------------------------------------------------------------- -// RContentManager::SetFillFileStatusesL -// --------------------------------------------------------------------------- -EXPORT_C void RContentManager::SetFillFileStatusesL( - const RPointerArray& 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 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 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* - 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 sizePckg( size ); - TPckg 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* itemArray = - new (ELeave)RPointerArray(); - 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* - RContentManager::MediaserversL() const - { - LOG(_L("[Cm Server]\t RContentManager::MediaServersL\n")); - TInt size( 0 ); - TInt amount( 0 ); - TPckg pckg( size ); - TPckg 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* mediaServers = - new (ELeave) RPointerArray(); - 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& 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 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 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& aDrives ) - { - LOG(_L("[Cm Server]\t RContentManager::GetDrivesL\n")); - TInt size( 0 ); - TInt amount( 0 ); - TPckg pckg( size ); - TPckg 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 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