--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imservices/ossprotocoladaptation/src/waittimer.cpp Thu Dec 17 08:54:49 2009 +0200
@@ -0,0 +1,1150 @@
+/*
+* Copyright (c) 2007-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: oss protocol plugin im features
+*
+*/
+
+
+#include "waittimer.h"
+#include "cosssenddataoperation.h"
+#include "msgliterals.h"
+#include "msg_enums.h"
+#include <stdlib.h>
+#include "ossprotocloliterals.h"
+#include "stringutils.h"
+#include "ossadappanics.h"
+#include <glib/gprintf.h>
+#include <string.h>
+#include <sys/msg.h>
+#include "ossprotocolpluginlogger.h"
+#include <ximpobjectfactory.h>
+#include "mossprotocolconnectionmanager.h"
+#include "cossprotocolconnectionmanager.h"
+#include <ximpprotocolconnectionhost.h>
+#include <ximpstatus.h>
+#include <math.h>
+#include <avabilitytext.h>
+#include "ossprotocoladaptutils.h"
+// CONSTANTS
+const TInt KOpIdInitvalue = 1000;
+
+#define KTimerInterval 50000
+
+#define ONE_K_OPENC_FIX 1020
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CWaitTimer::COSSProtocolImFeatures()
+// ---------------------------------------------------------------------------
+//
+CWaitTimer::CWaitTimer (MOSSProtocolConnectionManager& aConnMan) :
+ CActive ( EPriorityHigh ), // Standard priority
+ iOpidIterator ( KOpIdInitvalue ), iOpId ( 5 ),iConnMan ( aConnMan ),
+ iResponseMsgQCreated(EFalse),iServerDisconnected(EFalse),
+ iFetchingStep(EDataFetchingStep1) // -2 for fetching all three types of contacts
+ {
+ CActiveScheduler::Add ( this ); // Add to scheduler
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWaitTimer::NewL()
+// ---------------------------------------------------------------------------
+//
+CWaitTimer* CWaitTimer::NewL (MOSSProtocolConnectionManager& aConnMan)
+ {
+ CWaitTimer* self = new ( ELeave ) CWaitTimer (aConnMan);
+ CleanupStack::PushL ( self );
+ self->ConstructL ();
+ CleanupStack::Pop (); // self;
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CWaitTimer::ConstructL()
+// ---------------------------------------------------------------------------
+//
+void CWaitTimer::ConstructL()
+ {
+ User::LeaveIfError( iTimer.CreateLocal() );
+ }
+
+// ---------------------------------------------------------------------------
+// CWaitTimer::~CWaitTimer()
+// ---------------------------------------------------------------------------
+//
+CWaitTimer::~CWaitTimer()
+ {
+ LOGGER ( TXT ( "CWaitTimer::~CWaitTimer start" ) );
+ TInt error = 0;
+ MsgQDelete ( REQUEST_QUEUE, &error );
+ MsgQDelete ( RESPONSE_QUEUE, &error );
+ iIncomingData.ResetAndDestroy();
+ iIncomingMsg.ResetAndDestroy();
+ iIncomingPres.ResetAndDestroy();
+ iIncomingServerError.ResetAndDestroy();
+ iAddNotification.ResetAndDestroy();
+ if (iIncReqStatus)
+ {
+ User::RequestComplete( iIncReqStatus, KErrCancel );
+ iIncReqStatus = NULL;
+ }
+ if (iIncMsgReqStatus)
+ {
+ User::RequestComplete( iIncMsgReqStatus, KErrCancel );
+ iIncMsgReqStatus = NULL;
+ }
+ if (iIncPresReqStatus)
+ {
+ User::RequestComplete( iIncPresReqStatus, KErrCancel );
+ iIncPresReqStatus = NULL;
+ }
+ if (iIncAddReqStatus)
+ {
+ User::RequestComplete( iIncAddReqStatus, KErrCancel );
+ iIncAddReqStatus = NULL;
+ }
+ CancelContactsChangeListening();
+ Cancel (); // Cancel any request, if outstanding
+ iTimer.Close (); // Destroy the RTimer object
+ iOperations.ResetAndDestroy();
+ iSearchElements.ResetAndDestroy();
+ iContactChangeList.ResetAndDestroy();
+ LOGGER ( TXT ( "CWaitTimer::~CWaitTimer end" ) );
+
+ }
+
+// ---------------------------------------------------------------------------
+// CWaitTimer::DoCancel()
+// ---------------------------------------------------------------------------
+//
+void CWaitTimer::DoCancel()
+ {
+ iTimer.Cancel ();
+ }
+
+// ----------------------------------------------------------------------------
+// CWaitTimer::IncreaseOpId
+// ----------------------------------------------------------------------------
+void CWaitTimer::IncreaseOpId( )
+ {
+
+ iOpId++;
+
+ }
+
+
+// ----------------------------------------------------------------------------
+// CWaitTimer::GetOpId
+// ----------------------------------------------------------------------------
+TInt CWaitTimer::GetOpId( )
+ {
+
+ return iOpId;
+ }
+// ----------------------------------------------------------------------------
+// CWaitTimer::IsFetchingContinue
+// ----------------------------------------------------------------------------
+TInt CWaitTimer::IsFetchingContinue( )
+ {
+
+ return iFetchingContinue;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::SendDataL()
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::SendDataL ( TRequestStatus& aStatus, char* msg, TInt nBytes )
+ {
+ int result;
+ int err = 0;
+ int timeout = NO_WAIT;
+ LOGGER ( TXT ( "CWaitTimer::SendData start" ) );
+ // allocate slot in array by adding NULL pointer and removing it
+ iOperations.AppendL ( NULL );
+ iOperations.Remove ( iOperations.Count() - 1 );
+ COssSendDataOperation* operation =
+ COssSendDataOperation::NewLC();
+ operation->SetIds ( iOpId, iOpidIterator++ );
+ iOperations.Append ( operation );
+ CleanupStack::Pop ( operation ); // operation
+ // now it is safe to set request status
+ operation->SetRequestStatus ( aStatus );
+ aStatus = KRequestPending;
+ /* Try to Create queueOne
+ */
+ message_hdr_req* msgHdr = ( message_hdr_req* ) msg;
+ result = MsgQCreate ( REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err );
+ User::LeaveIfError ( result );
+ /* Send Message to queueOne */
+ if ( msgHdr->message_type == EUpdateOwnAvtar )
+ {
+ TInt header_size = sizeof( message_hdr_req );
+ char* one_pdu = ( char* ) User::AllocLC ( ONE_K_OPENC_FIX );
+ //run a loop for rest of the data and keep track of the case of nBytes being
+ //multiple of 1020 - sizeof(msghdr) and it being not
+ //Amount of payload that can be sent
+ TInt single_read = ONE_K_OPENC_FIX - header_size;
+ //Data recieved from PublishOwnPresenceL has message header at begining
+ TInt actual_data = nBytes - header_size;
+ //No of packets needed to send the image data
+ TInt total_packets = (TInt)ceil( ( double ) ( actual_data ) / single_read );
+ //This offset moves thru the msg pointer
+ TInt navigate_offset = header_size;
+ message_hdr_req msg_hdr;
+ memset( (void*)&msg_hdr, '\0', header_size );
+ msg_hdr.message_type = EUpdateOwnAvtar;
+ for ( TInt i = 0; i < total_packets; i++ )
+ {
+ //till the last packet size_tobe_sent will be ONE_K_OPENC_FIX
+ //last packet data is actual_data % single_read if less than single_read else ONE_K_OPENC_FIX
+ TInt size_tobe_sent = ( i < total_packets - 1 ) ? ONE_K_OPENC_FIX :
+ ( actual_data % single_read ?
+ actual_data % single_read + header_size : ONE_K_OPENC_FIX );
+
+ if ( i < total_packets - 1 )
+ {
+ msg_hdr.continue_flag = 1;
+ }
+ else
+ {
+ msg_hdr.continue_flag = 0;
+ }
+
+ //memcpy ( msg + header_size , msg + navigate_offset, size_tobe_sent - header_size );
+ memcpy( one_pdu , &msg_hdr, header_size );
+ memcpy( one_pdu + header_size, msg + navigate_offset, size_tobe_sent - header_size );
+ result = MsgQSend ( REQUEST_QUEUE, one_pdu, size_tobe_sent,
+ MSG_PRI_NORMAL, timeout, &err );
+ User::LeaveIfError ( result );
+ navigate_offset += single_read;
+ }
+ CleanupStack::PopAndDestroy( one_pdu );
+ one_pdu = NULL;
+ }
+ else
+ {
+ result = MsgQSend ( REQUEST_QUEUE, msg, nBytes, MSG_PRI_NORMAL, timeout, &err );
+
+ User::LeaveIfError ( result );
+ }
+ LOGGER ( TXT ( "CWaitTimer::SendData end" ) );
+
+ return iOpId;
+
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::ListenConatcsChange() //contacts
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::ListenContactsChange ( TRequestStatus& aStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ListenContactsChange Start" ) );
+
+ if ( !iContactsChangeStatus )
+ {
+ iContactsChangeStatus = &aStatus;
+ aStatus = KRequestPending;
+ }
+ LOGGER ( TXT ( "CWaitTimer::ListenContactsChange End" ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::CancelListening()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::CancelContactsChangeListening()
+ {
+ LOGGER ( TXT ( "CWaitTimer::CancelContactsChangeListening Start" ) );
+
+ if ( iContactsChangeStatus )
+ {
+ User::RequestComplete ( iContactsChangeStatus, KErrCancel );
+ iContactsChangeStatus = NULL;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::CancelContactsChangeListening End" ) );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::ListenIncomingData() //contacts
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::ListenIncomingData ( TRequestStatus& aStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingData Start" ) );
+
+ if ( !iIncReqStatus )
+ {
+ iIncReqStatus = &aStatus;
+ aStatus = KRequestPending;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::IncomingDataCount() //contacts
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::IncomingDataCount()
+ {
+ LOGGER ( TXT ( "CWaitTimer::IncomingDataCount Start" ) );
+
+ return iIncomingData.Count();
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::SearchDataCount() //Searched data
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::SearchDataCount()
+ {
+ return iSearchElements.Count();
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::ContactsChangeResponseCount() //Searched data
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::ContactsChangeResponseCount()
+ {
+ return iContactChangeList.Count();
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::CancelListening()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::CancelListening()
+ {
+ LOGGER ( TXT ( "CWaitTimer::CancelListening Start" ) );
+
+ if ( iIncReqStatus )
+ {
+ User::RequestComplete ( iIncReqStatus, KErrCancel );
+ iIncReqStatus = NULL;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::CancelListening End" ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::ListenIncomingMsg() // messages
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::ListenIncomingMsg ( TRequestStatus& aStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingMsg Start" ) );
+
+ if ( !iIncMsgReqStatus )
+ {
+ iIncMsgReqStatus = &aStatus;
+ aStatus = KRequestPending;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingMsg End Count is %d" ), iIncomingMsg.Count() );
+
+ return iIncomingMsg.Count();
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::ListenIncomingPresenceL() // presence notifications
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::ListenIncomingPresence ( TRequestStatus& aStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingPresence Start" ) );
+
+ if ( !iIncPresReqStatus )
+ {
+ iIncPresReqStatus = &aStatus;
+ aStatus = KRequestPending;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingPresence End Count is %d" ), iIncomingPres.Count() );
+
+ return iIncomingPres.Count();
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::ListenAddNotification() // Add contact notifications
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::ListenAddNotification ( TRequestStatus& aStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ListenAddNotification Start" ) );
+
+ if ( !iIncAddReqStatus )
+ {
+ iIncAddReqStatus = &aStatus;
+ aStatus = KRequestPending;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::ListenAddNotification End Count is %d" ), iAddNotification.Count() );
+
+ return iAddNotification.Count();
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::ListenIncomingServerError() // presence notifications
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::ListenIncomingServerError ( TRequestStatus& aStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingServerError Start" ) );
+
+ if ( !iIncErrorReqStatus )
+ {
+ iIncErrorReqStatus = &aStatus;
+ aStatus = KRequestPending;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::ListenIncomingServerError End Count is %d" ), iIncomingServerError.Count() );
+
+ return iIncomingServerError.Count();
+ }
+// CWaitTimer::CancelListeningMsg()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::CancelListeningMsg()
+ {
+ LOGGER ( TXT ( "CWaitTimer::CancelListening Start" ) );
+
+ if ( iIncMsgReqStatus )
+ {
+ User::RequestComplete ( iIncMsgReqStatus, KErrCancel );
+ iIncMsgReqStatus = NULL;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::CancelListening End" ) );
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::CancelListeningPres()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::CancelListeningPres()
+ {
+ LOGGER ( TXT ( "CWaitTimer::CancelListeningPres Start" ) );
+
+ if ( iIncPresReqStatus )
+ {
+ User::RequestComplete ( iIncPresReqStatus, KErrCancel );
+ iIncPresReqStatus = NULL;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::CancelListeningPres End" ) );
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::CancelListeningAddNotication()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::CancelListeningAddNotication()
+ {
+ LOGGER ( TXT ( "CWaitTimer::CancelListeningAddNotication Start" ) );
+
+ if ( iIncAddReqStatus )
+ {
+ User::RequestComplete ( iIncAddReqStatus, KErrCancel );
+ iIncAddReqStatus = NULL;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::CancelListeningAddNotication End" ) );
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::CancelListeningServerErrors()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::CancelListeningServerErrors()
+ {
+ LOGGER ( TXT ( "CWaitTimer::CancelListeningServerErrors Start" ) );
+
+ if ( iIncErrorReqStatus )
+ {
+ User::RequestComplete ( iIncErrorReqStatus, KErrCancel );
+ iIncErrorReqStatus = NULL;
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::CancelListeningServerErrors End" ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::StartListeningL()
+// -----------------------------------------------------------------------------
+//
+
+void CWaitTimer::StartListeningL()
+ {
+ LOGGER ( TXT ( "CWaitTimer::StartListening Start" ) );
+// Cancel (); // Cancel any request, just to be sure
+// iProperty.Subscribe(iStatus);
+ iTimer.After ( iStatus, KTimerInterval );
+ SetActive (); // Tell scheduler a request is active
+ LOGGER ( TXT ( "CWaitTimer::StartListening End" ) );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::RunL()
+// -----------------------------------------------------------------------------
+//
+
+void CWaitTimer::RunL()
+ {
+
+ int timeout = IPC_NOWAIT; //TIME_OUT;
+ int err = 0;
+ int status = 0;
+ int size_msg = sizeof ( message_hdr_resp );
+ TBool msgreadcontinue = EFalse;
+ message_hdr_resp* msg_struct = NULL;
+ char* rmsg = NULL;
+
+ if( !iResponseMsgQCreated )
+ {
+ status = MsgQCreate ( RESPONSE_QUEUE, MAX_MSG_Q_SIZE, MSG_Q_FIFO, &err );
+ iResponseMsgQCreated = ETrue;
+ }
+
+ if(-1 == status)
+ {
+ LOGGER ( TXT ( "CWaitTimer::leave " ) );
+ User::Leave( status );
+ }
+ do
+ {
+ rmsg = ( char* ) User::AllocLC ( MAX_MSG_SIZE );
+
+ // Receive Message from queueTwo
+
+ status = MsgQReceive ( RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, timeout, &err );
+ User::LeaveIfError ( err );
+ //size should be atleast size of message_hdr_resp
+ if( -1 == status )
+ {
+ CleanupStack::PopAndDestroy ( rmsg );
+ }
+
+ if ( status >= size_msg )
+ {
+ LOGGER ( TXT ( "CWaitTimer::MsgQReceive responce recvd" ) );
+ msg_struct = ( message_hdr_resp* )rmsg ;
+ LOGGER ( TXT ( "CWaitTimer::data recvd of type %d" ), msg_struct->hdr_req.message_type );
+
+ switch( msg_struct->hdr_req.message_type )
+ {
+ TInt operationindex;
+ case EText_Message_Receive:
+ {
+ LOGGER ( TXT ( "CWaitTimer::EText_Message_Receive" ) );
+ // complete prfw request
+ iIncomingMsg.AppendL ( rmsg );
+ if ( iIncMsgReqStatus )
+ {
+ User::RequestComplete ( iIncMsgReqStatus, KErrNone );
+ iIncMsgReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case EPresenceNotification:
+ {
+
+ LOGGER ( TXT ( "CWaitTimer::EPresence_Notification_Received" ) );
+ // complete prfw request
+ // iIncomingPres.AppendL ( rmsg );
+ iIncomingPres.Insert (rmsg,0);
+ if ( iIncPresReqStatus )
+ {
+ User::RequestComplete ( iIncPresReqStatus, KErrNone );
+ iIncPresReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ETrying_To_Add_Contact_Publish:
+ {
+ LOGGER ( TXT ( "CWaitTimer::ETrying_To_Add_Contact" ) );
+ // complete prfw request
+ iAddNotification.AppendL ( rmsg );
+ if ( iIncAddReqStatus )
+ {
+ User::RequestComplete ( iIncAddReqStatus, KErrNone );
+ iIncAddReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ESubscribe_Remote_Pending:
+ case ETrying_To_Add_Contact_Known:
+ {
+ LOGGER ( TXT ( "CWaitTimer::Sync of contacts state" ) );
+ iContactChangeList.Append(rmsg);
+ if ( iContactsChangeStatus )
+ {
+ User::RequestComplete ( iContactsChangeStatus, KErrNone );
+ iContactsChangeStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+
+ case ESubscribe_RP_Accepted:
+ {
+ CleanupStack::PopAndDestroy( rmsg );
+ break;
+ }
+ case EPublish_RP_Accepted:
+ {
+ CleanupStack::PopAndDestroy( rmsg );
+ break;
+ }
+ case EPublish_Removed_Or_Rejected:
+ {
+ LOGGER ( TXT ( "CWaitTimer::Sync of contacts state" ) );
+ iContactChangeList.Append(rmsg);
+ if ( iContactsChangeStatus )
+ {
+ User::RequestComplete ( iContactsChangeStatus, KErrNone );
+ iContactsChangeStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ESubscribe_Removed_Or_Rejected:
+ {
+ LOGGER ( TXT ( "CWaitTimer::Sync of contacts state" ) );
+ iContactChangeList.Append(rmsg);
+ if ( iContactsChangeStatus )
+ {
+ User::RequestComplete ( iContactsChangeStatus, KErrNone );
+ iContactsChangeStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ECurrent_Member_Contacts:
+ {
+ iFetchingContinue = EFalse;
+ // complete ximpfw request
+ iIncomingData.AppendL ( rmsg );
+ if(msg_struct->continue_flag == 1)
+ {
+ iFetchingContinue = ETrue;
+ }
+ else
+ {
+ iFetchingStep++ ; // move to next step
+ }
+
+ if ( iIncReqStatus && iFetchingStep == EDataFetchComplete )// complete request only if step is 1
+ {
+ User::RequestComplete ( iIncReqStatus, KErrNone );
+ iIncReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ELocal_Pending_Contacts:
+ {
+ LOGGER ( TXT ( "CWaitTimer::ELocal_Pending_Contacts" ) );
+ // complete prfw request
+ iAddNotification.AppendL ( rmsg );
+ if ( iIncAddReqStatus )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ELocal_Pending_Contacts" ) );
+ User::RequestComplete ( iIncAddReqStatus, KErrNone );
+ iIncAddReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ERemote_Pending_Contacts:
+ {
+ LOGGER ( TXT ( "CWaitTimer::ECurrent_Member_Contacts" ) );
+ iFetchingContinue = EFalse;
+ // complete ximpfw request
+ iIncomingData.AppendL ( rmsg );
+ PendingPresenceContactsL(rmsg);
+ if(msg_struct->continue_flag == 1)
+ {
+ iFetchingContinue = ETrue;
+ }
+ else
+ {
+ iFetchingStep++ ; // move next step
+ }
+ if ( iIncReqStatus && iFetchingStep == EDataFetchComplete) // complete request only if step is 1
+ {
+ User::RequestComplete ( iIncReqStatus, KErrNone );
+ iIncReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ESend_Error:
+ {
+ LOGGER ( TXT ( "CWaitTimer::ESend_Error" ) );
+ // complete ximpfw request
+ iIncomingServerError.AppendL ( rmsg );
+ if ( iIncErrorReqStatus )
+ {
+ User::RequestComplete ( iIncErrorReqStatus, KErrNone );
+ iIncErrorReqStatus = NULL;
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+
+ case EUserEndGprs:
+ LOGGER ( TXT ( "CWaitTimer::EUserCancelAccessPoint start" ) );
+
+ case EServer_DisConnect_Request:
+ {
+ iServerDisconnected = ETrue;
+ LOGGER ( TXT ( "CWaitTimer::EServer_DisConnect_Request start" ) );
+ CancelListeningMsg();
+ CancelListening();
+ CancelListeningPres();
+ CancelListeningAddNotication();
+ CancelListeningServerErrors();
+ CancelContactsChangeListening();
+
+ MXIMPObjectFactory& prfwObjFact = iConnMan.HandleToHost().ObjectFactory();
+ MXIMPStatus* status = prfwObjFact.NewStatusLC();// status
+ status->SetResultCode( KErrDisconnected );
+ iConnMan.HandleToHost().HandleConnectionTerminated( status );
+ //IssueReleaseRequestL();//Release the connection
+ CleanupStack::PopAndDestroy(); // status
+ CleanupStack::Pop( rmsg );
+ LOGGER ( TXT ( "CWaitTimer::EServer_DisConnect_Request end" ) );
+ break;
+ }
+ case ESearch_State_Finished:
+ {
+ LOGGER ( TXT ( "CWaitTimer::ESearch_State_Finished" ) );
+ operationindex = ( FindOperationL ( iOpId, COssSendDataOperation::OperationId ) );
+
+ if ( operationindex != KErrNotFound )
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperationL found" ) );
+ iOperations[ operationindex ]->SetResponse ( rmsg ); //ownership of rmsg is transferred
+ iOperations[ operationindex ]->CompletedOperation ( KErrNone );
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ case ESearch:
+ {
+ LOGGER ( TXT ( "CWaitTimer::ESearch" ) );
+ if ( msg_struct->response != 0 )
+ {
+ LOGGER ( TXT ( "CWaitTimer::ESearch : Result" ) );
+ char* pResponse = ( char* ) User::AllocLC ( status );
+ memset ( pResponse, '\0', status );
+ memcpy ( pResponse, rmsg, status );
+ iSearchElements.AppendL ( pResponse );
+ CleanupStack::Pop( pResponse );
+ CleanupStack::PopAndDestroy( rmsg );
+ }
+ else
+ {
+ LOGGER ( TXT ( "CWaitTimer::ESearch: ERROR !!" ) );
+ operationindex = ( FindOperationL ( iOpId, COssSendDataOperation::OperationId ) );
+ iOperations[ operationindex ]->SetResponse ( rmsg ); //ownership of rmsg is transferred
+ iOperations[ operationindex ]->CompletedOperation ( KErrNotSupported );// for all errors
+ CleanupStack::Pop( rmsg );
+ // send not supported, since the error mapping is not done
+ }
+ break;
+ }
+ case ESearch_Get_Keys:
+ {
+
+ LOGGER ( TXT ( "CWaitTimer::ESearch_Get_Keys" ) );
+ operationindex = ( FindOperationL ( iOpId, COssSendDataOperation::OperationId ) );
+
+ if ( operationindex != KErrNotFound )
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperationL found" ) );
+ iOperations[ operationindex ]->SetResponse ( rmsg ); //ownership of rmsg is transferred
+ iOperations[ operationindex ]->CompletedOperation ( KErrNone );
+ }
+ CleanupStack::Pop( rmsg );
+ LOGGER ( TXT ( "CWaitTimer::ESearch_Get_Keys end" ) );
+ break;
+ }
+ case ESearch_State_During :
+ {
+ LOGGER ( TXT ( "CWaitTimer::ESearch_State_During" ) );
+ iSearchElements.ResetAndDestroy();
+ CleanupStack::PopAndDestroy( rmsg );
+ LOGGER ( TXT ( "CWaitTimer::ESearch_State_During end" ) );
+ break;
+ }
+ case EUpdateOwnAvtar :
+ {
+ LOGGER ( TXT ( "CWaitTimer::EUpdateOwnAvtar" ) );
+ operationindex = ( FindOperationL ( iOpId, COssSendDataOperation::OperationId ) );
+
+ if ( operationindex != KErrNotFound )
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperationL found" ) );
+
+ iOperations[ operationindex ]->SetResponse ( rmsg ); //ownership of rmsg is transferred
+ iOperations[ operationindex ]->CompletedOperation ( KErrNone );
+ }
+ CleanupStack::Pop( rmsg );
+ break;
+ }
+ default:
+ {
+ LOGGER ( TXT ( "CWaitTimer::default start" ) );
+ operationindex = ( FindOperationL ( iOpId, COssSendDataOperation::OperationId ) );
+
+ if ( operationindex != KErrNotFound )
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperationL found" ) );
+
+ iOperations[ operationindex ]->SetResponse ( rmsg ); //ownership of rmsg is transferred
+ iOperations[ operationindex ]->CompletedOperation ( KErrNone );
+ }
+ CleanupStack::Pop( rmsg );
+ LOGGER ( TXT ( "CWaitTimer::default end" ) );
+ break;
+ }
+ }
+
+ TInt pendingMsgCount = MsgQCheck(RESPONSE_QUEUE, &err );
+ if( pendingMsgCount > 0)
+ {
+ msgreadcontinue = ETrue;
+ }
+ else
+ {
+ msgreadcontinue = EFalse;
+ }
+ LOGGER ( TXT ( "CWaitTimer::pendingMsgCount is %d" ), pendingMsgCount );
+ }
+ }while( msgreadcontinue );
+ /*
+ // there is no pending message in msgqueue,
+ // set active and subscribe for incomming queue message
+ iProperty.Subscribe(iStatus);
+ SetActive(); // Tell scheduler a request is active */
+
+ iTimer.After( iStatus, KTimerInterval );
+ SetActive();
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::PendingPresenceContactsL()
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::PendingPresenceContactsL(char* aRmessage)
+ {
+ char* prmsg = NULL;
+ prmsg = aRmessage;
+ HBufC16 *contactName = NULL;
+ HBufC* name = NULL;
+ int len = 0;
+ if( aRmessage )
+ {
+ prmsg += sizeof ( message_hdr_resp );
+ MPresenceBuddyInfo2* buddyPresInfo = MPresenceBuddyInfo2::NewLC();
+
+ MPresenceCacheWriter2* presenceCacheWriter = MPresenceCacheWriter2::CreateWriterL();
+ CleanupDeletePushL(presenceCacheWriter);
+ while(1)
+ {
+ len = strlen(prmsg) + 1;
+ if (1 == len)
+ {
+ break;
+ }
+ char* contact = prmsg;
+ prmsg += len;
+
+ contactName = OssProtocolAdapUtils::ConvertCharToTUint16LC( contact );
+ LOGGER ( TXT ( "CWaitTimer::PendingPresenceContacts:ContactName:%S " ), contactName );
+
+ // contacts.AppendL(contactName);
+ name = HBufC::NewLC( contactName->Length() + iConnMan.ServiceName().Length() + KColon().Length() );
+ TPtr namePtr( name->Des() );
+ namePtr.Zero();
+ namePtr.Append(iConnMan.ServiceName() ); // prepend service name
+ namePtr.Append(KColon);
+ namePtr.Append(contactName->Des() );
+ buddyPresInfo->SetIdentityL(namePtr);
+ LOGGER ( TXT ( "CPresenceNotificationHandler::ProcessIncomingDataL :ContactName:%S " ), contactName );
+
+ buddyPresInfo->SetAnyFieldL(KExtensionKey,KPendingRequestExtensionValue());
+ CleanupStack::PopAndDestroy(2);//name,contactName
+ name = NULL;
+ contactName = NULL;
+ // Writing into Presence Cache
+ TInt cacheerror = presenceCacheWriter->WritePresenceL(buddyPresInfo);
+ User::LeaveIfError ( cacheerror);
+
+ }
+ CleanupStack::PopAndDestroy(2);//presenceCacheWriter,buddyPresInfo
+
+ }
+ }
+// -----------------------------------------------------------------------------
+// CWaitTimer::ResponseL()
+// -----------------------------------------------------------------------------
+//
+
+char* CWaitTimer::ResponseL ( TInt aTransId )
+ {
+
+ if ( aTransId == 0 ) // for contact list
+ {
+ if ( iIncomingData.Count() == 0 )
+ {
+ User::Leave ( KErrNotFound );
+ }
+
+ // take first one from the array
+ char* buff = iIncomingData[ 0 ];
+
+ iIncomingData.Remove ( 0 );
+ iIncomingData.Compress();
+ return buff;
+ }
+
+ if ( aTransId == 1 ) //for receive message
+ {
+ if ( iIncomingMsg.Count() == 0 )
+ {
+ User::Leave ( KErrNotFound );
+ }
+
+ // take first one from the array
+ char* buff = iIncomingMsg[ 0 ];
+
+ iIncomingMsg.Remove ( 0 );
+
+ return buff;
+ }
+ if ( aTransId == 2 ) //for presence notifications
+ {
+ TInt pCount = iIncomingPres.Count();
+
+ if ( pCount == 0 )
+ {
+ User::Leave ( KErrNotFound );
+ }
+
+ // take first one from the array
+ char* buff = iIncomingPres[ pCount-1 ];
+
+ iIncomingPres.Remove ( pCount-1 );
+ iIncomingPres.Compress();
+ return buff;
+ }
+ if ( aTransId == 3 ) //for send error
+ {
+ if ( iIncomingServerError.Count() == 0 )
+ {
+ User::Leave ( KErrNotFound );
+ }
+
+ // take first one from the array
+ char* buff = iIncomingServerError[ 0 ];
+
+ iIncomingServerError.Remove ( 0 );
+
+ return buff;
+ }
+ if ( aTransId == 4 ) //for Add notifications
+ {
+ if ( iAddNotification.Count() == 0 )
+ {
+ User::Leave ( KErrNotFound );
+ }
+
+ // take first one from the array
+ char* buff = iAddNotification[ 0 ];
+
+ iAddNotification.Remove ( 0 );
+
+ return buff;
+ }
+ if( aTransId == 5 ) // search results
+ {
+ // take first one from the array
+ char* buff=NULL;
+
+ if ( iSearchElements.Count() != 0 )
+ {
+ buff = iSearchElements[ 0 ];
+ iSearchElements.Remove ( 0 );
+ iSearchElements.Compress();
+ }
+ else
+ {
+ TInt x ( FindOperationL ( 6, COssSendDataOperation::OperationId ) );
+ if( x != -1)
+ { // is operation completed?
+ TRequestStatus* status = iOperations[ x ]->Status();
+
+ if ( status && ( *status == KRequestPending ) )
+ {
+ User::Leave ( KErrNotReady );
+ }
+ delete iOperations[ x ];
+ iOperations.Remove ( x );
+ }
+
+ }
+
+ return buff; // return the buffer
+ }
+ if ( aTransId == 200 ) //for contact sync
+ {
+ if ( iContactChangeList.Count() == 0 )
+ {
+ User::Leave ( KErrNotFound );
+ }
+
+ // take first one from the array
+ char* buff = iContactChangeList[ 0 ];
+
+ iContactChangeList.Remove ( 0 );
+ iContactChangeList.Compress();
+ return buff;
+ }
+ // try to find operation
+ TInt x ( FindOperationL ( aTransId, COssSendDataOperation::OperationId ) );
+
+ // is operation completed?
+ TRequestStatus* status = iOperations[ x ]->Status();
+
+ if ( status && ( *status == KRequestPending ) )
+ {
+ User::Leave ( KErrNotReady );
+ }
+
+ char* buff = iOperations[ x ]->Response();
+
+ delete iOperations[ x ];
+ iOperations.Remove ( x );
+ return buff;
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::RunError()
+// -----------------------------------------------------------------------------
+//
+
+TInt CWaitTimer::RunError ( TInt aError )
+ {
+ return aError;
+ }
+
+// =============================================================================
+// =============== New private Functions of the base class =====================
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::FindOperation()
+// Find operation in array
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::FindOperation (
+ TInt aOpId,
+ TInt ( COssSendDataOperation:: *aIdFunc ) () const ) const
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperation Start" ) );
+ TInt count ( iOperations.Count() );
+
+ for ( TInt x ( 0 ) ; x < count ; ++x )
+ {
+ if ( aOpId == ( ( *iOperations[ x ] ).*aIdFunc ) () )
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperation Returns %d" ), x );
+ return x;
+ }
+ }
+
+ LOGGER ( TXT ( "CWaitTimer::FindOperation End" ) );
+
+ return KErrNotFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::FindOperationL()
+// Find operation in array, leave if not found
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CWaitTimer::FindOperationL (
+ TInt aOpId,
+ TInt ( COssSendDataOperation:: *aIdFunc ) () const ) const
+ {
+ LOGGER ( TXT ( "CWaitTimer::FindOperation Start" ) );
+ TInt x ( FindOperation ( aOpId, aIdFunc ) );
+
+ LOGGER ( TXT ( "CWaitTimer::FindOperation End Returns %d" ), x );
+
+ return x;
+ }
+
+// -----------------------------------------------------------------------------
+// CWaitTimer::IssueReleaseRequestL()
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CWaitTimer::IssueReleaseRequestL()
+ {
+ LOGGER ( TXT ( "CWaitTimer::IssueReleaseRequestL Start" ) );
+ int err = 0;
+ int timeout = NO_WAIT;
+ message_hdr_req *msgHdr = NULL;
+ msgHdr = ( message_hdr_req* ) User::AllocLC(sizeof ( message_hdr_req ));
+ memset ( msgHdr, '\0', sizeof ( message_hdr_req ) );
+ msgHdr->message_type = EKill_Process;
+
+ TInt nBytes = sizeof ( message_hdr_req );
+
+ MsgQCreate ( REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err );
+
+ MsgQSend ( REQUEST_QUEUE, ( char* ) msgHdr , nBytes, MSG_PRI_NORMAL, timeout, &err );
+
+ CleanupStack::PopAndDestroy ( msgHdr );
+
+ LOGGER ( TXT ( "CWaitTimer::IssueReleaseRequestL end" ) );
+
+ }
+// ---------------------------------------------------------------------------
+// CWaitTimer::IsServerDisconnect()
+// ---------------------------------------------------------------------------
+//
+TBool CWaitTimer::IsServerDisconnect()
+ {
+ return iServerDisconnected;
+ }
+// ---------------------------------------------------------------------------
+// CWaitTimer::IsFetchContactsCompleted()
+// ---------------------------------------------------------------------------
+//
+TBool CWaitTimer::IsFetchContactsCompleted()
+ {
+ if(iFetchingStep == EDataFetchComplete)
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+// End of file