/*
* Copyright (c) 2008-2008 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: Implementation of the presence handler
*
*/
#include "cvimpstdetailspresencehandler.h"
#include "tvimpstconsts.h"
//presence cache header
#include <presencecachereader2.h> // cache reader
#include <avabilitytext.h>
// ximpfw
#include <ximpclient.h>
#include <ximpcontext.h>
#include <StringLoader.h>
#include <vimpstdetailsviewpluginrsc.rsg>
// ---------------------------------------------------------------------------
// NewL, two-phase construction
// ---------------------------------------------------------------------------
//
CVIMPSTDetailsPresenceHandler* CVIMPSTDetailsPresenceHandler::NewL(const TDesC& aServiceName ,
MVIMPSTDetailsPresenceObserver& aObserver,
TBool aPresenceSupported )
{
CVIMPSTDetailsPresenceHandler* self= new (ELeave) CVIMPSTDetailsPresenceHandler( aObserver, aPresenceSupported );
CleanupStack::PushL(self);
self->ConstructL( aServiceName );
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
// C++ (first phase) constructor
// ---------------------------------------------------------------------------
//
CVIMPSTDetailsPresenceHandler::CVIMPSTDetailsPresenceHandler(MVIMPSTDetailsPresenceObserver& aObserver,
TBool aPresenceSupported)
: iPresenceObserver( aObserver ),
iStatus( TVIMPSTEnums::EOffline ),
iPresenceSupported( aPresenceSupported )
{
// No implementation required
}
// ---------------------------------------------------------------------------
// ConstructL, second phase constructor
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::ConstructL(const TDesC& aServiceName )
{
iServiceName = aServiceName.AllocL();
iXIMClient = MXIMPClient::NewClientL();
//Create new sink to receive ximp context events
iPresenceContext = iXIMClient->NewPresenceContextLC();
CleanupStack::Pop(); // iPresenceContext
//initialize the presence cache.
iPresenceCacheReader = MPresenceCacheReader2::CreateReaderL();
iPresenceCacheReader->SetObserverForSubscribedNotifications(this);
iUserId = NULL;
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CVIMPSTDetailsPresenceHandler::~CVIMPSTDetailsPresenceHandler()
{
delete iStatusMessage;
delete iUserId;
delete iStatusText;
delete iServiceName;
delete iPresenceCacheReader;
delete iPresenceContext;
delete iXIMClient;
}
// ---------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::SubscribePresenceL
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::SubscribePresenceL(const TDesC& aUserId )
{
if( iUserId )
{
delete iUserId;
iUserId = NULL;
}
iUserId = aUserId.AllocL();
if( !iPresenceSupported )
{
return;
}
HBufC* name = HBufC::NewLC( aUserId.Length() + iServiceName->Length() + KColon().Length() );
TPtr namePtr( name->Des() );
namePtr.Zero();
// append the service name followed by user id ,seperated by colon
namePtr.Append(*iServiceName);
namePtr.Append(KColon);
namePtr.Append(aUserId);
iPresenceCacheReader->SubscribePresenceBuddyChangeL(namePtr);
MPresenceBuddyInfo2* presenceBuddyInfo = iPresenceCacheReader->PresenceInfoLC(namePtr);
if ( presenceBuddyInfo )
{
TPtrC buddyXSPId = presenceBuddyInfo->BuddyId(); // read the buddyID : returns in XSP format
TPtrC buddyId = buddyXSPId.Right( buddyXSPId.Length() - iServiceName->Length() - KColon().Length());
// read the availability /presence state enum value
MPresenceBuddyInfo2::TAvailabilityValues availabilityEnum = presenceBuddyInfo->Availability();
TPtrC avablityText = presenceBuddyInfo->AvailabilityText();
ConvertPresenceCacheEnums( availabilityEnum ,avablityText ); // convert the presence cache enum value to service tab enum
if(TVIMPSTEnums::EUnknown == iStatus)
{
//get the blocked and pending state
GetKeyFieldsAndValuesL(*presenceBuddyInfo);
}
TPtrC statusMsg = presenceBuddyInfo->StatusMessage(); // read the status message
ProcessStatusMesssageL( statusMsg );
CleanupStack::PopAndDestroy(); // presenceBuddyInfo
}
CleanupStack::PopAndDestroy(); // name
}
// ---------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::HandlePresenceReadL
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::HandlePresenceReadL(TInt /*aErrorCode*/,
RPointerArray<MPresenceBuddyInfo2>& /*aPresenceBuddyInfoList*/)
{
//Not required as we are not subcribing to all buddies presence
}
// ---------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::HandlePresenceNotificationL
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::HandlePresenceNotificationL(TInt /*aErrorCode*/,
MPresenceBuddyInfo2* aPresenceBuddyInfo)
{
if ( aPresenceBuddyInfo )
{
CleanupDeletePushL( aPresenceBuddyInfo );
TPtrC buddyXSPId = aPresenceBuddyInfo->BuddyId(); // read the buddyID : returns in XSP format
TPtrC buddyId = buddyXSPId.Right( buddyXSPId.Length() - iServiceName->Length() - KColon().Length());
// read the availability /presence state enum value
MPresenceBuddyInfo2::TAvailabilityValues availabilityEnum = aPresenceBuddyInfo->Availability();
TPtrC avablityText = aPresenceBuddyInfo->AvailabilityText();
// convert the presence cache enum value to service tab enum
ConvertPresenceCacheEnums( availabilityEnum ,avablityText );
// its either blocked or pending stats, hence get the corrrect state
if(TVIMPSTEnums::EUnknown == iStatus)
{
//get the blocked and pending state
GetKeyFieldsAndValuesL(*aPresenceBuddyInfo);
}
TPtrC statusMsg = aPresenceBuddyInfo->StatusMessage(); // read the status message
ProcessStatusMesssageL( statusMsg );
CleanupStack::PopAndDestroy(); // aPresenceBuddyInfo
}
}
// ---------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::ConvertPresenceCacheEnums
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::ConvertPresenceCacheEnums(MPresenceBuddyInfo2::TAvailabilityValues aAvailabilityEnum, TPtrC aAvabilityText)
{
// convert the presence cache enums to UI enumvalues
// by default if the enum doesnot match then its TVIMPSTEnums::UnKnown
switch( aAvailabilityEnum )
{
case MPresenceBuddyInfo2::EBusy:
{
if(0==aAvabilityText.Compare(KAwayState))
{
iStatus = TVIMPSTEnums::EAway;
}
else if(0==aAvabilityText.Compare(KOnPhoneState))
{
iStatus = TVIMPSTEnums::EOnPhone;
}
else if(0==aAvabilityText.Compare(KDndState))
{
iStatus = TVIMPSTEnums::EDoNotDisturb;
}
else
{
iStatus = TVIMPSTEnums::EBusy;
}
break;
}
case MPresenceBuddyInfo2::EAvailable:
{
iStatus = TVIMPSTEnums::EOnline;
break;
}
case MPresenceBuddyInfo2::ENotAvailable:
{
iStatus = TVIMPSTEnums::EOffline;
break;
}
case MPresenceBuddyInfo2::EUnknownAvailability:
{
iStatus = TVIMPSTEnums::EUnknown;
if(0==aAvabilityText.Compare(KInvisibleState))
{
iStatus = TVIMPSTEnums::EInvisible;
}
break;
}
default:
{
iStatus = TVIMPSTEnums::EOffline;
break;
}
}
}
// ---------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::ProcessStatusMesssageL
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::ProcessStatusMesssageL(const TDesC& aStatusMessage )
{
if( iStatusMessage )
{
delete iStatusMessage ;
iStatusMessage = NULL;
}
if( aStatusMessage.Length() > 0 )
{
// MAx length of KStatusMsgMaxLength is allocated
// if status message is longer than KStatusMsgMaxLength
iStatusMessage = aStatusMessage.Left( KStatusMsgMaxLength ).AllocL();
}
iPresenceObserver.HandlePresenceChangedL();
}
// --------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::GetPresenceStatus
// --------------------------------------------------------------------------
//
TVIMPSTEnums::TOnlineStatus CVIMPSTDetailsPresenceHandler::GetPresenceStatus()
{
if(!iUserId)
{
return TVIMPSTEnums::EUnknown;
}
return iStatus;
}
// --------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::GetHeaderLabelDataL
// --------------------------------------------------------------------------
//
const TDesC& CVIMPSTDetailsPresenceHandler::GetHeaderLabelDataL( TInt aIndex )
{
if( aIndex == 0 && iServiceName ) // first label data
{
return *iServiceName;
}
else if( aIndex == 2 && iPresenceSupported ) // second label data
{
return GetStatusTextL();
}
return KNullDesC; // return empty string for index 1 (label 2) for line in between the service name and presence
}
// --------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::GetStatusMessageL
// --------------------------------------------------------------------------
//
const TDesC& CVIMPSTDetailsPresenceHandler::GetStatusMessageL()
{
if( iStatusMessage && iStatusMessage->Length() )
{
return *iStatusMessage;
}
return GetStatusTextL();
}
// --------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::IsSupported
// --------------------------------------------------------------------------
//
TBool CVIMPSTDetailsPresenceHandler::IsSupported() const
{
return iPresenceSupported;
}
// --------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::GetStatusTextL
// --------------------------------------------------------------------------
//
const TDesC& CVIMPSTDetailsPresenceHandler::GetStatusTextL()
{
TInt resourceId = R_SERVDETAIL_STATUSTEXT_OFFLINE;
switch( iStatus )
{
case TVIMPSTEnums::EOffline:
{
resourceId = R_SERVDETAIL_STATUSTEXT_OFFLINE;
break;
}
case TVIMPSTEnums::EBusy:
{
resourceId = R_SERVDETAIL_STATUSTEXT_BUSY;
break;
}
case TVIMPSTEnums::EOnline:
{
resourceId = R_SERVDETAIL_STATUSTEXT_ONLINE;
break;
}
case TVIMPSTEnums::EInvisible:
{
resourceId = R_SERVDETAIL_STATUSTEXT_DND;
break;
}
case TVIMPSTEnums::EOnPhone:
{
resourceId = R_SERVDETAIL_STATUSTEXT_ONTHEPHONE;
break;
}
case TVIMPSTEnums::EDoNotDisturb:
{
resourceId = R_SERVDETAIL_STATUSTEXT_DND;
break;
}
case TVIMPSTEnums::EAway:
{
resourceId = R_SERVDETAIL_STATUSTEXT_AWAY;
break;
}
case TVIMPSTEnums::EBlocked:
{
resourceId = R_SERVDETAIL_STATUSTEXT_BLOCKED;
break;
}
case TVIMPSTEnums::EPending:
{
resourceId = R_SERVDETAIL_STATUSTEXT_PENDING;
break;
}
case TVIMPSTEnums::ECallForward:
{
resourceId = R_SERVDETAIL_STATUSTEXT_CALLFORWARD;
break;
}
case TVIMPSTEnums::EUnknown:
case TVIMPSTEnums::EServiceOut:
default:
{
break;
}
}
if( iStatusText )
{
delete iStatusText;
iStatusText = NULL;
}
if( CCoeEnv::Static() && TVIMPSTEnums::EServiceOut != iStatus
&& TVIMPSTEnums::EUnknown != iStatus )
{
iStatusText = StringLoader::LoadL( resourceId );
}
if( iStatusText && iUserId )
{
return *iStatusText;
}
return KNullDesC;
}
// ---------------------------------------------------------------------------
// CVIMPSTDetailsPresenceHandler::GetKeyFieldsAndValuesL
// ---------------------------------------------------------------------------
//
void CVIMPSTDetailsPresenceHandler::GetKeyFieldsAndValuesL(MPresenceBuddyInfo2& aPresenceBuddyInfo)
{
// At any point of time fro remote and blocked contact only one of the keys
// KPendingRequestExtensionValue/KBlockedExtensionValue will be assigned, and not both the keys.
TPtrC8 value = aPresenceBuddyInfo.GetAnyField( KExtensionKey() ) ;
if(value.Compare( KPendingRequestExtensionValue ) == 0)
{
iStatus = TVIMPSTEnums::EPending;
}
else if(value.Compare( KBlockedExtensionValue ) == 0)
{
iStatus = TVIMPSTEnums::EBlocked;
}
else if(value.Compare( KServiceExtensionValue ) == 0)
{
iStatus = TVIMPSTEnums::EServiceOut;
}
else if(value.Compare( KCallForwardExtensionValue ) == 0)
{
iStatus = TVIMPSTEnums::ECallForward;
}
else
{
iStatus = TVIMPSTEnums::EOffline;
}
}
// end of file