/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Handler class for incoming and outgoing messages
*
*/
#ifndef __CCAMESSAGEHANDLER_H__
#define __CCAMESSAGEHANDLER_H__
#include "ImpsImCli.h" // MImpsImHandler2
#include "MCAMessageObserver.h"
#include "MCAMessageErrorInformer.h"
#include "MCAContentProcessObserver.h"
#include "MCAMessageCreator.h" // For SMessageData
// FORWARD CLASS DECLERATIONS
class MCAChatInterface;
class MCAMessageUtils;
class MCAMessagesReadInterface;
class MCAImpsFactory;
class MCAImpsImClient;
// CLASS DECLARATION
/**
* Handler class for incoming and outgoing messages
*
* @lib CAEngine.dll
* @since 3.0
*/
class CCAMessageHandler : public CBase,
public MImpsImHandler2,
public MCAMessageObserver,
public MCAMessageErrorInformer,
public MCAContentProcessObserver
{
public: // Construction
/**
* Construction
* @param aChatInterface Access to message read and write interfaces
* @param aMessageUtils Access to message utils ( Message creator,
* processors )
* @param aImpsFactory Factory for IMPS interface wrappers
* @return Pointer to new created instance of CCAMessageCreator
*/
static CCAMessageHandler* NewL( MCAChatInterface& aChatInterface,
MCAMessageUtils& aMessageUtils,
MCAImpsFactory* aIMPSFactory );
/**
* Construction
* @see CCAMessageHandler::NewL
*/
static CCAMessageHandler* NewLC( MCAChatInterface& aChatInterface,
MCAMessageUtils& aMessageUtils,
MCAImpsFactory* aIMPSFactory );
/**
* Destruction
*/
~CCAMessageHandler();
private: // Construction
/**
* Constructor
* @see CCAMessageHandler::NewL
*/
CCAMessageHandler( MCAChatInterface& aChatInterface,
MCAMessageUtils& aMessageUtils,
MCAImpsFactory* aIMPSFactory );
/**
* Constructor
*/
void ConstructL();
private: // From MImpsImHandler
/**
* @see MImpsImHandler2
*/
void HandleNewTextMessageL( TInt aOpId,
const TDesC& aMessageId,
const TDesC& aSender,
const TDesC& aGroupId,
const MDesCArray& aRecipients,
const MDesCArray& aScreenNames,
const TDesC& aText,
TImpsCspIdentifier& aCspId );
/**
* @see MImpsImHandler2
*/
void HandleNewContentMessageL( TInt aOpId,
const TDesC& aMessageId,
const TDesC& aSender,
const TDesC& aGroupId,
const MDesCArray& aRecipients,
const MDesCArray& aScreenNames,
const TDesC& aContentType,
const TDesC8& aContent,
TImpsCspIdentifier& aCspId );
/**
* @see MImpsImHandler2
*/
void HandleSendCompleteL( TInt aOpId,
TBool aDeliveryReportOrdered,
TImpsCspIdentifier& aCspId );
/**
* @see MImpsImHandler2
*/
void HandleDeliveryReportL( const TDesC& aMessageId,
TInt aResult,
const TDesC* aDescription,
TImpsCspIdentifier& aCspId );
private: // From MCAMessageObserver
/**
* @see MCAMessageObserver
*/
void HandleMessageEvent( TMessageEventType aEvent, TInt aIndex );
private: // From MCAMessageErrorInformer
/**
* @see MCAMessageErrorInformer
*/
void RegisterObserver( MCAMessageErrorObserver* aObserver );
/**
* @see MCAMessageErrorInformer
*/
void UnregisterObserver( MCAMessageErrorObserver* aObserver );
private: // From MCAContentProcessObserver
/**
* @see MCAContentProcessObserver
*/
void HandleProcessingComplete( MCAContentProcessor& aProcessor,
MCAMessage& aMessage,
TInt aStatus );
public: // New methods
/**
* Handle sent message.
* @param aStatus, Status of operation
* @param aOperationCode. Operation code to identify message.
* @param aSuccess ETrue, if message sent ok. EFalse if not.
*/
void HandleMessageSentL( TInt aStatus, TInt aOperationCode,
TBool aSuccess );
/**
* Set state of local echo in group.
*/
void SetLocalEchoInGroup( TBool aLocalEchoInGroup );
private: // New helper methods
/**
* Callback method for CIdle
* @param aInstance Instance of CCAMessageHandler
* @return ETrue, if more messages, EFalse if last one.
*/
static TInt SendMessage( TAny *aInstance );
/**
* Send one message
* @return ETrue, if more messages, EFalse if last one.
*/
TInt DoSendMessage();
/**
* Handle new message.
* @param aData. Data of message.
*/
void HandleNewMessageL( MCAMessageCreator::SMessageData& aData );
/**
* Notify observers about
* @param aStatus, Error code
* @param aMessage, Message that failed.
*/
void NotifyMessageError( TInt aStatus, MCAMessage* aMessage );
/**
* Get next holding message if exists.
* @return Next holding message if exists. NULL if not.
*/
MCAMessage* NextHoldingMessage();
/**
* Is holding needed for message. If it is, appended to holding.
* @param aMessage. Checked message
* @return ETrue, if appended to holding EFalse if not.
*/
TBool AppendedToHoldingL( MCAMessage& aMessage );
/**
* Send message to server
* @param aMessage. Message to sent.
* @return Operation code.
*/
TInt SendMessageToServerL( MCAMessage& aMessage );
/**
* Handle message sent failed. Create failed message and notify user.
* @param aMessage. Failed message
* @param aError, Error code for fail.
*/
void HandleMessageSentFailedL( MCAMessage& aMessage, TInt aError );
/**
* Show message to user who sent it.
* @param aMessage. Sent message to echo.
*/
void LocalEchoMessageL( MCAMessage& aMessage );
private: // Member data
/// does not own. This is used for example to get message creator
MCAMessageUtils& iMessageUtils;
/// Does not own. Access to message containers
MCAChatInterface& iChatInterface;
/// Does not own. Access to messages in send buffer
MCAMessagesReadInterface* iSendBuffer;
// not owned
MCAImpsFactory* iImpsFactory;
// not owned
MCAImpsImClient* iImpsImClient;
/// Idle for message sending purposes. Owns.
CIdle* iIdle;
/// Message error observers
RPointerArray< MCAMessageErrorObserver > iErrorObservers;
/// Messages which are processed before sending.
RPointerArray< MCAMessage > iHoldingMessages;
/// Is local echo in groups used.
TBool iLocalEchoInGroup;
/// If send is active, do not start it again.
TBool iSendLaunchLock;
};
#endif // CCAMESSAGEHANDLER_H
// End of File