diff -r 000000000000 -r e6b17d312c8b imservices/ossprotocoladaptation/src/waittimer.cpp --- /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 +#include "ossprotocloliterals.h" +#include "stringutils.h" +#include "ossadappanics.h" +#include +#include +#include +#include "ossprotocolpluginlogger.h" +#include +#include "mossprotocolconnectionmanager.h" +#include "cossprotocolconnectionmanager.h" +#include +#include +#include +#include +#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