1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  This is Metadata engine client session file

    15 *

    16 */

    17 

    18 #include <e32std.h>

    19 #include <f32file.h>

    20 

    21 // INCLUDE FILES

    22 #include "mdeenginesession.h"

    23 #include "mdcserializationbuffer.h"

    24 #include "mdequerycriteriaserialization.h"

    25 #include "mdesessionimpl.h"

    26 #include "mdsutils.h"

    27 

    28 RMdEEngineSession::RMdEEngineSession(CMdESessionImpl& aSession) 

    29 	: RSessionBase(), iSession( aSession )

    30     {

    31    	iIsSessionOpen = EFalse;

    32    	iIsSessionProcessOpen = EFalse;

    33     }

    34 

    35 void RMdEEngineSession::OpenL(TRequestStatus& aStatus)

    36     {

    37     TFindServer findMdEServer( KMdSServerName );

    38     TFullName name;

    39 

    40     const TInt result = findMdEServer.Next( name );

    41     if( result == KErrNone )

    42         {

    43         // Server already running

    44 		iIsSessionProcessOpen = ETrue;

    45 

    46 		TRequestStatus* status = &aStatus;

    47         User::RequestComplete( status, KErrNone );

    48 

    49         return;

    50         }

    51 

    52     User::LeaveIfError( iServerProcess.Create( KMdSServerFilename, 

    53     		KNullDesC ) );

    54 

    55 	iIsSessionProcessOpen = ETrue;

    56 

    57     iServerProcess.Rendezvous( aStatus );

    58 

    59     if( aStatus != KRequestPending )

    60     	{

    61         iServerProcess.Kill( 0 );   // abort startup

    62     	}

    63     else

    64     	{

    65         iServerProcess.Resume();    // logon OK - start the server   

    66     	}

    67     }

    68 

    69 void RMdEEngineSession::OpenCancel(TRequestStatus& aStatus)

    70 	{

    71 	if( iIsSessionProcessOpen )

    72 		{		

    73 		iServerProcess.RendezvousCancel( aStatus );

    74 

    75 		iServerProcess.Close();

    76 	

    77 		iIsSessionProcessOpen = EFalse;

    78 		}

    79 	}

    80 

    81 void RMdEEngineSession::ConnectL()

    82     {

    83     if( iIsSessionProcessOpen )

    84     	{

    85 	    TBool error = (iServerProcess.ExitType() != EExitPending);

    86 

    87     	iServerProcess.Close();

    88 

    89 		iIsSessionProcessOpen = EFalse;

    90 	

    91 		if( error )

    92 			{

    93 			User::LeaveIfError( KErrCommsBreak );

    94 			}

    95 

    96 	    const TInt result = CreateSession( 

    97 	    	KMdSServerName,

    98 			Version(),

    99 	        KMetadataMessageSlots,

   100 	        EIpcSession_Unsharable );

   101 

   102 		User::LeaveIfError( result );

   103 		

   104 		iIsSessionOpen = ETrue;

   105     	}

   106     else

   107     	{

   108     	User::LeaveIfError( KErrBadHandle );

   109     	}

   110     }

   111 

   112 TInt RMdEEngineSession::Shutdown()

   113     {

   114     TInt err = KErrNone;

   115 

   116     if( iIsSessionOpen )

   117     	{

   118 	    err = SendReceive( EShutdown );

   119     	}

   120 

   121 	if( iIsSessionProcessOpen )

   122 		{		

   123 		iServerProcess.Close();

   124 

   125 		iIsSessionProcessOpen = EFalse;

   126 		}

   127 

   128     return err;

   129     }

   130 

   131 TVersion RMdEEngineSession::Version() const

   132     {

   133     return( TVersion( KMdSServMajorVersionNumber,

   134                       KMdSServMinorVersionNumber,

   135                       KMdSServBuildVersionNumber ) );

   136     }

   137 

   138 void RMdEEngineSession::DoAddEventDefL(const TDefId aNameSpaceId, 

   139 		const TDesC &aName )

   140 	{

   141 	TIpcArgs ipcArgs;

   142 	ipcArgs.Set( EAddDefArgNamespaceId, aNameSpaceId );

   143 	ipcArgs.Set( EAddDefArgDefName,     &aName );

   144     const TInt ret = SendReceive( EAddEventDef, ipcArgs );

   145     

   146     NotifySessionError( ret );

   147     

   148     User::LeaveIfError( ret );

   149 	}

   150 

   151 void RMdEEngineSession::DoAddRelationDefL(const TDefId aNameSpaceId, 

   152 		const TDesC &aName )

   153 	{

   154 	TIpcArgs ipcArgs;

   155 	ipcArgs.Set( EAddDefArgNamespaceId, aNameSpaceId );

   156 	ipcArgs.Set( EAddDefArgDefName,     &aName );

   157     const TInt ret = SendReceive( EAddRelationDef, ipcArgs );

   158     

   159     NotifySessionError( ret );

   160     

   161     User::LeaveIfError( ret );

   162 	}

   163 

   164 void RMdEEngineSession::DoAddItemsL( 

   165 		const CMdCSerializationBuffer& aSerializedBuffer, 

   166 		CMdCSerializationBuffer& aResultBuffer )

   167     {

   168     TIpcArgs ipcArgs;

   169     ipcArgs.Set( 0, aSerializedBuffer.BufferConstPtr() );

   170     ipcArgs.Set( 1, aResultBuffer.BufferPtr() );

   171     const TInt ret = SendReceive( EAdd, ipcArgs );

   172     

   173     NotifySessionError( ret );

   174     

   175     User::LeaveIfError( ret );

   176     }

   177 

   178 void RMdEEngineSession::DoAddItemsAsync( 

   179 		const CMdCSerializationBuffer& aSerializedBuffer, 

   180 		CMdCSerializationBuffer& aResultBuffer, TRequestStatus& aStatus )

   181     {

   182     TIpcArgs ipcArgs;

   183     ipcArgs.Set( 0, aSerializedBuffer.BufferConstPtr() );

   184     ipcArgs.Set( 1, aResultBuffer.BufferPtr() );

   185 	SendReceive( EAdd, ipcArgs, aStatus );

   186     }

   187 

   188 void RMdEEngineSession::DoUpdateItemsL( 

   189 		const CMdCSerializationBuffer& aSerializedBuffer, 

   190 		CMdCSerializationBuffer& aResultBuffer )

   191     {

   192     TIpcArgs ipcArgs;

   193     ipcArgs.Set( 0, aSerializedBuffer.BufferConstPtr() );

   194     ipcArgs.Set( 1, aResultBuffer.BufferPtr() );

   195     const TInt ret = SendReceive( EUpdate, ipcArgs );

   196     

   197     NotifySessionError( ret );

   198     

   199     User::LeaveIfError( ret );

   200     }

   201 

   202 void RMdEEngineSession::DoUpdateItemsAsync( 

   203 		const CMdCSerializationBuffer& aSerializedBuffer, 

   204 		CMdCSerializationBuffer& aResultBuffer, TRequestStatus& aStatus )

   205     {

   206     TIpcArgs ipcArgs;

   207     ipcArgs.Set( 0, aSerializedBuffer.BufferConstPtr() );

   208     ipcArgs.Set( 1, aResultBuffer.BufferPtr() );

   209 	SendReceive( EUpdate, ipcArgs, aStatus );

   210     }

   211     

   212 CMdCSerializationBuffer* RMdEEngineSession::DoFindSyncLC( 

   213 	const CMdEQuery* aQuery, 

   214     const CMdEQueryCriteriaSerialization& aSerializationBuffer, 

   215     TMdCQueryLockType aLocktype, TUint32 aNotifyCount)

   216 	{

   217     TIpcArgs ipcArgs;

   218     TPckgBuf<TInt> size(0);

   219 

   220     ipcArgs.Set( EFindArgQueryId,         (TUint32)aQuery->GetQueryId() );

   221     ipcArgs.Set( EFindArgConditions,      aSerializationBuffer.BufferPtr() );

   222     ipcArgs.Set( EFindArgResulBufferSize, &size );

   223     ipcArgs.Set( EFindArgNotifyCount,     aNotifyCount );	

   224 

   225     const TInt err = SendReceive( EFind, ipcArgs );

   226     

   227     NotifySessionError( err );

   228     

   229     User::LeaveIfError( err );

   230 

   231     CMdCSerializationBuffer* resultBuf = 

   232     	CMdCSerializationBuffer::NewLC( size() );

   233 

   234     DoGetDataL( aQuery, resultBuf, EFind, aLocktype );

   235 

   236     return resultBuf;	

   237 	}

   238 

   239 void RMdEEngineSession::DoFindAsync( TUint32 aQueryId, 

   240 		const CMdEQueryCriteriaSerialization& aSerializationBuffer,

   241 		TPckgBuf<TInt>* aSizeBuf, TRequestStatus& aAsyncStatus, 

   242 		TUint32 aNotifyCount )

   243     {

   244     TIpcArgs ipcArgs;

   245 

   246     ipcArgs.Set( EFindArgQueryId,         (TUint32)aQueryId );

   247     ipcArgs.Set( EFindArgConditions,      aSerializationBuffer.BufferPtr() );

   248     ipcArgs.Set( EFindArgResulBufferSize, aSizeBuf );

   249     ipcArgs.Set( EFindArgNotifyCount,     aNotifyCount );

   250 

   251     SendReceive( EAsyncFind, ipcArgs, aAsyncStatus );

   252     }

   253 

   254 void RMdEEngineSession::DoFindContinue( 

   255 	const CMdEQuery* aQuery, 

   256     TPckgBuf<TInt>* aSizeBuf,

   257     TRequestStatus& aAsyncStatus )

   258     {

   259     TIpcArgs ipcArgs;

   260 

   261     ipcArgs.Set( EFindArgQueryId,         (TUint32)aQuery->GetQueryId() );

   262     ipcArgs.Set( EFindArgResulBufferSize, aSizeBuf );

   263 

   264     SendReceive( EContinueAsyncFind, ipcArgs, aAsyncStatus );

   265     }

   266 

   267 void RMdEEngineSession::DoFindCancelL( const CMdEQuery* aQuery )

   268     {

   269     // silently skip if session is not open

   270     if( iIsSessionOpen )

   271     	{

   272     	TIpcArgs ipcArgs;

   273     	ipcArgs.Set( EFindArgQueryId, (TUint32)aQuery->GetQueryId() );

   274 

   275 	    const TInt err = SendReceive( ECancelFind, ipcArgs );

   276 	

   277 	    NotifySessionError( err );

   278 	    

   279 	    User::LeaveIfError( err );

   280     	}

   281     }

   282     

   283 void RMdEEngineSession::DoCheckObjectL( 

   284 		CMdCSerializationBuffer& aObjectBuffer, const TDesC& aUri, 

   285 		TDefId aNamespaceDefId )

   286 	{

   287 	TIpcArgs ipcArgs;

   288 

   289 	TPckgBuf<TDefId> namespaceDefId( aNamespaceDefId );

   290 

   291 	ipcArgs.Set( ECheckObjectArgType,           ECheckObjectByUri );

   292 	ipcArgs.Set( ECheckObjectArgTypeValue,      &aUri );

   293 	ipcArgs.Set( ECheckObjectArgNamespaceDefId, &namespaceDefId );

   294 	ipcArgs.Set( ECheckObjectArgObject,         aObjectBuffer.BufferPtr() );

   295 

   296 	TInt err = SendReceive( ECheckObject, ipcArgs );

   297 	

   298 	NotifySessionError( err );

   299 	

   300 	User::LeaveIfError( err );

   301 	}

   302 

   303 void RMdEEngineSession::DoCheckObjectL( 

   304 		CMdCSerializationBuffer& aObjectBuffer, TItemId aId, 

   305 		TDefId aNamespaceDefId )

   306 	{

   307 	TIpcArgs ipcArgs;

   308 	TPckgBuf<TDefId> namespaceDefId( aNamespaceDefId );

   309 	TPckgBuf<TItemId> objectId( aId );

   310 

   311 	ipcArgs.Set( ECheckObjectArgType,           ECheckObjectById );

   312 	ipcArgs.Set( ECheckObjectArgTypeValue,      &objectId );

   313 	ipcArgs.Set( ECheckObjectArgNamespaceDefId, &namespaceDefId );

   314 	ipcArgs.Set( ECheckObjectArgObject,         aObjectBuffer.BufferPtr() );

   315 

   316 	TInt err = SendReceive( ECheckObject, ipcArgs );

   317 	

   318 	NotifySessionError( err );

   319 	

   320 	User::LeaveIfError( err );

   321 	}

   322 

   323 void RMdEEngineSession::DoCheckObjectL( 

   324 		CMdCSerializationBuffer& aObjectsBuffer, 

   325 		const CMdCSerializationBuffer& aObjectIdsBuffer, 

   326 		TDefId aNamespaceDefId )

   327 	{

   328 	TIpcArgs ipcArgs;

   329 	TPckgBuf<TDefId> namespaceDefId( aNamespaceDefId );

   330 

   331 	ipcArgs.Set( ECheckObjectArgType,           ECheckObjectByIds );

   332 	ipcArgs.Set( ECheckObjectArgTypeValue,      aObjectIdsBuffer.BufferPtr() );

   333 	ipcArgs.Set( ECheckObjectArgNamespaceDefId, &namespaceDefId );

   334 	ipcArgs.Set( ECheckObjectArgObject,         aObjectsBuffer.BufferPtr() );

   335 

   336 	TInt err = SendReceive( ECheckObject, ipcArgs );

   337 	

   338 	NotifySessionError( err );

   339 	

   340 	User::LeaveIfError( err );

   341 	}

   342 

   343 void RMdEEngineSession::DoCommitObjectsL( const CMdCSerializationBuffer& aCodedObjects )

   344 	{

   345 	TIpcArgs ipcArgs;

   346 	ipcArgs.Set( 0, aCodedObjects.BufferConstPtr() );

   347 

   348 	TInt err = SendReceive( EUpdate, ipcArgs );

   349 	

   350 	NotifySessionError( err );

   351 	

   352 	User::LeaveIfError( err );

   353 	}

   354 

   355 void RMdEEngineSession::DoCancelObjectL( CMdCSerializationBuffer& aRemoveId )

   356     {

   357     // silently skip if session is not open

   358     if( iIsSessionOpen )

   359     	{

   360 	    TIpcArgs ipcArgs;

   361 	    ipcArgs.Set( 0, aRemoveId.BufferPtr() );

   362 	

   363 	   	TInt err = SendReceive( ECancelObject, ipcArgs );

   364 	   	

   365 	   	NotifySessionError( err );

   366 	   	

   367 	   	User::LeaveIfError( err );

   368     	}

   369     }

   370 

   371 void RMdEEngineSession::DoRegisterL( TInt aId,

   372     TUint32 aType,

   373     CMdCSerializationBuffer& aBuffer,

   374     TDefId aNamespaceDefId )

   375     {

   376     TIpcArgs ipcArgs;

   377     ipcArgs.Set( 0, aId );

   378     ipcArgs.Set( 1, aType );

   379     ipcArgs.Set( 2, aBuffer.BufferPtr() );

   380     ipcArgs.Set( 3, aNamespaceDefId );

   381 

   382     const TInt err = SendReceive( ERegister, ipcArgs );

   383 

   384     NotifySessionError( err );

   385 

   386     User::LeaveIfError( err );

   387     }

   388 

   389 void RMdEEngineSession::DoListen( TInt aId,

   390     TPckgBuf<TInt>* aSizeBuf,

   391     TRequestStatus& aAsyncStatus )

   392     {

   393     TIpcArgs ipcArgs;

   394     ipcArgs.Set( 0, aId );

   395     ipcArgs.Set( 1, aSizeBuf );

   396 

   397     SendReceive( EListen, ipcArgs, aAsyncStatus );

   398     }

   399 

   400 void RMdEEngineSession::DoUnregisterL( TInt aId )

   401     {

   402     // silently skip if session is not open

   403     if( iIsSessionOpen )

   404     	{

   405 	    TIpcArgs ipcArgs;

   406 	    ipcArgs.Set( 0, aId );

   407 	

   408 	    const TInt err = SendReceive( EUnregister, ipcArgs );

   409 	

   410 	    NotifySessionError( err );

   411 	

   412 	    User::LeaveIfError( err );

   413     	}

   414     }

   415 

   416 void RMdEEngineSession::DoRemoveItemsL( const CMdCSerializationBuffer& aRemoveId, CMdCSerializationBuffer& aSuccessfulId )

   417     {

   418     TIpcArgs ipcArgs;

   419     ipcArgs.Set( 0, aRemoveId.BufferConstPtr() );

   420     ipcArgs.Set( 1, aSuccessfulId.BufferPtr() );

   421 

   422    	TInt err = SendReceive( ERemove, ipcArgs );

   423    	

   424    	NotifySessionError( err );

   425    	

   426    	User::LeaveIfError( err );

   427     }

   428 

   429 void RMdEEngineSession::DoRemoveItemsAsync( const CMdCSerializationBuffer& aRemoveId, CMdCSerializationBuffer& aSuccessfulId, TRequestStatus& aStatus )

   430     {

   431     TIpcArgs ipcArgs;

   432     ipcArgs.Set( 0, aRemoveId.BufferPtr() );

   433     ipcArgs.Set( 1, aSuccessfulId.BufferPtr() );

   434 

   435    	SendReceive( ERemove, ipcArgs, aStatus );

   436     }

   437 

   438 void RMdEEngineSession::DoLoadSchemaL( TInt& aHandle )

   439     {

   440     TPckgBuf<TInt> handleBuf;

   441 

   442     TIpcArgs ipcArgs;

   443     ipcArgs.Set( 1, &handleBuf );

   444     ipcArgs.Set( 2, ELoadSchema );

   445     

   446     const TInt err = SendReceive( EGetData, ipcArgs );

   447     

   448     NotifySessionError( err );

   449     

   450     User::LeaveIfError( err );

   451 

   452     aHandle = handleBuf();

   453     }

   454 

   455 void RMdEEngineSession::DoGetDataL( const CMdEQuery* aQuery, 

   456 	CMdCSerializationBuffer* aResultBuffer, 

   457 	TUint32 aRelatedCommand, TUint32 aExtraData)

   458 	{

   459 	TIpcArgs ipcArgs;

   460 

   461     ipcArgs.Set( 0, (TUint32)aQuery->GetQueryId() );

   462 	ipcArgs.Set( 1, aResultBuffer->BufferPtr() );

   463     ipcArgs.Set( 2, aRelatedCommand );

   464     ipcArgs.Set( 3, aExtraData );

   465 

   466     const TInt err = SendReceive( EGetData, ipcArgs );

   467     

   468     NotifySessionError( err );

   469     

   470     User::LeaveIfError( err );

   471 	}

   472 

   473 void RMdEEngineSession::DoGetDataL( CMdCSerializationBuffer& aBuffer, TUint32 aExtraData )

   474     {

   475     TIpcArgs ipcArgs;

   476     ipcArgs.Set( 0, 0 );

   477     ipcArgs.Set( 1, aBuffer.BufferPtr() );

   478     ipcArgs.Set( 2, EListen );

   479     ipcArgs.Set( 3, aExtraData );

   480     const TInt err = SendReceive( EGetData, ipcArgs );

   481     

   482     NotifySessionError( err );

   483     

   484     User::LeaveIfError( err );

   485     }

   486 

   487 void RMdEEngineSession::DoImportSchemaL( const TDesC& aFileName )

   488     {

   489     TIpcArgs ipcArgs;

   490     ipcArgs.Set( 0, &aFileName );

   491 

   492     const TInt err = SendReceive( EImportSchema, ipcArgs );

   493 

   494     NotifySessionError( err );

   495     

   496     User::LeaveIfError( err );

   497     }

   498     

   499 TInt RMdEEngineSession::DoImportMetadataL( const TDesC& aFileName )

   500     {

   501     TIpcArgs ipcArgs;

   502     TPckgBuf<TInt> failed;

   503     ipcArgs.Set( 0, &aFileName );

   504     ipcArgs.Set( 1, &failed );

   505 

   506     const TInt err = SendReceive( EImportMetadata, ipcArgs );

   507 

   508     NotifySessionError( err );

   509     

   510     User::LeaveIfError( err );    

   511     return failed();

   512     }

   513 

   514 void RMdEEngineSession::DoImportMetadata( const TDesC& aFileName, 

   515 		TPckgBuf<TInt>& aResult, TRequestStatus& aStatus )

   516     {

   517     TIpcArgs ipcArgs;

   518     ipcArgs.Set( 0, &aFileName );

   519     ipcArgs.Set( 1, &aResult );

   520 

   521     SendReceive( EAsyncImportMetadata, ipcArgs, aStatus );

   522     }

   523 

   524 void RMdEEngineSession::DoExportMetadataL( const TDesC& aFileName, 

   525 		const CMdCSerializationBuffer& aItems )

   526     {

   527     TIpcArgs ipcArgs;

   528     ipcArgs.Set( 0, &aFileName );

   529     ipcArgs.Set( 1, aItems.BufferConstPtr() );

   530 

   531     const TInt err = SendReceive( EExportMetadata, ipcArgs );

   532 

   533     NotifySessionError( err );

   534     

   535     User::LeaveIfError( err );    

   536     }

   537 

   538 void RMdEEngineSession::DoExportMetadataL( const TDesC& aFileName, 

   539 		const CMdCSerializationBuffer& aItems, TRequestStatus& aStatus )

   540     {

   541     TIpcArgs ipcArgs;

   542     ipcArgs.Set( 0, &aFileName );

   543     ipcArgs.Set( 1, aItems.BufferConstPtr() );

   544 

   545     SendReceive( EAsyncExportMetadata, ipcArgs, aStatus );

   546     }

   547 

   548 void RMdEEngineSession::DoAddMemoryCard(TUint32 aMediaId)

   549 	{

   550     TPckgC<TUint32> mediaIdPckg( aMediaId );

   551 

   552 	TIpcArgs ipcArgs;

   553     ipcArgs.Set( 0, &mediaIdPckg );

   554 

   555     const TInt err = SendReceive( EAddMemoryCard, ipcArgs );

   556 

   557     NotifySessionError( err );

   558 	}

   559 

   560 TBool RMdEEngineSession::DoGetMemoryCard(TUint32& aMediaId)

   561 	{

   562     TPckg<TUint32> mediaIdPckg( aMediaId );

   563 

   564 	TIpcArgs ipcArgs;

   565     ipcArgs.Set( 0, &mediaIdPckg );

   566 

   567     const TInt error = SendReceive( EGetMemoryCard, ipcArgs );

   568 

   569     NotifySessionError( error );

   570 

   571     if( error != KErrNone )

   572     	{

   573     	return EFalse;

   574     	}

   575     else

   576     	{

   577 	    aMediaId = mediaIdPckg();

   578     	return ETrue;

   579     	}

   580     }

   581 

   582 TBool RMdEEngineSession::DoCheckMemoryCard(TUint32 aMediaId, TBool& aExist)

   583 	{

   584     TPckgC<TUint32> mediaIdPckg( aMediaId );

   585     TPckg<TBool> existPckg( aExist );

   586 

   587 	TIpcArgs ipcArgs;

   588     ipcArgs.Set( 0, &mediaIdPckg );

   589     ipcArgs.Set( 1, &existPckg );

   590 

   591     const TInt error = SendReceive( ECheckMemoryCard, ipcArgs );

   592 

   593     NotifySessionError( error );

   594     

   595     if( error != KErrNone )

   596     	{

   597     	return EFalse;

   598     	}

   599     else

   600     	{

   601 	    aExist = existPckg();

   602     	return ETrue;

   603     	}

   604     }

   605 

   606 void RMdEEngineSession::DoSetMediaL(TUint32 aMediaId, TChar aDrive, 

   607 		TBool aPresentState)

   608 	{

   609     TPckgC<TUint32> mediaIdPckg( aMediaId );

   610     TPckgC<TChar> drivePckg( aDrive );

   611     TPckgC<TBool> presentStatePckg( aPresentState );

   612 

   613 	TIpcArgs ipcArgs;

   614     ipcArgs.Set( 0, &mediaIdPckg );

   615     ipcArgs.Set( 1, &drivePckg );

   616     ipcArgs.Set( 2, &presentStatePckg );

   617 

   618     const TInt err = SendReceive( ESetMedia, ipcArgs );

   619 

   620     NotifySessionError( err );

   621     

   622     User::LeaveIfError( err );

   623 	}

   624 

   625 TBool RMdEEngineSession::DoGetMediaL(TUint32 aMediaId, TChar& aDrive, 

   626 		TBool& aPresentState)

   627 	{

   628 	TPckgC<TUint32> mediaIdPckg( aMediaId );

   629     TPckg<TChar> drivePckg( aDrive );

   630     TPckg<TBool> presentStatePckg( aPresentState );

   631 

   632     TBool exists;

   633     TPckg<TBool> existsPckg( exists );

   634 

   635 	TIpcArgs ipcArgs;

   636     ipcArgs.Set( 0, &mediaIdPckg );

   637     ipcArgs.Set( 1, &drivePckg );

   638     ipcArgs.Set( 2, &presentStatePckg );

   639     ipcArgs.Set( 3, &existsPckg );

   640 

   641     const TInt error = SendReceive( EGetMedia, ipcArgs );

   642 

   643     NotifySessionError( error );

   644 

   645 	User::LeaveIfError( error );

   646 

   647 	aDrive = drivePckg();

   648 	aPresentState = presentStatePckg();

   649 	

   650 	exists = existsPckg();

   651 	

   652 	return exists;

   653     }

   654 

   655 void RMdEEngineSession::DoGetPresentMediasL(RArray<TMdEMediaInfo>& aMedias)

   656 	{

   657 	// buffer size for media info for every possible drive

   658 	const TInt KMediaInfoSize = sizeof( TMdEMediaInfo ) * KMaxDrives;

   659 

   660 	TInt32 mediaCount;

   661 	TPckg<TInt32> mediaCountPckg( mediaCount );

   662 	

   663 	HBufC8* mediaInfoBuffer = HBufC8::NewLC( KMediaInfoSize );

   664 	

   665 	TIpcArgs ipcArgs;

   666     ipcArgs.Set( 0, &mediaCountPckg );

   667     TPtr8 ptr( CONST_CAST( TUint8*, mediaInfoBuffer->Ptr() ), KMediaInfoSize );

   668     ipcArgs.Set( 1, &ptr );

   669 

   670 	TInt error = SendReceive( EGetPresentMedias, ipcArgs );

   671 

   672     NotifySessionError( error );

   673 

   674 	User::LeaveIfError( error );

   675 

   676 	mediaCount = mediaCountPckg();

   677 

   678 	aMedias.ReserveL( mediaCount );

   679 

   680 	mediaCount *= sizeof( TMdEMediaInfo );

   681 	

   682 	const TUint8* mediaInfoPtr = mediaInfoBuffer->Ptr();

   683 	

   684 	// get media infos from buffer

   685 	for( TInt32 i = 0; i < mediaCount; i += sizeof( TMdEMediaInfo ) )

   686 		{

   687 		const TMdEMediaInfo& mediaInfo = *STATIC_CAST( const TMdEMediaInfo*, 

   688 				(const TMdEMediaInfo*)( mediaInfoPtr + i ) );

   689 		

   690 		aMedias.AppendL( mediaInfo );

   691 		}

   692 	

   693 	CleanupStack::PopAndDestroy( mediaInfoBuffer );

   694 	}

   695 

   696 TBool RMdEEngineSession::DoSetFileToPresent(TUint32 aMediaId, 

   697 		const TDesC& aUri, TMdSFileInfo& aFileInfo)

   698 	{

   699     TPckgC<TUint32> mediaIdPckg( aMediaId );

   700     TPckgC<TMdSFileInfo> fileInfoPckg( aFileInfo );

   701 

   702 	TIpcArgs ipcArgs;

   703     ipcArgs.Set( 0, &mediaIdPckg );

   704     ipcArgs.Set( 1, &aUri );

   705     ipcArgs.Set( 2, &fileInfoPckg );

   706 

   707    	TInt error = SendReceive( ESetFileToPresent, ipcArgs );

   708 

   709    	NotifySessionError( error );

   710 

   711    	if( error != KErrNone )

   712     	{

   713     	return EFalse;

   714     	}

   715     else

   716     	{

   717     	return ETrue;

   718     	}

   719 	}

   720 

   721 TInt RMdEEngineSession::DoSetFilesToPresent(TMdSMediaIdAndCount aMediaIdAndCount, 

   722 		const TDes8& aUris, const TDes8& aFileInfos, TDes8& aResults)

   723 	{

   724     TPckgC<TMdSMediaIdAndCount> mediaIdAndCountPckg( aMediaIdAndCount );

   725 

   726 	TIpcArgs ipcArgs;

   727     ipcArgs.Set( 0, &mediaIdAndCountPckg );

   728     ipcArgs.Set( 1, &aUris );

   729     ipcArgs.Set( 2, &aFileInfos );

   730     ipcArgs.Set( 3, &aResults );

   731 

   732    	TInt error = SendReceive( ESetFilesToPresent, ipcArgs );

   733 

   734    	return error;

   735 	}

   736 

   737 void RMdEEngineSession::DoSetFilesToNotPresent(TUint32 aMediaId, TBool aStartUp)

   738 	{

   739     TPckgC<TUint32> mediaIdPckg( aMediaId );

   740     TPckgC<TBool> startUpPckg( aStartUp );

   741 

   742 	TIpcArgs ipcArgs;

   743     ipcArgs.Set( 0, &mediaIdPckg );

   744     ipcArgs.Set( 1, &startUpPckg );

   745 

   746     const TInt err = SendReceive( ESetFilesToNotPresent, ipcArgs );

   747 

   748     NotifySessionError( err );

   749 	}

   750 	

   751 void RMdEEngineSession::DoRemoveFilesNotPresent(TUint32 aMediaId, TBool aStartUp)

   752 	{

   753     TPckgC<TUint32> mediaIdPckg( aMediaId );

   754     TPckgC<TBool> startUpPckg( aStartUp );

   755 	

   756 	TIpcArgs ipcArgs;

   757     ipcArgs.Set( 0, &mediaIdPckg );

   758     ipcArgs.Set( 1, &startUpPckg );

   759 

   760     const TInt err = SendReceive( ERemoveFilesNotPresent, ipcArgs );

   761     

   762     NotifySessionError( err );

   763 	}

   764 

   765 void RMdEEngineSession::DoGetSchemaVersionL(

   766 		TInt& aMajorVersion, TInt& aMinorVersion)

   767 	{

   768     TPckg<TInt> majorVersion( aMajorVersion );

   769     TPckg<TInt> minorVersion( aMinorVersion );

   770 

   771 	TIpcArgs ipcArgs;

   772     ipcArgs.Set( 0, &majorVersion );

   773     ipcArgs.Set( 1, &minorVersion );

   774 

   775     const TInt err = SendReceive( EGetSchemaVersion, ipcArgs );

   776     

   777     NotifySessionError( err );

   778     

   779     User::LeaveIfError( err );

   780     }

   781 

   782 void RMdEEngineSession::DoSetObjectToPresentByGuidL( 

   783 		const TInt64& aGuidHigh, const TInt64& aGuidLow )

   784 	{

   785     TPckgC<TInt64> guidHigh( aGuidHigh );

   786     TPckgC<TInt64> guidLow( aGuidLow );

   787 

   788 	TIpcArgs ipcArgs;

   789     ipcArgs.Set( ESetObjectToPresentByGuidArgGuidHigh, &guidHigh );

   790     ipcArgs.Set( ESetObjectToPresentByGuidArgGuidLow,  &guidLow );

   791 

   792     const TInt err = SendReceive( ESetObjectToPresentByGuid, ipcArgs );

   793 

   794     NotifySessionError( err );

   795 

   796     User::LeaveIfError( err );

   797 	}

   798 

   799 void RMdEEngineSession::DoChangePath( 

   800 		const TDesC& aOldPath, const TDesC& aNewPath, TRequestStatus& aStatus )

   801 	{

   802 	TIpcArgs ipcArgs;

   803     ipcArgs.Set( 0, &aOldPath );

   804     ipcArgs.Set( 1, &aNewPath );

   805 

   806 	SendReceive( EChangePath, ipcArgs, aStatus );

   807 	}

   808 

   809 void RMdEEngineSession::DoChangeCDriveMediaId()

   810 	{

   811 	SendReceive( EChangeMediaId );

   812 	}

   813 

   814 void RMdEEngineSession::DoSetPendingL( const RArray<TItemId>& aObjectIds )

   815 	{

   816 	HBufC8* idBuffer = SerializeArrayL( aObjectIds );

   817 	CleanupStack::PushL( idBuffer );

   818 

   819 	TIpcArgs ipcArgs;

   820     ipcArgs.Set( 0, idBuffer );

   821 

   822     const TInt err = SendReceive( ESetPending, ipcArgs );

   823 

   824     NotifySessionError( err );

   825 

   826 	CleanupStack::PopAndDestroy( idBuffer );

   827 	}

   828 

   829 void RMdEEngineSession::DoResetPendingL( const RArray<TItemId>& aObjectIds )

   830 	{

   831 	HBufC8* idBuffer = SerializeArrayL( aObjectIds );

   832 	CleanupStack::PushL( idBuffer );

   833 

   834 	TIpcArgs ipcArgs;

   835     ipcArgs.Set( 0, idBuffer );

   836 

   837     const TInt err = SendReceive( EResetPending, ipcArgs );

   838 

   839     NotifySessionError( err );

   840 

   841 	CleanupStack::PopAndDestroy( idBuffer );

   842 	}

   843 	

   844 TInt RMdEEngineSession::DoGetPendingCount( const CMdEObjectDef* aObjectDef )

   845 	{

   846 	TDefId objectDefId = KNoDefId;

   847 	

   848 	if( aObjectDef )

   849 		{

   850 		objectDefId = aObjectDef->Id();

   851 		}

   852 

   853 	TPckg<TDefId> objectDefIdPckg( objectDefId );

   854 	TPckg<TInt> idCountPckg( 0 );

   855 	

   856 	TIpcArgs ipcArgs;

   857 	ipcArgs.Set( 0, &objectDefIdPckg );

   858 	ipcArgs.Set( 1, &idCountPckg );

   859 

   860     SendReceive( EGetPendingCount, ipcArgs );

   861 

   862     return idCountPckg();

   863 	}

   864 

   865 TInt RMdEEngineSession::DoGetPending( 

   866 		const CMdEObjectDef* aObjectDef, TInt& /* aObjectIdCount */, 

   867 		CMdCSerializationBuffer& aObjectIdBuffer )

   868 	{

   869 	TDefId objectDefId = KNoDefId;

   870 	

   871 	if( aObjectDef )

   872 		{

   873 		objectDefId = aObjectDef->Id();

   874 		}

   875 

   876 	TPckg<TDefId> objectDefIdPckg( objectDefId );

   877 	TPckg<TInt> idCountPckg( 0 );

   878 	TPckg<TInt> resultPckg( 0 );

   879 	TInt result( 0 );

   880 	

   881 	TIpcArgs ipcArgs;

   882 	ipcArgs.Set( 0, &objectDefIdPckg );

   883 	ipcArgs.Set( 1, &idCountPckg );

   884 	ipcArgs.Set( 2, aObjectIdBuffer.BufferPtr() );

   885 	ipcArgs.Set( 3, &resultPckg );

   886 	

   887     SendReceive( EGetPending, ipcArgs );

   888 

   889     result = resultPckg();

   890     

   891     return result;

   892 	}

   893 

   894 void RMdEEngineSession::DoResetDBL()

   895 	{

   896 	TInt err = SendReceive( EResetDB );

   897 

   898     NotifySessionError( err );

   899 

   900 	User::LeaveIfError( err );

   901 	}

   902 

   903 void RMdEEngineSession::DoSetHarvestingPrioritizationChunkL( 

   904 		RHandleBase aHandle )

   905 	{

   906 	TIpcArgs ipcArgs;

   907     ipcArgs.Set( 0, aHandle );

   908 

   909     const TInt err = SendReceive( ESetHarvestingPrioritizationChunk, ipcArgs );

   910     

   911     NotifySessionError( err );

   912     

   913     User::LeaveIfError( err );

   914 	}

   915 

   916 void RMdEEngineSession::DoAddHarvestingPrioritizationObserver( 

   917 		TRequestStatus& aStatus )

   918 	{

   919     SendReceive( EAddHarvestingPrioritizationObserver, aStatus );

   920 	}

   921 

   922 TInt RMdEEngineSession::DoCancelHarvestingPrioritizationObserver()

   923 	{

   924     const TInt err = SendReceive( ECancelHarvestingPrioritizationObserver );

   925     

   926     NotifySessionError( err );

   927     

   928     return err;

   929 	}

   930 

   931 void RMdEEngineSession::NotifySessionError( TInt aError )

   932 	{

   933 	if( aError != KErrServerTerminated )

   934 		{

   935 		return;

   936 		}

   937 	

   938 	iIsSessionOpen = EFalse;

   939 	iSession.NotifyError( aError );

   940 	}