/*
* Copyright (c) 2002-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 im client.
*
*/
// INCLUDE FILES
#include <e32std.h>
#include <imcvcodc.h>
#include "impsimcli.h"
#include "impsimhandler.h"
#include "impsfields.h"
#include "impsservercommon.h"
#include "impserrors.h"
#include "impsutils.h"
#include "impsdataaccessor.h"
#include "impscdatautils.h"
#include "impsliterals.h"
// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif
// ================= MEMBER FUNCTIONS =======================
// ----------------------------------------------------------------------------
// CImpsImHandler2::CImpsImHandler2
// ----------------------------------------------------------------------------
CImpsImHandler2::CImpsImHandler2(
TInt aPriority,
RImpsImClient2& aClient ) :
// The base class adds this to the scheduler
CImpsHandler2( aPriority, aClient )
{
}
// ----------------------------------------------------------------------------
// CImpsImHandler2::NewL
// ----------------------------------------------------------------------------
CImpsImHandler2* CImpsImHandler2::NewL(
RImpsImClient2& aClient,
TInt aPriority )
{
// Perform the construction.
CImpsImHandler2* self = new (ELeave)
CImpsImHandler2( aPriority, aClient);
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// CImpsImHandler2::~CImpsImHandler2()
// ----------------------------------------------------------------------------
CImpsImHandler2::~CImpsImHandler2()
{
}
// ----------------------------------------------------------------------------
// CImpsImHandler2::ConstructL
// ----------------------------------------------------------------------------
void CImpsImHandler2::ConstructL()
{
CImpsHandler2::ConstructL();
}
// ----------------------------------------------------------------------------
// CImpsImHandler2::HandleEventL()
// ----------------------------------------------------------------------------
void CImpsImHandler2::HandleEventL( CImpsFields* aErrorFields )
{
// get the event data from server thread.
SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2::HandleEventL opid=%d cli=%d"),
event->iOpCode, (TInt)&iClient );
#endif
if ( event->iStatus != ( Imps_ERROR_BASE - 200 ) &&
event->iStatus != KErrNone )
{
HandleErrorEventL( event->iOpCode, event->iStatus, aErrorFields );
}
// Call regular observer
// iStatus is error code or message size
else if ( iStatus >= 0 )
{
HandleImEventL( );
}
}
// ----------------------------------------------------------------------------
// CImpsImHandler2::HandleImEventL()
// ----------------------------------------------------------------------------
void CImpsImHandler2::HandleImEventL( )
{
SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();
RImpsImClient2& client = (RImpsImClient2&)iClient;
MImpsImHandler2* imhandler = client.Handler();
MImpsBlockingHandler2* blockhandler = client.BlockHandler();
TInt err( KErrNone );
// Check incoming message type
TInt myType = event->iMessageType;
CImpsDataAccessor* myAccess = CImpsDataAccessor::NewLC( iFields ); // <<
CImpsKey* myKey = CImpsKey::NewLC(); // <<< myKey
switch ( myType )
{
case EImpsNewMessage:
{
if ( !imhandler )
{
break;
}
// get messageID
TPtrC msgId = TPtrC( KNullDesC );
(void)TImpsCDataUtils::GetNewMessageIdL(
myKey, myAccess, msgId );
myKey->Reset();
// arrays
// notice: optimize creation of arrays
CPtrC16Array* users = new ( ELeave )CPtrC16Array( 4 );
CleanupStack::PushL( users ); // <<< users
CPtrC16Array* sns = new ( ELeave )CPtrC16Array( 4 );
CleanupStack::PushL( sns ); // <<< sns
CPtrC16Array* grs = new ( ELeave )CPtrC16Array( 4 );
CleanupStack::PushL( grs ); // <<< grs
CPtrC16Array* sng = new (ELeave) CPtrC16Array(5);
CleanupStack::PushL( sng ); // <<< grs
TImpsCDataUtils::AddValuesFromArrayL(
myKey,
KNewMessageElements,
sizeof( KNewMessageElements ) /
sizeof( KNewMessageElements[0] ) );
myKey->AddL( CREATEKEY( EImpsKeyMessageInfo, 0 ) );
TPtrC mySender;
TPtrC myGroup;
TImpsCDataUtils::GetSenderL( myKey, myAccess,
mySender, myGroup );
TImpsCDataUtils::GetRecipientsL( myKey, myAccess,
grs, users, sng, sns );
myKey->PopL();
TPtrC myType;
TImpsCDataUtils::GetContentTypeL( myAccess, myType );
// !!!! Fix for JKIO-6PAGQ3 !!!!
// Check whether the content type starts with "text/plain"
if ( !myType.Left(KImpsContentType().Length()).CompareF( KImpsContentType ) || myType.Length() == 0 )
{
TPtrC myContent;
TImpsCDataUtils::GetContentDataL( myKey, myAccess, myContent );
// Call API observer method
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2::call HandleNewTextMessageL opid=%d"), event->iOpCode );
#endif
TRAP( err, imhandler->HandleNewTextMessageL(
event->iOpCode,
msgId,
mySender,
myGroup,
*users,
*sns,
myContent,
*iClient.CspIdentifier() ));
}
else
{
TPtrC8 myContent;
TInt inCleanup(0);
TDesC8* content;
myKey->Reset();
TImpsCDataUtils::AddValuesFromArrayL(
myKey,
KNewMessageElements,
sizeof( KNewMessageElements ) /
sizeof( KNewMessageElements[0] ) );
myKey->AddL( CREATEKEY( EImpsKeyContentData, 0 ) );
if ( myAccess->RestoreDesc8L( myKey, content ) )
{
TInt encoding (-1);
TImpsCDataUtils::GetContentEncodingL( myAccess, encoding);
if ( encoding == EImpsBASE64 )
{
// allocate buffer for decoding
HBufC8* contentBuf = HBufC8::NewLC( content->Length() ); // << contentBuf
inCleanup++;
// BASE64 decoding
TImCodecB64 codec;
codec.Initialise();
TPtr8 ptr( contentBuf->Des() );
codec.Decode( *content , ptr );
myContent.Set(*contentBuf);
}
else
{
myContent.Set( *content );
}
}
else
{
myContent.Set( KNullDesC8 );
}
// Call API observer method
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2::HandleNewContentMessageL opid=%d length=%d"), event->iOpCode, myContent.Length() );
#endif
TRAP( err, imhandler->HandleNewContentMessageL(
event->iOpCode,
msgId,
mySender,
myGroup,
*users,
*sns,
myType,
myContent,
*iClient.CspIdentifier() ));
if ( inCleanup > 0 )
{
CleanupStack::PopAndDestroy( inCleanup ); // >>> contentBuf
}
myKey->PopL();
}
CleanupStack::PopAndDestroy(4); // >>> users, sns, grs, sng
}
break;
case EImpsDeliveryReportReq:
{
if ( !imhandler )
{
break;
}
TImpsCDataUtils::AddValuesFromArrayL(
myKey,
KTransContentElements,
sizeof( KTransContentElements ) /
sizeof( KTransContentElements[0] ) );
myKey->AddL( CREATEKEY( EImpsKeyDeliveryReport_Request, 0 ) );
myKey->AddL( CREATEKEY( EImpsKeyMessageInfo, 0 ) );
myKey->AddL( CREATEKEY( EImpsKeyMessageID, 0 ) );
TDesC* msgId;
myAccess->RestoreDescL( myKey, msgId );
myKey->PopL( 2 );
myKey->AddL( CREATEKEY( EImpsKeyResult, 0 ) );
myKey->AddL( CREATEKEY( EImpsKeyCode, 0 ) );
TInt result( 0 );
myAccess->RestoreIntegerL( myKey, result );
myKey->PopL();
myKey->AddL( CREATEKEY( EImpsKeyDescription, 0 ) );
TDesC* description;
myAccess->RestoreDescL( myKey, description );
TRAP( err, imhandler->HandleDeliveryReportL(
*msgId, result, description, *iClient.CspIdentifier() ) );
// myKey->ResetL( );
}
break;
case EImpsGetBlockedListRes:
if ( blockhandler )
{
TBool blockedInUse( EFalse );
TBool grantedInUse( EFalse );
CPtrC16Array* blockedList = new ( ELeave )CPtrC16Array( 4 );
CleanupStack::PushL( blockedList ); // <<< blockedList
CPtrC16Array* grantedList = new ( ELeave )CPtrC16Array( 4 );
CleanupStack::PushL( grantedList ); // <<< grantedList
// Get data from internal data format to API method
TImpsCDataUtils::GetBlockedListResponseL(
myKey, myAccess,
blockedList,
blockedInUse,
grantedList,
grantedInUse );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2::call GetBlockedListResponseL opid=%d"), event->iOpCode );
#endif
// Call API observer method
TRAP( err, blockhandler->GetBlockedListResponseL(
blockedList,
blockedInUse,
grantedList,
grantedInUse,
*client.CspIdentifier() ) );
CleanupStack::PopAndDestroy(2); // >> blockedList, grantedlist
}
break;
default: // responses
if ( event->iReqMesType == EImpsBlockEntityReq && blockhandler)
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2::call HandleCompleteL opid=%d"), event->iOpCode );
#endif
TRAP( err, blockhandler->HandleCompleteL( event->iOpCode, /*event->iStatus,*/ *iClient.CspIdentifierL() ));
}
else if ( event->iReqMesType == EImpsSendMessageReq && imhandler)
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2::call HandleSendCompleteL opid=%d"), event->iOpCode );
#endif
TRAP( err, imhandler->HandleSendCompleteL(
event->iOpCode, EFalse, *iClient.CspIdentifier()));
}
else
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("CImpsImHandler2:: ERROR CORRUPTED ***** opid=%d"), event->iOpCode );
#endif
__ASSERT_DEBUG( 0 == 1,
User::Panic( KImpsPanicCategory,
EImpsCorrupted ) );
User::Leave( KErrNotSupported );
}
break;
} // switch
CleanupStack::PopAndDestroy(2); // myKey, myAccess
}
// End of File