{
	MoveToFolderL((*iIdArray)[aIndex], aFolder);
}

void CMtmsEngine::MoveToFolderL( TMsvId aMessageId,  TMsvId aFolder )
{
	iSmsMtm->SwitchCurrentEntryL( aMessageId );
	TMsvSelectionOrdering selection;
	selection.SetShowInvisibleEntries(ETrue);
	CMsvEntry* parentEntry = CMsvEntry::NewL( iSmsMtm->Session(), 
		iSmsMtm->Entry().Entry().Parent(), selection );
	CleanupStack::PushL(parentEntry);
	// Move the message
	parentEntry->MoveL( aMessageId, aFolder );
	CleanupStack::PopAndDestroy(); // parentEntry
}

// ----------------------------------------------------------------------------
// CMtmsEngine::DeleteMessageL( TMsvId aMessageId )
//
// Delete message from a folder. Notice that the iSmsMtm points to the parent, 
// not to the message itself.
// ----------------------------------------------------------------------------
void CMtmsEngine::DeleteMessageL(TInt nCurrent)
{
	DeleteMessageL((*iIdArray)[nCurrent]);
	iIdArray->Remove(nCurrent);
}

void CMtmsEngine::DeleteMessageL( TMsvId aMessageId )
{
	iSmsMtm->SwitchCurrentEntryL( aMessageId );
	TMsvId parent = iSmsMtm->Entry().Entry().Parent();
	
	iSmsMtm->SwitchCurrentEntryL( parent );
	iSmsMtm->Entry().DeleteL( aMessageId );
}

void CMtmsEngine::GetMessageInfo(TInt aIndex, TDes& aDate)
{
	iSmsMtm->SwitchCurrentEntryL( (*iIdArray)[aIndex] );
	TTime tmTmp = iSmsMtm->Entry().Entry().iDate;
	
	TBuf<32> sTmp;
	sTmp.Format(_L("%04d-%02d-%02d\r\n"), tmTmp.DateTime().Year(), tmTmp.DateTime().Month(), tmTmp.DateTime().Day());
	aDate.Append(sTmp);
	sTmp.Format(_L("%02d:%02d:%02d\r\n"), tmTmp.DateTime().Hour(), tmTmp.DateTime().Minute(), tmTmp.DateTime().Second());
	aDate.Append(sTmp);
}
// ----------------------------------------------------------------------------
// CMtmsEngine::GetMessageAddressL( TMsvId aMessageId, 
//										      TDes& aAddress )
//
// Get originator address from SmsHeader.
// ----------------------------------------------------------------------------
void CMtmsEngine::GetMessageAddressL( TMsvId aMessageId, TDes& aAddress )
{
	iSmsMtm->SwitchCurrentEntryL( aMessageId );	
	
	// Remember to load before using the SmsHeader
	iSmsMtm->LoadMessageL();
	
	CSmsHeader&	header = iSmsMtm->SmsHeader();
	
	// 	aAddress.Append( header.FromAddress() );
	// Other possibility is this: (It's little bit faster than the previous one).
	aAddress.Append( iSmsMtm->Entry().Entry().iDetails );
}

// ----------------------------------------------------------------------------
// CMtmsEngine::GetMessageL( TMsvId aMessageId, TDes& aMessage)
//
// Get message body from entry storage (CMsvStore). CMsvStore stores whole
// message, not summary information ( see GetMessageIndexBodyTextL() ).
// ----------------------------------------------------------------------------
TBool CMtmsEngine::GetMessageL( TMsvId aMessageId, TDes& aMessage)
{
	iSmsMtm->SwitchCurrentEntryL( aMessageId );
	
	if ( iSmsMtm->Entry().HasStoreL() ) 
	{
		// SMS message is stored inside Messaging store.
		CMsvStore* store = iSmsMtm->Entry().ReadStoreL();
		CleanupStack::PushL(store);
		
		if (store->HasBodyTextL())
		{
			CRichText* richText = CRichText::NewL(
				CEikonEnv::Static()->SystemParaFormatLayerL(),
				CEikonEnv::Static()->SystemCharFormatLayerL());
			richText->Reset();
			CleanupStack::PushL(richText);
			
			// Get the SMS body text.
			store->RestoreBodyTextL(*richText);
			const TInt length = richText->DocumentLength();
			TBuf<KMessageBodySize> message;
			
			// Check length because message is read to limited size TBuf.
			if ( length >= KMessageBodySize ) 
			{
				message.Append( richText->Read(0, KMessageBodySize -1) );
			}
			else 
			{
				message.Append( richText->Read(0, length) );
			}
			
			aMessage.Append( message );
			
			CleanupStack::PopAndDestroy(richText);
		}
		CleanupStack::PopAndDestroy(store);
	}
	else
	{
		return EFalse;
	}
	
	return ETrue;
}

// ----------------------------------------------------------------------------
// CMtmsEngine::GetMessageIndexBodyTextL( TMsvId aMessageId, TDes& aMessage)
//
// Get beginning of message's body. Index entry is just a summary of the whole
// message.
// ----------------------------------------------------------------------------
TBool CMtmsEngine::GetMessageIndexBodyTextL( TMsvId aMessageId, TDes& aMessage)
{
	iSmsMtm->SwitchCurrentEntryL( aMessageId );
	aMessage.Append(iSmsMtm->Entry().Entry().iDescription );
	return ETrue;
}


