imservices/ossprotocoladaptation/src/presencepublishing/cpublishownpresencerequest.cpp
/*
* Copyright (c) 2006 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: IMplementaion for publising own presence
*
*/
#include <ximpprotocolconnectionhost.h>
#include "cpublishownpresencerequest.h"
#include "mossprotocolconnectionmanager.h"
#include "ossprotocolpluginlogger.h"
#include "waittimer.h"
#include "cossprotocolconnectionmanager.h"
#include <ximpobjectfactory.h>
#include <ximpobjectcollection.h>
#include <protocolpresencepublishingdatahost.h>
#include <presentitygroupinfo.h>
#include <presenceinfofieldvaluetext.h>
#include <presenceinfofieldvalueenum.h>
#include <presentitygroupmemberinfo.h>
#include <ximpidentity.h>
#include <presenceinfo.h>
#include <personpresenceinfo.h>
#include <servicepresenceinfo.h>
#include <devicepresenceinfo.h>
#include <presenceinfofield.h>
#include <presenceinfofieldcollection.h>
#include <presenceinfofieldvaluebinary.h>
#include <stdlib.h>
#include "stringutils.h"
#include <string.h>
#include "msgliterals.h"
#include "msg_enums.h"
#include "xmppparameters.h"
#include "waittimer.h"
#include <e32math.h>
#include "ossprotocoladaptutils.h"
#include <avabilitytext.h>
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::CPublishOwnPresencerequest
// ---------------------------------------------------------------------------
//
CPublishOwnPresencerequest::CPublishOwnPresencerequest(
MOSSProtocolConnectionManager& aConnMan,
TXIMPRequestId aRequestId ) :
CActive( EPriorityNormal ),
iRequestId( aRequestId ),
iConnMan( aConnMan )
{
LOGGER ( TXT("::CPublishOwnPresencerequest Start") );
CActiveScheduler::Add( this );
LOGGER ( TXT("::CPublishOwnPresencerequest End") );
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::ConstructL
// ---------------------------------------------------------------------------
//
void CPublishOwnPresencerequest::ConstructL()
{
LOGGER ( TXT("CPublishOwnPresencerequest::ConstructL Start-End") );
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::NewL
// ---------------------------------------------------------------------------
//
CPublishOwnPresencerequest* CPublishOwnPresencerequest::NewL(
MOSSProtocolConnectionManager& aConnMan,
TXIMPRequestId aRequestId )
{
LOGGER ( TXT("CPublishOwnPresencerequest::NewL Start") );
CPublishOwnPresencerequest* self = new( ELeave )
CPublishOwnPresencerequest( aConnMan, aRequestId );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
LOGGER ( TXT("CPublishOwnPresencerequest::NewL End") );
return self;
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::NewLC
// ---------------------------------------------------------------------------
//
CPublishOwnPresencerequest* CPublishOwnPresencerequest::NewLC(
MOSSProtocolConnectionManager& aConnMan,
TXIMPRequestId aRequestId )
{
LOGGER ( TXT("CPublishOwnPresencerequest::NewLC Start") );
CPublishOwnPresencerequest* self =
CPublishOwnPresencerequest::NewL(aConnMan, aRequestId);
CleanupStack::PushL( self );
LOGGER ( TXT("CPublishOwnPresencerequest::NewLC End") );
return self;
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::~CPublishOwnPresencerequest
// ---------------------------------------------------------------------------
//
CPublishOwnPresencerequest::~CPublishOwnPresencerequest()
{
LOGGER ( TXT("::~CPublishOwnPresencerequest Start") );
CActive::Cancel();
delete iOwnPresenceInfo;
iOwnPresenceInfo = NULL;
LOGGER ( TXT("::~CPublishOwnPresencerequest End") );
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::DoCancel()
// ---------------------------------------------------------------------------
//
void CPublishOwnPresencerequest::DoCancel()
{
LOGGER ( TXT("CPublishOwnPresencerequest::DoCancel Start") );
// iConnMan.DataHandler().CancelSending( iSendId );
LOGGER ( TXT("CPublishOwnPresencerequest::DoCancel End") );
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::RunL()
// ---------------------------------------------------------------------------
//
void CPublishOwnPresencerequest::RunL()
{
LOGGER ( TXT("CPublishOwnPresencerequest::RunL Start") );
message_hdr_resp* msg_struct = NULL;
User::LeaveIfError ( iStatus.Int() );
char* pResponse = NULL;
pResponse = iConnMan.DataHandler().ResponseL ( iSendId );
msg_struct = ( message_hdr_resp* )pResponse ;
if( !( msg_struct->response ) )
{
switch( msg_struct->error_type )
{
default: //for all other error codes like ssl related are mapped to general error
iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, KXIMPErrServiceGeneralError );
break;
}
}
else
{
if( iOwnPresenceInfo )
{
// set or clear avatar
MPresenceCacheWriter2* presenceCacheWriter = MPresenceCacheWriter2::CreateWriterL();
TInt cacheerror = presenceCacheWriter->WritePresenceL( iOwnPresenceInfo );
User::LeaveIfError ( cacheerror);
delete iOwnPresenceInfo ;
iOwnPresenceInfo = NULL;
delete presenceCacheWriter;
}
iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, KErrNone );
}
free( pResponse );
delete this;
LOGGER ( TXT("CPublishOwnPresencerequest::RunL End") );
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::RunError
// ---------------------------------------------------------------------------
//
TInt CPublishOwnPresencerequest::RunError( TInt aError )
{
LOGGER ( TXT("CPublishOwnPresencerequest::RunError Start") );
iConnMan.HandleToHost().HandleRequestCompleted( iRequestId, aError );
delete this;
LOGGER ( TXT("CPublishOwnPresencerequest::RunError End") );
return KErrNone;
}
// ---------------------------------------------------------------------------
// CPublishOwnPresencerequest::PublishOwnPresenceL
// ---------------------------------------------------------------------------
//
void CPublishOwnPresencerequest::PublishOwnPresenceL(const MPresenceInfo& aPresence)
{
LOGGER ( TXT("CPublishOwnPresencerequest::PublishOwnPresenceL Start") );
char *smsg = NULL;
char *tmpmsg = NULL;
message_hdr_req msgHdr = {0,};
int err = 0;
int userLen = 0;
int totalLen = 0;
const MPersonPresenceInfo* personPresence = aPresence.PersonPresence();
const MPresenceInfoFieldCollection& presenceFields = personPresence->Fields();
const MPresenceInfoField& presenceField = presenceFields.FieldAt( 0 );
//updating own avtar
if( !(presenceField.FieldType().Compare( NPresenceInfo::NFieldType::KAvatar )) )
{
int messagelength = 0;
const MPresenceInfoFieldValueBinary* avtarfield =
TXIMPGetInterface< const MPresenceInfoFieldValueBinary >::From(
presenceField.FieldValue(),
MXIMPBase::EPanicIfUnknown );
if( !(avtarfield->MimeType().Length() )) //clear avatar
{
// now manufacture the message for the clear avtar
msgHdr.message_type = EClearOwnAvatar;
messagelength = sizeof( message_hdr_req );
smsg = ( char* ) User::AllocLC ( messagelength );
memset ( smsg, '\0', messagelength );
memcpy( smsg, &msgHdr, messagelength );//copies message header
iSendId = iConnMan.DataHandler().SendDataL ( iStatus, smsg, messagelength );
SetActive();// signal the scheduler
CleanupStack::PopAndDestroy ( 1 ); //smsg
}
else //set or update avatar
{
// now manufacture the message for the avtar
msgHdr.message_type = EUpdateOwnAvtar;
messagelength = sizeof( message_hdr_req ) + avtarfield->MimeType().Length() + avtarfield->BinaryValue().Length()+2; // 2 for '\0' 's
smsg = ( char* ) User::AllocLC ( messagelength );
tmpmsg = ( char* ) User::AllocLC ( messagelength );
memset ( smsg, '\0', messagelength );
memset ( tmpmsg, '\0', messagelength );
if( messagelength > (MAX_MSG_SIZE - totalLen) )
msgHdr.continue_flag = 1;
memcpy( smsg, &msgHdr, sizeof( message_hdr_req ) );//copies message header
totalLen += sizeof( message_hdr_req );
OssProtocolAdapUtils::ConvertTDesC8toChar( avtarfield->MimeType(),tmpmsg);
userLen = avtarfield->MimeType().Length();
memcpy( smsg + totalLen, tmpmsg, userLen );//copies mimetype
totalLen += userLen + 1; // for '\0'
memset ( tmpmsg, '\0', messagelength );
OssProtocolAdapUtils::ConvertTDesC8toChar( avtarfield->BinaryValue(),tmpmsg);
userLen = avtarfield->BinaryValue().Length();
memcpy( smsg + totalLen, tmpmsg, userLen );//copies avtar
totalLen += userLen + 1;
iSendId = iConnMan.DataHandler().SendDataL ( iStatus, smsg, totalLen );
SetActive();// signal the scheduler
CleanupStack::PopAndDestroy ( 2 ); //tmpmsg,smsg
}
iOwnPresenceInfo = MPresenceBuddyInfo2::NewL();
if( iOwnPresenceInfo )
{
TPtrC ownUserPtr = iConnMan.UserName();
HBufC* xspId = NULL;
if( ownUserPtr.Length() )
{
xspId = HBufC::NewLC( ownUserPtr.Length() + iConnMan.ServiceName().Length() + KColon().Length() );
TPtr xspIdPtr( xspId->Des() );
xspIdPtr.Zero();
xspIdPtr.Append(iConnMan.ServiceName() ); // prepend service name
xspIdPtr.Append(KColon);
xspIdPtr.Append( ownUserPtr );
iOwnPresenceInfo->SetIdentityL(xspIdPtr);
CleanupStack::PopAndDestroy(xspId); //xspId
}
else
{
TPtrC xmppOwnId = iConnMan.XmppParams().UserName();
xspId = HBufC::NewLC( xmppOwnId.Length() + iConnMan.ServiceName().Length() + KColon().Length() );
TPtr xspIdPtr( xspId->Des() );
xspIdPtr.Zero();
xspIdPtr.Append(iConnMan.ServiceName() ); // prepend service name
xspIdPtr.Append(KColon);
xspIdPtr.Append( xmppOwnId );
iOwnPresenceInfo->SetIdentityL(xspIdPtr);
CleanupStack::PopAndDestroy(xspId); //xspId
}
iOwnPresenceInfo->SetAvatarL( avtarfield->BinaryValue() );
TInt fieldCount = presenceFields.FieldCount();
for( TInt i = 1; i < fieldCount; i++ ) // zero index is for avatar
{
const MPresenceInfoField& presenceField = presenceFields.FieldAt( i );
TBuf8<32> temp = presenceField.FieldType();
if( !( presenceField.FieldType().Compare( NPresenceInfo::NFieldType::KAvailabilityEnum )) )
{
const MPresenceInfoFieldValueEnum* availability =
TXIMPGetInterface< const MPresenceInfoFieldValueEnum >::From(
presenceField.FieldValue(),
MXIMPBase::EPanicIfUnknown );
MPresenceBuddyInfo2::TAvailabilityValues availabe = MPresenceBuddyInfo2::EUnknownAvailability;
switch (availability->Value())
{
case NPresenceInfo::EAvailable :
{
availabe = MPresenceBuddyInfo2::EAvailable;
iOwnPresenceInfo->SetAvailabilityL( availabe ,KNullDesC );
break;
}
case NPresenceInfo::EBusy :
{
availabe = MPresenceBuddyInfo2::EBusy;
iOwnPresenceInfo->SetAvailabilityL( availabe ,KNullDesC );
break;
}
case NPresenceInfo::EHidden :
{
availabe = MPresenceBuddyInfo2::EAvailable;
iOwnPresenceInfo->SetAvailabilityL( availabe ,KNullDesC );
break;
}
case NPresenceInfo::EDoNotDisturb:
{
availabe = MPresenceBuddyInfo2::EBusy;
iOwnPresenceInfo->SetAvailabilityL( availabe,KDndState);
break;
}
case NPresenceInfo::EAway:
{
availabe = MPresenceBuddyInfo2::EBusy;
iOwnPresenceInfo->SetAvailabilityL( availabe,KAwayState);
break;
}
case NPresenceInfo::ENotAvailable:
{
availabe = MPresenceBuddyInfo2::ENotAvailable;
iOwnPresenceInfo->SetAvailabilityL( availabe ,KNullDesC );
break;
}
default:
break;
}
}
else if( !(presenceField.FieldType().Compare( NPresenceInfo::NFieldType::KStatusMessage )) )
{
const MPresenceInfoFieldValueText* statustext =
TXIMPGetInterface< const MPresenceInfoFieldValueText >::From(
presenceField.FieldValue(),
MXIMPBase::EPanicIfUnknown );
// now manufacture the message for the status text
if( statustext && statustext->TextValue().Length() )
{
iOwnPresenceInfo->SetStatusMessageL( statustext->TextValue() );
}
}
}
}
}
else //for update presence
{
TInt fieldCount = presenceFields.FieldCount();
char* availablty = ( char* ) User::AllocLC ( MAX_MSG_SIZE );
smsg = ( char* ) User::AllocLC ( MAX_MSG_SIZE );
tmpmsg = ( char* ) User::AllocLC ( MAX_MSG_SIZE );
msgHdr.message_type = EUpdateOwnPresence;
memset ( smsg, '\0', MAX_MSG_SIZE );
memset ( tmpmsg, '\0', MAX_MSG_SIZE );
memset ( availablty, '\0', MAX_MSG_SIZE );
memcpy( smsg, &msgHdr, sizeof( message_hdr_req ) );
totalLen += sizeof( message_hdr_req );
// updating availability
const MPersonPresenceInfo* personPresence = aPresence.PersonPresence();
const MPresenceInfoFieldCollection& presenceFields = personPresence->Fields();
//TInt fieldCount = presenceFields.FieldCount();
for( TInt i = 0; i < fieldCount; i++ )
{
const MPresenceInfoField& presenceField = presenceFields.FieldAt( i );
TBuf8<32> temp = presenceField.FieldType();
LOGGER ( TXT( "ExtractPersonPresenceAttributes:%S "),&presenceField.FieldType());
if( !( presenceField.FieldType().Compare( NPresenceInfo::NFieldType::KAvailabilityEnum )) )
{
const MPresenceInfoFieldValueEnum* availability =
TXIMPGetInterface< const MPresenceInfoFieldValueEnum >::From(
presenceField.FieldValue(),
MXIMPBase::EPanicIfUnknown );
if ( availability->Value() == NPresenceInfo::EAvailable )
{
char* temp = "avaliable";
strcpy(availablty,temp);
userLen = strlen( availablty );
memcpy( smsg + totalLen, availablty, userLen );
totalLen += userLen + 1;
}
else if ( availability->Value() == NPresenceInfo::EBusy )
{
char* temp = "dnd";
strcpy(availablty,temp);
userLen = strlen( availablty );
memcpy( smsg + totalLen, availablty, userLen );
totalLen += userLen + 1;
}
else if(availability->Value() == NPresenceInfo::EAway)
{
char* temp = "away";
strcpy(availablty,temp);
userLen = strlen( availablty );
memcpy( smsg + totalLen, availablty, userLen );
totalLen += userLen + 1;
}
else if(availability->Value() == NPresenceInfo::EHidden)
{
char* temp = "hidden";
strcpy(availablty,temp);
userLen = strlen( availablty );
memcpy( smsg + totalLen, availablty, userLen );
totalLen += userLen + 1;
}
else if(availability->Value() == NPresenceInfo::ENotAvailable)
{
char* temp = "offline";
strcpy(availablty,temp);
userLen = strlen( availablty );
memcpy( smsg + totalLen, availablty, userLen );
totalLen += userLen + 1;
}
}
//updating status text
if( !(presenceField.FieldType().Compare( NPresenceInfo::NFieldType::KStatusMessage )) )
{
const MPresenceInfoFieldValueText* statustext =
TXIMPGetInterface< const MPresenceInfoFieldValueText >::From(
presenceField.FieldValue(),
MXIMPBase::EPanicIfUnknown );
// now manufacture the message for the status text
if( statustext && statustext->TextValue().Length() )
{
TPtrC bufferPtr ( statustext->TextValue() );
err = tbufC16tochar ( bufferPtr, tmpmsg );
if( KErrNotFound == err)
{
iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, err );
}
userLen = strlen ( tmpmsg ) + 1; //for '\0'
}
memcpy( smsg + totalLen, tmpmsg, userLen );
totalLen += userLen + 1;
}
}
iSendId = iConnMan.DataHandler().SendDataL ( iStatus, smsg, totalLen );
SetActive();// signal the scheduler
CleanupStack::PopAndDestroy ( 3 ); //tmpmsg,smsg,availability
}
LOGGER ( TXT("CPublishOwnPresencerequest::PublishOwnPresenceL End") );
}
// End of file