/*

* 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 );