1 /*

     2 * Copyright (c) 2006 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:  Message store session implementation.

    15 *

    16 */

    17 

    18 

    19 

    20 // ========

    21 // INCLUDES

    22 // ========

    23 

    24 #include "MsgStoreTypes.h"

    25 #include "MsgStorePropertyKeys.h"

    26 

    27 #include "MessageStoreSession.h"

    28 #include "MessageStoreServer.h"

    29 #include "ContainerStore.h"

    30 #include "PropertiesSerializer.h"

    31 #include "ContainerStoreMRUAddressTable.h"

    32 #include "bufferedmessagecreator.h"

    33 

    34 

    35 // =========

    36 // CONSTANTS

    37 // =========

    38 

    39 // The maximum number of observer events that will be queued up for a single session.

    40 const TInt KMsgStoreMaximumEventQueueDepth = 100;

    41 const TInt KInitialAddressBufSize          = 256;

    42 const TInt KSortedArrayGranularity         = 100;

    43 

    44 const TUint KValThree = 3;

    45 const TUint KGranularity25 = 25;

    46 const TUint KGranularity15 = 15;

    47 

    48 // ======================

    49 // CLASS CSearchResult

    50 // ======================

    51 // ==========================================================================

    52 // FUNCTION: NewL

    53 // ==========================================================================

    54 CSearchResult* CSearchResult::NewL( TContainerId aMessageId, TContainerId aFolderId, const TDesC8& aPropertyBuf )

    55     {

    56     CSearchResult* self = new(ELeave) CSearchResult( aMessageId, aFolderId );

    57     CleanupStack::PushL( self );

    58     self->ConstructL( aPropertyBuf );

    59     CleanupStack::Pop( self );

    60     return self;

    61     }

    62 

    63 CSearchResult* CSearchResult::SearchCompleteResultL()

    64     {

    65     return NewL( KContainerInvalidId, KContainerInvalidId, KNullDesC8 );

    66     }

    67 

    68 // ==========================================================================

    69 // FUNCTION: Constructor

    70 // ==========================================================================

    71 CSearchResult::CSearchResult( TContainerId aMessageId, TContainerId aFolderId )

    72     : iMessageId( aMessageId ), iFolderId( aFolderId )

    73     {

    74     }

    75 

    76 // ==========================================================================

    77 // FUNCTION: ConstructL

    78 // ==========================================================================

    79 void CSearchResult::ConstructL( const TDesC8& aPropertyBuf )

    80     {

    81     iPropertyBuf.Create( aPropertyBuf );

    82     }

    83 

    84 // ==========================================================================

    85 // FUNCTION: Destructor

    86 // ==========================================================================

    87 CSearchResult::~CSearchResult()

    88     {

    89     iPropertyBuf.Close();

    90     }

    91         

    92 

    93 // ==========================

    94 // CLASS CMessageStoreSession

    95 // ==========================

    96 // ==========================================================================

    97 // FUNCTION: Constructor

    98 // ==========================================================================

    99 CMessageStoreSession::CMessageStoreSession(CMessageStoreServer& aMessageStoreServer) : 

   100 	iServer(aMessageStoreServer),

   101 	iIds( KGranularity25 ),

   102 	iEventQueue( KGranularity15 ),

   103     iSearchHandler( NULL )

   104     {

   105   	__LOG_CONSTRUCT( "msg", "CMessageStoreSession" )

   106   	}

   107 

   108 // ==========================================================================

   109 // FUNCTION: CreateL

   110 // ==========================================================================

   111 void CMessageStoreSession::CreateL()

   112     {

   113     __LOG_ENTER( "CreateL" )

   114     

   115     iServer.AddSession( this );

   116 

   117     // This could leave if a session is created while the store is unavailable.

   118     TRAP_IGNORE( iServer.MessageStoreL().ObserveL( this ) );

   119     

   120     __LOG_EXIT

   121     } // end CreateL

   122 

   123 // ==========================================================================

   124 // FUNCTION: Destructor

   125 // ==========================================================================

   126 CMessageStoreSession::~CMessageStoreSession()	

   127 	{

   128     delete iBufferedMessageCreator;

   129     

   130 	iIds.Reset();

   131 	

   132     iMruAddressArray.ResetAndDestroy();

   133     

   134 	iPropertyNames.ResetAndDestroy();

   135     

   136 	iMatchMessages.ResetAndDestroy();

   137     

   138     iSearchStrings.ResetAndDestroy();

   139 	

   140 	delete iSearchHandler;

   141 	

   142 	TRAP_IGNORE( iServer.MessageStoreL().StopObserving( this ) );

   143 	

   144 	//close all the sort iterators when the client exits/crashes

   145 	for ( TInt i = 0 ; i < iSortSessionIds.Count(); i++  )

   146 	    {

   147 	    TRAP_IGNORE( iServer.MessageStoreL().EndSortingL( iSortSessionIds[i] ) );

   148 	    }

   149 	iSortSessionIds.Close();

   150 

   151 	iEventQueue.Close();

   152 

   153 	if( !iObserverMessage.IsNull() )

   154 		{

   155 		iObserverMessage.Complete( KErrCancel );

   156 		} // end if

   157 

   158 	if( !iGetMatchesMessage.IsNull() )

   159 		{

   160 		iGetMatchesMessage.Complete( KErrCancel );

   161 		} // end if

   162 

   163 	iServer.DropSession( this );

   164 

   165 	__LOG_DESTRUCT

   166 	} // end destructor

   167 

   168 // ==========================================================================

   169 // FUNCTION:ServiceL

   170 // ==========================================================================

   171 void CMessageStoreSession::ServiceL(const RMessage2& aMessage)

   172   {

   173   __LOG_ENTER_SUPPRESS( "ServiceL" )

   174   __LOG_WRITE8_FORMAT1_INFO( "%d", aMessage.Function() )

   175 

   176   // Call the appropriate message handler function, based on the message function ID.

   177   switch( aMessage.Function() )

   178     {

   179 	case EMsgStoreCmdAuthenticated:

   180 		DoAuthenticatedL( aMessage );

   181 		break;

   182         

   183 	case EMsgStoreCmdAuthenticate:

   184 		DoAuthenticateL( aMessage );

   185 		break;

   186         

   187 	case EMsgStoreCmdClearAuthentication:

   188 		DoClearAuthenticationL( aMessage );

   189 		break;

   190         

   191 	case EMsgStoreCmdHasPassword:

   192 		DoHasPasswordL( aMessage );

   193 		break;

   194         

   195 	case EMsgStoreCmdSetPassword:

   196 		DoSetPasswordL( aMessage );

   197 		break;

   198         

   199 	case EMsgStoreCmdChangePassword:

   200 		DoChangePasswordL( aMessage );

   201 		break;

   202         

   203     case EMsgStoreCmdEnableEncryption:

   204         DoEnableEncryptionL( aMessage );

   205         break;

   206         

   207     case EMsgStoreCmdDisableEncryption:

   208         DoDisableEncryptionL( aMessage );

   209         break;

   210         

   211 	case EMsgStoreCmdWipeEverything:

   212 		DoWipeEverythingL( aMessage );

   213 		break;

   214         

   215     case EMsgStoreCmdStartObserving:

   216 		DoStartObserving( aMessage );

   217 		break;

   218         

   219     case EMsgStoreCmdGetEvents:

   220 		DoGetEventsL( aMessage );

   221 		break;

   222         

   223     case EMsgStoreCmdStopObserving:	

   224 		DoStopObserving( aMessage );

   225 		break;

   226 		

   227     case EMsgStoreCmdCreateAccount:	

   228     	DoCreateAccountL( aMessage );

   229     	break;

   230     	

   231     case EMsgStoreCmdOpenAccount:	

   232 		DoOpenAccountL( aMessage );

   233 		break;

   234 		

   235     case EMsgStoreCmdDeleteAccount:	

   236 		DoDeleteAccountL( aMessage );

   237 		break;

   238 		

   239     case EMsgStoreCmdRenameAccount:	

   240 		DoRenameAccountL( aMessage );

   241 		break;

   242 		

   243     case EMsgStoreCmdListAccounts:	

   244 		DoListAccountsL( aMessage );

   245 		break;

   246     

   247     case EMsgStoreCmdCreateContainer:

   248 		DoCreateContainerL( aMessage );

   249 		break;

   250         

   251     case EMsgStoreCmdCommitContainer:

   252 		DoCommitContainerL( aMessage );

   253 		break;

   254         

   255     case EMsgStoreCmdAbandonContainer:

   256 		DoAbandonContainerL( aMessage );

   257 		break;

   258         

   259     case EMsgStoreCmdMoveContainer:

   260 		DoMoveContainerL( aMessage );

   261 		break;

   262         

   263     case EMsgStoreCmdCopyContainer:

   264 		DoCopyContainerL( aMessage );

   265 		break;

   266         

   267 	case EMsgStoreCmdDeleteContainer:

   268 		DoDeleteContainerL( aMessage );

   269 		break;

   270         

   271 	case EMsgStoreCmdChildrenCounts:

   272 		DoChildrenCountsL( aMessage );

   273 		break;

   274         

   275 	case EMsgStoreCmdTotalCounts:

   276 		DoTotalCountsL( aMessage );

   277 		break;

   278         

   279     case EMsgStoreCmdChildrenIds:

   280 		DoChildrenIdsL( aMessage );

   281 		break;

   282         

   283     case EMsgStoreCmdPropertiesList:

   284 		DoPropertiesListL( aMessage );

   285 		break;

   286         

   287 	case EMsgStoreCmdFetchProperties:

   288 		DoFetchPropertiesL( aMessage );

   289 		break;

   290         

   291 	case EMsgStoreCmdUpdateProperties:

   292 		DoUpdatePropertiesL( aMessage );

   293 		break;

   294         

   295 	case EMsgStoreCmdUpdateProperty:

   296 		DoUpdatePropertyL( aMessage );

   297 		break;

   298         

   299     case EMsgStoreCmdContentLength:

   300 		DoContentLengthL( aMessage );

   301 		break;

   302         

   303     case EMsgStoreCmdFetchContentToBuffer:

   304 		DoFetchContentToBufferL( aMessage );

   305 		break;

   306         

   307     case EMsgStoreCmdFetchContentToFile:

   308 		DoFetchContentToFileL( aMessage );

   309 		break;

   310         

   311     case EMsgStoreCmdReplaceContentWithBuffer:

   312 		DoReplaceContentWithBufferL( aMessage );

   313 		break;

   314         

   315     case EMsgStoreCmdReplaceContentWithFile:

   316 		DoReplaceContentWithFileL( aMessage );

   317 		break;

   318         

   319     case EMsgStoreCmdAppendToContent:

   320         DoAppendToContentL( aMessage );

   321 		break;

   322         

   323     case EMsgStoreCmdPrependToContent:

   324         DoPrependToContentL( aMessage );

   325         break;

   326 

   327     case EMsgStoreCmdRemoveContent:

   328 		DoRemoveContentL( aMessage );

   329 		break;

   330         

   331     case EMsgStoreCmdOpenContentFile:

   332         DoOpenContentFileL( aMessage );

   333         break;

   334         

   335     case EMsgStoreCmdPrepareSearch:

   336 		DoPrepareSearchL( aMessage );

   337 		break;

   338         

   339     case EMsgStoreCmdGetMatches:

   340 		DoGetMatches( aMessage );

   341 		break;

   342         

   343     case EMsgStoreCmdCancelSearch:

   344 		DoCancelSearch( aMessage );

   345 		break;

   346         

   347     case EMsgStoreCmdClearSearchResultCache:

   348         DoClearSearchResultCache( aMessage );

   349         break;

   350         

   351     case EMsgStoreCmdStartSorting:

   352         DoStartSortingL( aMessage );

   353         break;

   354         

   355     case EMsgStoreCmdEndSorting:

   356         DoEndSortingL( aMessage );

   357         break;

   358         

   359     case EMsgStoreCmdGetSortedRows:

   360         DoGetSortedRowsL( aMessage );

   361         break;

   362         

   363     case EMsgStoreCmdGetIteratorGroupCount:

   364         DoGetIteratorGroupCountL( aMessage );

   365         break;

   366 

   367     case EMsgStoreCmdGetIteratorIdsAndFlags:

   368         DoGetSortedIdsAndFlagsL( aMessage );

   369         break;

   370     

   371     case EMsgStoreCmdSortedIndexOf:

   372         DoGetSortedIndexOfL( aMessage );

   373         break;

   374 

   375     case EMsgStoreCmdGetIteratorIds:

   376         DoGetSortedIdsL( aMessage );

   377         break;

   378         

   379     case EMsgStoreCmdGetIteratorIdsAndGroupCount:

   380         DoGetSortedIdsAndGroupCountL( aMessage );

   381         break;

   382         

   383     case EMsgStoreCmdSetMaxMruAddressCount:

   384         DoSetMaxMruAdressCountL( aMessage );

   385         break;

   386         

   387     case EMsgStoreCmdSetMruAddressList:

   388         DoSetMruAddressListL( aMessage );

   389         break;

   390         

   391     case EMsgStoreCmdGetMruAddressList:

   392         DoGetMruAddressListL( aMessage );

   393         break;

   394         

   395     case EMsgStoreCmdBeginBatchInsert:

   396         DoBeginBatchInsertL( aMessage );

   397         break;

   398 

   399     case EMsgStoreCmdFinishBatchInsert:

   400         DoFinishBatchInsertL( aMessage );

   401         break;

   402 

   403 #ifdef _DEBUG

   404         

   405     case EMsgStoreCmdInjectBackupRestoreEvent:

   406         DoInjectBackupRestoreEventL( aMessage );

   407         break;

   408     case EMsgStoreCmdInjectPointSecEvent:

   409         DoInjectPointSecEvent( aMessage );

   410         break;

   411     case EMsgStoreCmdSimulateLowDiskSpace:

   412         DoSimulateLowDiskSpaceL( aMessage );

   413         break;

   414     case EMsgStoreCmdGetEncryptionState:

   415         DoGetEncryptionStateL( aMessage );

   416         break;

   417     case EMsgStoreCmdShutdownServer:

   418         DoShutdownServer( aMessage );

   419         break;

   420     

   421 #endif  

   422         

   423     default:

   424       __LOG_WRITE_ERROR( "Illegal function!" )

   425       PanicClient( aMessage, EPanicIllegalFunction );

   426       break;

   427     } // end switch

   428        

   429   __LOG_EXIT    

   430   } // end ServiceL

   431 

   432 // ==========================================================================

   433 // FUNCTION: ServiceError

   434 // ==========================================================================

   435 void CMessageStoreSession::ServiceError(const RMessage2& aMessage, TInt aError)

   436   {

   437   __LOG_ENTER_SUPPRESS( "ServiceError" )

   438   __LOG_WRITE8_FORMAT1_ERROR( "ServiceError %d", aError)

   439   CSession2::ServiceError( aMessage, aError );

   440   } // end ServiceError

   441 

   442 // ==========================================================================

   443 // FUNCTION: ContainerStoreUnavailable

   444 // ==========================================================================

   445 void CMessageStoreSession::ContainerStoreUnavailable()

   446 	{

   447     // Cancel any ongoing searches.

   448     delete iSearchHandler;

   449     iSearchHandler = NULL;

   450     iMatchMessages.ResetAndDestroy();    

   451     

   452 	TRAP_IGNORE( iServer.MessageStoreL().StopObserving( this ) );

   453 	} // end ContainerStoreUnavailable

   454 

   455 // ==========================================================================

   456 // FUNCTION: ContainerStoreAvailable

   457 // ==========================================================================

   458 void CMessageStoreSession::ContainerStoreAvailable()

   459 	{

   460 	TRAP_IGNORE( iServer.MessageStoreL().ObserveL( this ) );

   461 	} // end ContainerStoreAvailable

   462 

   463 // ----------------------

   464 // OBSERVER FUNCTIONALITY

   465 // ----------------------

   466 

   467 // ==========================================================================

   468 // FUNCTION: DoStartObserving

   469 // ==========================================================================

   470 void CMessageStoreSession::DoStartObserving( const RMessage2& aMessage )

   471 	{

   472 	iIsObserving = ETrue;

   473 	

   474 	aMessage.Complete( KErrNone );

   475 	} // end DoStartObserving

   476 	

   477 // ==========================================================================

   478 // FUNCTION: DoStopObserving

   479 // ==========================================================================

   480 void CMessageStoreSession::DoStopObserving( const RMessage2& aMessage )

   481 	{

   482 	iIsObserving = EFalse;

   483 	

   484 	iEventQueue.Reset();

   485 	

   486 	if( !iObserverMessage.IsNull() )

   487 		{

   488 		iObserverMessage.Complete( KErrCancel );

   489 		} // end if

   490 		

   491 	aMessage.Complete( KErrNone );

   492 	} // end DoStopObserving

   493 	

   494 // ==========================================================================

   495 // FUNCTION: DoCreateAccountL

   496 // ==========================================================================

   497 void CMessageStoreSession::DoCreateAccountL( const RMessage2& aMessage )

   498 	{

   499 	TInt32 ownerId = aMessage.Int1();

   500 

   501     RBuf name;    

   502     CleanupClosePushL( name );

   503     name.CreateL( aMessage.GetDesLengthL( 2 ) );

   504     

   505 	aMessage.ReadL( 2, name );

   506 	

   507 	RBuf8 propertiesBuf;

   508 	CleanupClosePushL( propertiesBuf );

   509 	propertiesBuf.CreateL( aMessage.GetDesLengthL( KValThree ) );

   510 	aMessage.ReadL( KValThree, propertiesBuf );

   511 	

   512 	TContainerId mbId = iServer.MessageStoreL().CreateAccountL( ownerId, name, this, propertiesBuf );

   513 	

   514     TPckg<TContainerId> mbIdPckg( mbId );

   515 	aMessage.WriteL( 0, mbIdPckg );

   516 	

   517 	CleanupStack::PopAndDestroy( &propertiesBuf );

   518 	CleanupStack::PopAndDestroy( &name );

   519 	

   520     aMessage.Complete( KErrNone );

   521 	}

   522 

   523 // ==========================================================================

   524 // FUNCTION: DoOpenAccountL

   525 // ==========================================================================

   526 void CMessageStoreSession::DoOpenAccountL( const RMessage2& aMessage )

   527 	{

   528 	__LOG_ENTER_SUPPRESS("DoOpenAccountL")

   529 	

   530 	//parameter 0 - result

   531 	TUint result;

   532 	TPckg<TUint> resultPckg( result );

   533 	

   534     //parameter 1 - params

   535 	TMsgStoreOpenAccountCmdParams params;

   536     TPckg<TMsgStoreOpenAccountCmdParams> paramsPckg( params );

   537 	aMessage.ReadL( 1, paramsPckg );

   538 	

   539 	TInt32 ownerId = params.iOwnerId;

   540 	

   541 	//parameter 2 - account anme

   542     RBuf name;    

   543     CleanupClosePushL( name );

   544     name.CreateL( aMessage.GetDesLengthL( 2 ) );

   545 	aMessage.ReadL( 2, name );

   546 	

   547 	//parameter 3 - property buf

   548 	RBuf8 propertiesBuf;

   549 	CleanupClosePushL( propertiesBuf );

   550 	

   551 	params.iMailBoxId = iServer.MessageStoreL().OpenAccountL( ownerId, name, propertiesBuf );

   552 	

   553 	if( propertiesBuf.Length() > aMessage.GetDesMaxLengthL( KValThree ) )

   554 	    {

   555 	    // Overflow!

   556 	    __LOG_WRITE8_FORMAT1_ERROR( "property buffer too long (%i)", propertiesBuf.Length() );

   557 	    

   558 	    // Write the required length to the result parameter, to indicate to the client that the

   559 	    // buffer must be increased to the given size.

   560 	    result = propertiesBuf.Length();

   561 	    aMessage.WriteL( 0, resultPckg );	    

   562 	    }

   563 	else

   564 	    {	    	

   565         result = 0;

   566 	    aMessage.WriteL( 0, resultPckg );

   567 	    

   568  	    aMessage.WriteL( 1, paramsPckg );

   569 

   570         aMessage.WriteL( KValThree, propertiesBuf );

   571 

   572 	    } // end if

   573 	

   574 	CleanupStack::PopAndDestroy( &propertiesBuf );

   575 	CleanupStack::PopAndDestroy( &name );

   576 	

   577     aMessage.Complete( KErrNone );

   578 	}

   579 

   580 // ==========================================================================

   581 // FUNCTION: DoRenameAccountL

   582 // ==========================================================================

   583 void CMessageStoreSession::DoRenameAccountL( const RMessage2& aMessage )

   584 	{

   585 	TInt32 ownerId = aMessage.Int0();

   586 

   587     RBuf oldName;    

   588     CleanupClosePushL( oldName );

   589     oldName.CreateL( aMessage.GetDesLengthL( 1 ) );

   590 	aMessage.ReadL( 1, oldName );

   591 	

   592     RBuf newName;    

   593     CleanupClosePushL( newName );

   594     newName.CreateL( aMessage.GetDesLengthL( 2 ) );

   595 	aMessage.ReadL( 2, newName );

   596 	

   597 	iServer.MessageStoreL().RenameAccountL( ownerId, oldName, newName, this );

   598 	

   599 	CleanupStack::PopAndDestroy( &newName );

   600 	CleanupStack::PopAndDestroy( &oldName );

   601 	

   602     aMessage.Complete( KErrNone );

   603 	}

   604 

   605 // ==========================================================================

   606 // FUNCTION: DoDeleteAccountL

   607 // ==========================================================================

   608 void CMessageStoreSession::DoDeleteAccountL( const RMessage2& aMessage )

   609 	{

   610 	TInt32 ownerId = aMessage.Int0();

   611 

   612     RBuf name;    

   613     CleanupClosePushL( name );

   614     name.CreateL( aMessage.GetDesLengthL( 1 ) );

   615 	aMessage.ReadL( 1, name );

   616 	

   617 	iServer.MessageStoreL().DeleteAccountL( ownerId, name, this );

   618 	

   619 	CleanupStack::PopAndDestroy( &name );

   620 	

   621     aMessage.Complete( KErrNone );

   622 	}

   623 

   624 // ==========================================================================

   625 // FUNCTION: DoListAccountsL

   626 // ==========================================================================

   627 void CMessageStoreSession::DoListAccountsL( const RMessage2& aMessage )

   628 	{

   629     RBuf8 resultBuf;

   630     CleanupClosePushL( resultBuf );

   631     resultBuf.CreateL( aMessage.GetDesMaxLength(0) );

   632     

   633     iServer.MessageStoreL().ListAccountsL( resultBuf );

   634     

   635     aMessage.WriteL( 0, resultBuf );

   636     

   637 	CleanupStack::PopAndDestroy( &resultBuf );

   638 	

   639     aMessage.Complete( KErrNone );

   640 	}

   641 

   642 // ==========================================================================

   643 // FUNCTION: DoGetEventsL

   644 // ==========================================================================

   645 void CMessageStoreSession::DoGetEventsL( const RMessage2& aMessage )

   646 	{

   647 	// If there are any queued events then send them right away, otherwise

   648 	// save the message until events become avaialable.

   649 	if( iEventQueue.Count() > 0 )

   650 		{

   651         TUint desLength = aMessage.GetDesMaxLengthL( 0 );

   652         

   653         TUint position = 0;

   654         

   655         while( iEventQueue.Count() > 0 && position < desLength )

   656             {

   657             TPckg<TMsgStoreEvent> eventPckg( iEventQueue[0] );

   658 			aMessage.WriteL( 0, eventPckg, position );

   659             

   660             position += sizeof( TMsgStoreEvent );

   661             iEventQueue.Remove( 0 );		

   662             } // end while

   663             

   664         aMessage.Complete( KErrNone );

   665 	    }

   666 	else

   667 	    {

   668 	    iObserverMessage = aMessage;

   669 		} // end if	

   670 		

   671 	} // end DoGetEventsL

   672 	

   673 // ==========================================================================

   674 // FUNCTION: SendEventToObserver

   675 // ==========================================================================

   676 void CMessageStoreSession::SendEventToObserver( TMsgStoreEvent aEvent )

   677 	{

   678 	__LOG_ENTER( "SendEventToObserver" )

   679 	

   680 	// If there is no observer message pending then queue up the message,

   681 	// otherwise send it immediately.

   682 	

   683 	if( iObserverMessage.IsNull() )

   684 		{

   685 		if( iEventQueue.Count() > KMsgStoreMaximumEventQueueDepth )

   686 		    {

   687 		    __LOG_WRITE_ERROR( "EVENT QUEUE OVERFLOW" );

   688 		    iEventQueue.Reset();

   689 		    

   690         	TMsgStoreEvent event;

   691         	event.iType        = EObserverEventQueueOverflow;

   692         	event.iId          = KMsgStoreInvalidId;

   693         	event.iParentId    = KMsgStoreInvalidId;

   694         	event.iOtherId     = KMsgStoreInvalidId;

   695         	event.iFlags       = KMsgStoreFlagsNotFound;

   696 

   697     		iEventQueue.Append( event );		

   698 		    }

   699 		else

   700 		    {

   701     		__LOG_WRITE_INFO( "event queued" )

   702     		iEventQueue.Append( aEvent );		

   703 		    } // end if		

   704 		}

   705 	else

   706 		{

   707 		__LOG_WRITE_INFO( "Sending event now" )

   708 		

   709 		TPckg<TMsgStoreEvent> eventPckg( aEvent );

   710 					

   711 		TRAPD( result, iObserverMessage.WriteL( 0, eventPckg ) );			

   712 		

   713 		iObserverMessage.Complete( result );

   714 		} // end if	

   715 		

   716     __LOG_EXIT		

   717 	} // end SendEventToObserver

   718 

   719 // ==========================================================================

   720 // FUNCTION: ContainerModified

   721 // ==========================================================================

   722 void CMessageStoreSession::ContainerModified( 

   723         TOperation aOperation, 

   724         const RArray<TContainerId>& aHierarchy, 

   725         TContainerId aNewParentId, 

   726         const TDesC8& aQuickProperties )

   727 	{

   728 	// If the children IDs array is not empty then a series of EMsgStoreCmdChildrenProperties

   729 	// messages are in progress, and a modified container could affect the data being streamed.

   730 	

   731 	if( iIds.Count() > 0 )

   732 	    {

   733         // The following event types could affect the properties that are being streamed to the client.

   734         // Reset the ID list to indicate that the streaming operation should be restarted.

   735         	

   736 	    if ( ( iUsingQuery ) && ( aHierarchy.Count() > 1 ) ) 

   737 	        {	        

   738 	        // If this is a query based list then the current change only affects the list if the

   739 	        // query was for all types or if the type match.

   740 	        if( (iQueryParams.iType == KContainerTypeAny) || (iQueryParams.iType == (aHierarchy[0] & KContainerTypeMask )) )

   741 	            {	            

   742             	switch( aOperation )

   743             		{

   744             		case EAdd:

   745             		case EMove:

   746              		case EDelete:

   747             		case EUpdateProperties:

   748             

   749                         // The current change only affects the list if the query was recursive or

   750                         // if the modified container has the same parent as used in the query.

   751             		    if( iQueryParams.iRecursive || (iQueryParams.iId == aHierarchy[1]) )

   752             		        {

   753             		        iIds.Reset();

   754             		        } // end if

   755                         break;

   756                             		        

   757             		} // end switch

   758             		

   759 	            } // end if

   760 	        }

   761 	    else

   762 	        {	        

   763    	        // Only deletes and property updates can affect the provided list of IDs.  Adds and

   764 	        // moves do not affect this operation.

   765         	switch( aOperation )

   766         		{

   767          		case EDelete:

   768         		case EUpdateProperties:

   769         		

   770                     iIds.Reset();

   771                     break;

   772                         		        

   773            		} // end switch

   774            		

   775 	        } // end if

   776     		

   777 	    } // end if	    

   778 	

   779 	// If the client session is currently observing then create an observer event.

   780 	

   781 	if( iIsObserving )

   782 	    {	    

   783     	TMsgStoreEvent event;

   784 

   785     	switch( aOperation )

   786     		{

   787     		case EAdd:

   788     		    event.iType = EMsgStoreAdd;

   789     			break;

   790     		case EMove:

   791     		    event.iType = EMsgStoreMove;

   792     			break;

   793     		case EDelete:

   794     			event.iType = EMsgStoreDelete;

   795     			break;

   796     		case EUpdateProperties:

   797     			event.iType = EMsgStoreUpdateProperties;

   798     			break;

   799     		case EUpdateContent:

   800     			event.iType = EMsgStoreUpdateContent;

   801     			break;

   802     		case ERemoveContent:

   803     			event.iType = EMsgStoreRemoveContent;

   804     			break;

   805     		default:

   806     		    // This shouldn't happen.

   807     		    event.iType = 0;

   808     		    break;    		    

   809     		} // end switch

   810     		

   811     	event.iId = aHierarchy[0];

   812     	

   813     	if( aHierarchy.Count() > 1 )

   814     	    {    	    

   815     	    event.iParentId = aHierarchy[1];

   816     	    }

   817     	else

   818     	    {

   819     	    event.iParentId = KContainerInvalidId;

   820     	    } // end if

   821     	        	

   822 	    if( aNewParentId != KContainerInvalidId )

   823 	        {

   824 	        // Use the new parent Id for the "other" id.

   825 	        event.iOtherId = aNewParentId;	        

   826 	        }

   827 	    else if( aHierarchy.Count() > 2 )

   828 	        {

   829 	        // Use the grandparent ID for the "other" ID.

   830 	        event.iOtherId = aHierarchy[2];

   831 	        }

   832 	    else

   833 	        {

   834 	        event.iOtherId = KContainerInvalidId;

   835 	        } // end if

   836 	    

   837 	    //Get the MailBoxId from the buttom of the Hierarchy

   838 	    if ( aHierarchy.Count() > 1 )

   839 	    	{

   840 	    	event.iMailBoxId = aHierarchy[ aHierarchy.Count() - 2 ];

   841 	    	}

   842 	    else

   843 	    	{

   844 	    	//this should not happen

   845 	    	event.iMailBoxId = KContainerInvalidId;

   846 	    	}

   847     	        	

   848         // Find the value of the flags property.

   849 

   850     	event.iFlags = KMsgStoreFlagsNotFound;

   851         if( aQuickProperties.Length() > 0 )

   852             {

   853             TPropertiesDeserializer deserializer( aQuickProperties );

   854             

   855             if( deserializer.Find( KMsgStorePropertyFlags ) && deserializer.Type() == EMsgStoreTypeUint32 )

   856                 {

   857     			TPckgBuf<TUint32> flagsPckg;

   858     			flagsPckg.Copy( deserializer.Value() );

   859 

   860                 event.iFlags = flagsPckg();                    

   861     			} // end if

   862 

   863             } // end if

   864         

   865         //initialize the names which are not used

   866         event.iAccountName.SetLength( 0 );

   867         event.iNewAccountName.SetLength( 0 );

   868 

   869     	SendEventToObserver( event );    	

   870     	

   871 	    } // end if

   872 	    

   873 	} // end ContainerModified

   874 	

   875 // ==========================================================================

   876 // FUNCTION: AuthenticationChanged

   877 // ==========================================================================

   878 void CMessageStoreSession::AuthenticationChanged( TBool aAuthenticated )

   879     {

   880     if( iIsObserving )

   881         {            

   882     	TMsgStoreEvent event;

   883 

   884     	if( aAuthenticated )

   885     	    {

   886     	    event.iType = EMsgStoreAuthenticated;

   887     	    }

   888     	else

   889     	    {

   890     	    event.iType = EMsgStoreNotAuthenticated;

   891     	    } // end if

   892 

   893     	event.iMailBoxId   = KMsgStoreInvalidId;

   894     	event.iId          = KMsgStoreInvalidId;

   895     	event.iParentId    = KMsgStoreInvalidId;

   896     	event.iOtherId     = KMsgStoreInvalidId;

   897     	event.iFlags       = KMsgStoreFlagsNotFound;

   898     	

   899         //initialize the names which are not used

   900         event.iAccountName.SetLength( 0 );

   901         event.iNewAccountName.SetLength( 0 );

   902     	

   903     	SendEventToObserver( event );

   904         } // end if

   905         

   906     } // end AuthenticationChanged

   907 

   908 // ==========================================================================

   909 // FUNCTION: AccountModified

   910 // ==========================================================================

   911 void CMessageStoreSession::AccountModified( TOperation aOperation, TInt32 aOwnerId, const TDesC8& aName, const TDesC8& aNewName, TContainerId aMailboxId )

   912 	{

   913     if( iIsObserving )

   914         {            

   915     	TMsgStoreEvent event;

   916     	

   917     	switch( aOperation )

   918 		{

   919 		case EAdd:

   920 		    event.iType = EMsgStoreAccountCreated;

   921 			break;

   922 		case EDelete:

   923 			event.iType = EMsgStoreAccountDeleted;

   924 			break;

   925 		case ERenameAccount:

   926 			event.iType = EMsgStoreAccountRenamed;

   927 			break;

   928 		default:

   929 		    // This shouldn't happen.

   930 		    event.iType = 0;

   931 		    break;    		    

   932 		} // end switch

   933 

   934     	event.iMailBoxId   = aMailboxId;

   935     	event.iId          = aOwnerId;

   936     	event.iParentId    = KMsgStoreInvalidId;

   937     	event.iOtherId     = KMsgStoreInvalidId;

   938     	event.iFlags       = KMsgStoreFlagsNotFound;

   939     	

   940         //initialize the names which are not used

   941         event.iAccountName.Copy( aName );

   942         event.iNewAccountName.Copy( aNewName );

   943     	

   944     	SendEventToObserver( event );

   945         } // end if

   946 	

   947 	}

   948 

   949 

   950 // --------------------    	

   951 // SEARCH FUNCTIONALITY

   952 // -------------------- 

   953     

   954 // ==========================================================================

   955 // FUNCTION: DoPrepareSearchL

   956 // ==========================================================================

   957 void CMessageStoreSession::DoPrepareSearchL( const RMessage2& aMessage )

   958     {

   959     //param 0 (search cmd param)

   960     TMsgStoreSearchCmdParams params;   

   961     TPckg<TMsgStoreSearchCmdParams> paramsPckg( params );

   962     aMessage.ReadL( 0, paramsPckg );

   963 

   964     //param 1 (search string)

   965     ReadString16ArrayL( aMessage, 1, iSearchStrings );

   966     

   967     //param 2 (folder IDs)

   968     ReadIdArrayL( aMessage, 2, iIds );

   969 

   970     //param 3 (property keys)

   971     // Deserialize the property names list.

   972     ReadString8ArrayL( aMessage, KValThree, iPropertyNames );

   973     

   974 	iMatchMessages.ResetAndDestroy();

   975     

   976     if ( iSearchHandler )

   977         {

   978         if ( iSearchHandler->IsSameSearchCriteriaL( iSearchStrings ) )

   979             {

   980             iSearchHandler->RestartL( params, iIds, iPropertyNames );

   981             }

   982         else

   983             {

   984             delete iSearchHandler;

   985             iSearchHandler = NULL;

   986             }

   987         }

   988     

   989     if ( !iSearchHandler )

   990         {

   991         // Create an asynchronous search handler and start it.

   992         iSearchHandler = iServer.MessageStoreL().SearchL( EMsgStoreMessageBits, params, iSearchStrings, iIds, iPropertyNames, *this );        

   993     	iSearchHandler->StartL();

   994         }

   995 	

   996     aMessage.Complete( KErrNone );

   997     } // end DoPrepareSearchL

   998     

   999 // ==========================================================================

  1000 // FUNCTION: DoGetMatchesL

  1001 // ==========================================================================

  1002 void CMessageStoreSession::DoGetMatches( const RMessage2& aMessage )

  1003     {

  1004     // TIpcArgs( &aMatchBuffer )

  1005     

  1006     iGetMatchesMessage = aMessage;

  1007     

  1008     // Always send the search results if the search has completed, even if there are not results found.

  1009     // The end of the search is indicated by a null search handler pointer.

  1010     TBool searchInProgress = EFalse;

  1011     if ( iSearchHandler )

  1012         {

  1013         searchInProgress = iSearchHandler->IsSearchInProgress();

  1014         }

  1015     

  1016     SendMatchesToClient( !searchInProgress );        

  1017     }

  1018     

  1019 // ==========================================================================

  1020 // FUNCTION: DoCancelSearch

  1021 // ==========================================================================

  1022 void CMessageStoreSession::DoCancelSearch( const RMessage2& aMessage )

  1023     {

  1024     iMatchMessages.ResetAndDestroy();

  1025     

  1026     if( iSearchHandler )

  1027         {     

  1028         //do not delete the search handler

  1029         iSearchHandler->CancelSearch();

  1030         } // end if

  1031         

  1032     if( !iGetMatchesMessage.IsNull() )

  1033         {

  1034         iGetMatchesMessage.Complete( KErrCancel );

  1035         } // end if

  1036     

  1037     iMatchMessages.ResetAndDestroy();

  1038     	

  1039 	aMessage.Complete( KErrNone );

  1040     } // end DoCancelSearch

  1041 

  1042 // ==========================================================================

  1043 // FUNCTION: DoClearSearchResultCache

  1044 // ==========================================================================

  1045 void CMessageStoreSession::DoClearSearchResultCache( const RMessage2& aMessage )

  1046     {

  1047     delete iSearchHandler;

  1048     iSearchHandler = NULL;

  1049     

  1050     aMessage.Complete( KErrNone );

  1051     }

  1052 

  1053 // ==========================================================================

  1054 // FUNCTION: MatchFound

  1055 // ==========================================================================

  1056 void CMessageStoreSession::MatchFound( TContainerId aMessageId, TContainerId aFolderId, const TDesC8& aPropertyBuf )

  1057     {

  1058     TRAP_IGNORE( DoMatchFoundL( aMessageId, aFolderId, aPropertyBuf ) );

  1059     } // end MatchFound

  1060 

  1061 // ==========================================================================

  1062 // FUNCTION: DoMatchFoundL

  1063 // ==========================================================================

  1064 void CMessageStoreSession::DoMatchFoundL( TContainerId aMessageId, TContainerId aFolderId, const TDesC8& aPropertyBuf )

  1065     {

  1066     CSearchResult* result = CSearchResult::NewL( aMessageId, aFolderId, aPropertyBuf );

  1067     iMatchMessages.Append( result );

  1068 

  1069     SendMatchesToClient();

  1070     } // end MatchFound

  1071 

  1072 // ==========================================================================

  1073 // FUNCTION: SearchComplete

  1074 // ==========================================================================

  1075 void CMessageStoreSession::SearchComplete( TInt /*aStatus*/ )

  1076     {

  1077     //do not delete the search handler

  1078     

  1079     // Always send the search results if the search has completed, even if there are not results found.

  1080     SendMatchesToClient( ETrue );

  1081     } // end SearchComplete

  1082     

  1083 // ==========================================================================

  1084 // FUNCTION: SendMatchesToClientL

  1085 // ==========================================================================

  1086 void CMessageStoreSession::SendMatchesToClient( TBool aAlwaysSend )

  1087     {

  1088     // If there is a pending GetMatches message and either aAlwaysSend is true or matches were found

  1089     // then build a nuffer of matching IDs and send to the client.

  1090     

  1091     if( !iGetMatchesMessage.IsNull() && (aAlwaysSend || iMatchMessages.Count() > 0 ) )

  1092         {

  1093         TRAPD( result, DoWriteMatchesToMessageL() );

  1094         iGetMatchesMessage.Complete( result );

  1095         } // end if

  1096 

  1097     } // end SendMatchesToClient

  1098   

  1099   

  1100 // ==========================================================================

  1101 // FUNCTION: DoWriteMatchesToMessageL

  1102 // ==========================================================================

  1103 void CMessageStoreSession::DoWriteMatchesToMessageL()

  1104     {

  1105     __LOG_ENTER_SUPPRESS( "DoWriteMatchesToMessageL" )

  1106     

  1107     TUint desLength = iGetMatchesMessage.GetDesMaxLengthL( 0 );        

  1108     TUint offset = 0;

  1109     

  1110     TUint fixedLength = sizeof(TContainerId)*2 + sizeof(TUint);  //fixed size: 2 ids and a length

  1111     

  1112     TInt msgWritten = 0;

  1113     

  1114     while( iMatchMessages.Count() > 0 && offset < desLength )

  1115         {

  1116         CSearchResult* result = iMatchMessages[0];

  1117         TUint length = result->PropertyBuf().Length();

  1118 	    TPckgBuf<TUint> lengthPkg( length );

  1119         

  1120         if ( desLength - offset >= fixedLength + length )

  1121             {

  1122             //write the message id

  1123             TPckgBuf<TContainerId> idPkg( result->MessageId() );

  1124             iGetMatchesMessage.WriteL( 0, idPkg, offset );

  1125             offset += sizeof( TContainerId );

  1126             

  1127             //write the folder id

  1128             TPckgBuf<TContainerId> folderIddPkg( result->FolderId() );

  1129             iGetMatchesMessage.WriteL( 0, folderIddPkg, offset );

  1130             offset += sizeof( TContainerId );

  1131 

  1132             //write the length

  1133             iGetMatchesMessage.WriteL( 0, lengthPkg, offset );

  1134             offset += sizeof( TUint );