/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Interface to messaging provider

*

*/

#include <e32base.h>

#include <msvstd.h>

#include <msvapi.h>

#include <msvids.h>

#include <SendUiConsts.h>

#include "messageheader.h"

#include "messagingservice.h"

#include "messagenotify.h"

#include "sendmessage.h"

#include "accessfolder.h"

#include "messagedetail.h"

#include "changestatus.h"

#ifdef __WINSCW__ 

	#define KFolderId KMsvDraftEntryId;

#else

	#define KFolderId KMsvGlobalInBoxIndexEntryId;

#endif

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

EXPORT_C CMessagingService* CMessagingService::NewL()

	{

	CMessagingService* self = new (ELeave) CMessagingService;

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

// ---------------------------------------------------------------------------

// Destructor.

// ---------------------------------------------------------------------------

//

CMessagingService::~CMessagingService()

	{

	DeleteAsyncObjects();//deletes all Asychronous objects

	iAsyncObjArray.Reset();

	delete iMsgServerSession;

	delete iSessionObserver;			

	}

// ---------------------------------------------------------------------------

// Constructor.

// ---------------------------------------------------------------------------

//

CMessagingService::CMessagingService()

	{

	}

// ---------------------------------------------------------------------------

// Constructor.

// ---------------------------------------------------------------------------

//

void CMessagingService::ConstructL()

	{

	iSessionObserver = CMessageObserver::NewL();

	iMsgServerSession = CMsvSession::OpenSyncL( *iSessionObserver );

	((CMessageObserver*)iSessionObserver)->SetSession( iMsgServerSession );

	}

// ---------------------------------------------------------------------------

// Sends Message 

// ---------------------------------------------------------------------------

//

EXPORT_C void CMessagingService::SendMessageL( CSendMessageParams* aMessageParam, 

												CMsgCallbackBase* aCallback )

	{

	CMessageDetailInfo* 	templateDetail = NULL;

	if ( aMessageParam->TemplateId() > 0 )

		{

		CMessageDetail* detailObj = NULL;

		CMsvEntry * messageEntry = iMsgServerSession->GetEntryL( aMessageParam->TemplateId() );

	    CleanupStack::PushL(messageEntry);

	    if ( aMessageParam->MessageType() == KSenduiMtmSmsUid && 

	            messageEntry->Entry().iMtm == KSenduiMtmMmsUid )

            {

            User::Leave( KErrNotSupported );

            }

	    CleanupStack::PopAndDestroy(messageEntry);

		detailObj = CMessageDetail::NewL( *iMsgServerSession );

		CleanupStack::PushL( detailObj );

		detailObj->GetMessageDetailL( aMessageParam->TemplateId(), templateDetail );

		CleanupStack::PopAndDestroy( detailObj );

		}

	else if ( aMessageParam->TemplateId() < 0 )

		{

		User::Leave( KErrNotSupported );

		}

	CSendMessage* sendMessageObj = CSendMessage::NewL( *iMsgServerSession );

	CleanupStack::PushL( sendMessageObj );

	// aCallback, templateDetail ownership passes to CSendMessage

	sendMessageObj->SetInputParamsL( aMessageParam, templateDetail, aCallback, this );

	if ( aCallback )

		{

		AddAsyncObjL( aCallback->iTransactionId, sendMessageObj );

		}

	sendMessageObj->SendMessageL();

	CleanupStack::Pop( sendMessageObj );

	if ( !aCallback )

		delete sendMessageObj;

	}

// ---------------------------------------------------------------------------

// Deletes Message 

// ---------------------------------------------------------------------------

//

EXPORT_C void CMessagingService::DeleteMessageL( const TMsvId aMessageId,

					                       			CMsgCallbackBase* /*aCallback*/ )

	{

	CMessageChangeStatus* obj = NULL;

	obj = CMessageChangeStatus::NewL( *iMsgServerSession );

	CleanupStack::PushL( obj );

	obj->DeleteMessageL( aMessageId );

	CleanupStack::PopAndDestroy( obj );

	}

// ---------------------------------------------------------------------------

// Chages status of message entry

// ---------------------------------------------------------------------------

//

EXPORT_C void CMessagingService::ChangeStatusL( const TMsvId aMessageId,

												const TMessageStatusFlag aStatusFlag,

												const TBool  aFlagValue,

					                			CMsgCallbackBase* /*aCallback*/ )

	{

	CMessageChangeStatus* obj = CMessageChangeStatus::NewL( *iMsgServerSession );

	CleanupStack::PushL( obj );

	obj->ChangeStatusL( aMessageId, aStatusFlag, aFlagValue );

	CleanupStack::PopAndDestroy( obj );

	}

// ---------------------------------------------------------------------------

// Gives notification for new messages

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CMessagingService::RequestNotification( const TNotificationType /*aNotification*/,

														CMsgCallbackBase* aCallback )

	{

	// Only one object can get the new message notification

	if( ( (CMessageObserver*)iSessionObserver )->IsActive() )

		return KErrAlreadyExists;

	CMsgCallbackBase* oldCallback = iSessionObserver->SetCallback( aCallback );

	delete oldCallback;

	return KErrNone;	

	}

// ---------------------------------------------------------------------------

// Cancels notification

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CMessagingService::CancelNotification( const TNotificationType /*aNotification*/, 

														CMsgCallbackBase* /*aCallback*/ )

	{

	CMsgCallbackBase* oldCallback = iSessionObserver->SetCallback( NULL );

	delete oldCallback;

	return KErrNone;	

	}

// ---------------------------------------------------------------------------

// Gives a sorted list of message Ids 

// ---------------------------------------------------------------------------

//

EXPORT_C void CMessagingService::GetIdListL( CFilterParamInfo* aFilterParams,

											TMsvId /*aFolderId*/,

									        CMsgCallbackBase* 	aCallback,

									        CMsvEntrySelection*& aEntrySelection )

	{

	// Hard coding for Inbox/Draft

	// Folder Id can be passed as input parameter, to support access any folder

	TMsvId 	folderId = KFolderId;

	CMessagingAccessFolder* obj = CMessagingAccessFolder::NewL( *iMsgServerSession );

	CleanupStack::PushL( obj );

	obj->SetInputParamsL(aCallback,this);

	if ( aCallback )

	{

	AddAsyncObjL( aCallback->iTransactionId,obj);

	}

	obj->GetIdListL( folderId, aFilterParams, aEntrySelection );

	CleanupStack::Pop( obj );

	if ( !aCallback )

	    delete obj;

	}

EXPORT_C void CMessagingService::GetNextHeaderL( CFilterParamInfo* aFilterParams,

													CMsvEntrySelection* aEntrySelection,

													TInt& aIndex, 

									        		CMsgCallbackBase* 	/*aCallback*/,

									        		CMessageHeader*& aHeader )

	{

	CMessagingAccessFolder* obj = CMessagingAccessFolder::NewL( *iMsgServerSession );

	CleanupStack::PushL( obj );

	obj->GetNextHeaderL( aFilterParams, aEntrySelection, aIndex, aHeader );

	CleanupStack::PopAndDestroy( obj );

	}

// ---------------------------------------------------------------------------

// Gives details of the message 

// ---------------------------------------------------------------------------

//

EXPORT_C void CMessagingService::GetMessageDetailL( const TMsvId aMessageId, 

													CMsgCallbackBase* /*aCallback*/, 

													CMessageDetailInfo*& aResult )

	{

	CMessageDetail* obj = CMessageDetail::NewL( *iMsgServerSession );

	CleanupStack::PushL( obj );

	obj->GetMessageDetailL( aMessageId, aResult );

	CleanupStack::PopAndDestroy( obj );

	}

// ---------------------------------------------------------------------------

// Adds asynchronous request object

// ---------------------------------------------------------------------------

//

void CMessagingService::AddAsyncObjL( const TInt32 aTransactionId, CActive* aAsyncObj )

	{

	TAsyncRequestInfo asyncRequestInfo;

	asyncRequestInfo.iTransactionId = aTransactionId;

	asyncRequestInfo.iAsyncObj = aAsyncObj;

	User::LeaveIfError( iAsyncObjArray.Append( asyncRequestInfo ) );

	}

// ---------------------------------------------------------------------------

// Deletes all the asynchronous request objects

// ---------------------------------------------------------------------------

//

void CMessagingService::DeleteAsyncObjects()

	{

	TInt pos = iAsyncObjArray.Count() - 1;

	TAsyncRequestInfo obj;

	for ( ; pos >= 0; pos-- )

		{

		obj = iAsyncObjArray[pos];

		(obj.iAsyncObj)->Cancel();

		delete obj.iAsyncObj;

		}

	}

// ---------------------------------------------------------------------------

// Cancels asynchronous request

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CMessagingService::Cancel( const TInt32 aTransactionId )

	{

	TInt pos = iAsyncObjArray.Count() - 1;

	TAsyncRequestInfo obj;

	for ( ; pos >= 0; pos-- )

		{

		obj = iAsyncObjArray[pos];

		if( obj.iTransactionId == aTransactionId )

			{

			obj.iAsyncObj->Cancel();

			delete obj.iAsyncObj;

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

// ---------------------------------------------------------------------------

// Notifies Messaging service about the completeion of the request

// ---------------------------------------------------------------------------

//

void CMessagingService::RequestComplete( const TInt32 aTransactionId )

	{

	TInt pos = iAsyncObjArray.Count() - 1;

	TAsyncRequestInfo obj;

	for ( ; pos >= 0; pos-- )

		{

		obj = iAsyncObjArray[pos];

		if( obj.iTransactionId == aTransactionId )

			{

			iAsyncObjArray.Remove(pos);

			iAsyncObjArray.Compress();

			return;

			}

		}

	}