// ----------------------------------------------------------------------------
// CMtmsEngine::CopyMessageL( TMsvId aMessageId, TMsvId aFolder )
//
// Copy message to another folder. 
// ----------------------------------------------------------------------------
void CMtmsEngine::CopyMessageL( TMsvId aMessageId, TMsvId aFolder )
{
	iSmsMtm->SwitchCurrentEntryL( aMessageId );
	TMsvSelectionOrdering selection;
	selection.SetShowInvisibleEntries(ETrue);
	CMsvEntry* parentEntry = CMsvEntry::NewL( iSmsMtm->Session(), 
		iSmsMtm->Entry().Entry().Parent(), selection );
	CleanupStack::PushL(parentEntry);
	// iSmsMtm points to the parent
	parentEntry->CopyL( aMessageId, aFolder );
	CleanupStack::PopAndDestroy(); // parentEntry
}

// ----------------------------------------------------------------------------
// CMtmsEngine::GetMessageIds()
//
// ids of messages that has been got using ListMessagesL
// ----------------------------------------------------------------------------
RArray<TMsvId>* CMtmsEngine::GetMessageIds()
{
	return iIdArray;
}

// ----------------------------------------------------------------------------
// CMtmsEngine::GetFolderSMSMessageInformation( TMsvId aFolderID, 
//														   CDesCArrayFlat* aAddresses, 
//														   CDesCArrayFlat* aMessages )
//
// Get all folder's children which are SMS messages.
// Note that the folder can contain .sis files which have to be filtered out.
// IdArray is made here because it makes finding the SMS easier later on.
// ----------------------------------------------------------------------------
void CMtmsEngine::GetFolderSMSMessageInformation(TMsvId aFolderID, CDesCArrayFlat*& aIsRead, CDesCArrayFlat*& aMobile, CDesCArrayFlat*& aMessage)
{
	iSmsMtm->SwitchCurrentEntryL( aFolderID );
	CMsvEntry& entry = iSmsMtm->Entry();
	
	// Remember to delete this entry after no longer needed!
	// Only intrested in messages. Filter out service etries.
	CMsvEntrySelection* entries = entry.ChildrenWithMtmL(KUidMsgTypeSMS);
	
	TBuf<2> sTmp;
	//	CDesCArrayFlat* arrayRead = new (ELeave) CDesCArrayFlat(10);
	//	CDesCArrayFlat* arrayAddr = new (ELeave) CDesCArrayFlat(10);
	//	CDesCArrayFlat* arrayMsgBody = new (ELeave) CDesCArrayFlat(10);
	
	if(iIdArray)
	{
		iIdArray->Reset();
		delete iIdArray;
	}
	iIdArray = new (ELeave) RArray<TMsvId>;
	
	for (TInt i = entries->Count()-1; i >= 0; i-- ) 
	{
		//		TBuf<KMessageBodySize> body;
		//		TBuf<KMessageAddressLength> address;
		
		iIdArray->Append((*entries)[i]);
		//of READ FLAG
		iSmsMtm->SwitchCurrentEntryL( (*entries)[i] );
		sTmp.Format(_L("%d"), !iSmsMtm->Entry().Entry().Unread());
		aIsRead->AppendL(sTmp);
		//of message.
		iSmsMtm->SwitchCurrentEntryL( (*entries)[i] );
		aMessage->AppendL(iSmsMtm->Entry().Entry().iDescription);
		//of mobile
		iSmsMtm->SwitchCurrentEntryL( (*entries)[i] );	
		iSmsMtm->LoadMessageL();
		CSmsHeader&	header = iSmsMtm->SmsHeader();
		//aMobile->AppendL(header.FromAddress());
		aMobile->AppendL(iSmsMtm->Entry().Entry().iDetails);
	}
	
	// Delete entries. This is your responsibility.
	entries->Reset();
	delete entries;
	entries = 0;
	
	
}
// ----------------------------------------------------------------------------
// CMtmsEngine::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* 
//	/*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)
//
// Tells when the session has been opened
// ----------------------------------------------------------------------------
void CMtmsEngine::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)
{
    switch (aEvent)
	{
        // This event tells us that the session has been opened
	case EMsvServerReady:
		CreateMtmClientL();
		break;
	default:
		// do nothing
		break;
	}
}


void CMtmsEngine::SaveMessageInfoL()
{
    
    iSmsMtm->SwitchCurrentEntryL(iSmsId);
	
    // Load the created message
    iSmsMtm->LoadMessageL();
	
    // Gets the current SMS service settings
    CSmsSettings& serviceSettings = iSmsMtm->ServiceSettings();
	
	// Gets the number of service centre addresses stored in this object.
    const TInt numSCAddresses = serviceSettings.NumSCAddresses();
    
	// There should always be a service center number
	if (numSCAddresses > 0)
	{
        CSmsNumber*	serviceCentreNumber = NULL;
		
        // get the service center number
        if ((serviceSettings.DefaultSC() >= 0)  &&  (serviceSettings.DefaultSC() < numSCAddresses))
            serviceCentreNumber = &(serviceSettings.SCAddress(serviceSettings.DefaultSC()));
        else
            serviceCentreNumber = &(serviceSettings.SCAddress(0));
		
        iSmsMtm->SmsHeader().SetServiceCenterAddressL(serviceCentreNumber->Address());
	}
	else 
	{
		// Leave if there is no service center number
		User::Leave(0);
	}
	
    iSmsMtm->SaveMessageL();
	
    // Index entry must be Updated
    TMsvEntry indexEntry = iSmsMtm->Entry().Entry();
	// Set in-preparation flag
    indexEntry.SetInPreparation(EFalse);
	// Sets the sending state
    indexEntry.SetSendingState(KMsvSendStateWaiting);
    iSmsMtm->Entry().ChangeL(indexEntry);
	
    // Time to send the message
    Cancel(); // prepare iMsvOper for use
	iEntrySelection->Reset();
	iEntrySelection->AppendL(iSmsId);
}