// Copyright (c) 2001-2009 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:

//

//class include

#include <obexsendop.h>

//System includes

#include <msvids.h>

#include <msventry.h>	//CMsvServerEntry

#include <btmsgtypeuid.h>	//KUidMsgTypeBt

#include <irmsgtypeuid.h>	//KUidMsgTypeIr

#include <obexheaderlist.h>

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <apparc.h>		// CApaApplication::GenerateFileName

#include <apgcli.h>		// RApaLsSession   <-- data recognition.

//user includes

// Following are named KErrIrObexClientXXXXX because they are using the irobex.dll (which 

// should really be called obex.dll now that it supports more than IR)

const TInt KErrIrObexClientFirstPutFailed = -5510;

const TInt KErrIrObexClientSubsequentPutFailed = -5511;

const TInt KMaxBufSizeForRecognition = 1024;

EXPORT_C CObexServerSendOperation::CObexServerSendOperation(TUid aMsgTypeUid, CMsvServerEntry& aSendObj, TInt aConnectTimeoutMicroSeconds, TInt aPutTimeoutMicroSeconds, TRequestStatus& aObserverRequestStatus)

	:CActive(CActive::EPriorityHigh),

		iAsyncInit(EFalse),

		iObserverRequestStatus(aObserverRequestStatus),

		iMsvSendParent(aSendObj), 

		iConnectTimeout(aConnectTimeoutMicroSeconds),

		iPutTimeout(aPutTimeoutMicroSeconds),

		iCancelWithoutCompleting(EFalse),

		iProgressPckg(TObexMtmProgress()),

		iMtm(aMsgTypeUid)

/**

 * Constructor.

 *

 *  @param aMsgTypeUid UID of message type

 *  @param aSendObj Reference to the object to send.

 *  @param aConnectTimeoutMicroSeconds Timeout period for Connect operation in microseconds.

 *  @param aPutTimeoutMicroseconds Timeout period for Put operation in microseconds.

 *  @param aObserverRequestStatus TRequestStatus of owning active object.

 */

	{

	}

EXPORT_C CObexServerSendOperation::CObexServerSendOperation

                                   (TUid aMsgTypeUid, CMsvServerEntry& aSendObj,TInt aConnectTimeoutMicroSeconds,

                                    TInt aPutTimeoutMicroSeconds, TRequestStatus& aObserverRequestStatus,

                                    TBool aLastSendAttempt)

	:CActive(CActive::EPriorityHigh),

		iAsyncInit(EFalse),

		iLastSendAttempt(aLastSendAttempt),

		iObserverRequestStatus(aObserverRequestStatus),

		iMsvSendParent(aSendObj), 

		iConnectTimeout(aConnectTimeoutMicroSeconds),

		iPutTimeout(aPutTimeoutMicroSeconds),

		iCancelWithoutCompleting(EFalse),

		iProgressPckg(TObexMtmProgress()),

		iMtm(aMsgTypeUid)

/**

 * Constructor.

 *

 *  @param aMsgTypeUid UID of message type

 *  @param aSendObj Reference to the object to send.

 *  @param aConnectTimeoutMicroSeconds Timeout period for Connect operation in microseconds.

 *  @param aPutTimeoutMicroseconds Timeout period for Put operation in microseconds.

 *  @param aObserverRequestStatus TRequestStatus of owning active object.

 *  @param aLastSendAttempt TBool flag to check for second send attempt and also for sending headers.  EFalse sends full headers, ETrue only sends name and size

 */

	{

	}

EXPORT_C void CObexServerSendOperation::ConstructL(const TDesC* aConnectPassword)

/**

 * Second phase constructor. Sets up connection to the FileServer, initialises attachments or filename list then 

 * starts sending process by initialising.

 *

 * @param aConnectPassword Pointer to the password to be used for authentication.

 * @leave Leaves if insufficient memory.

 * @leave Leaves if cannot connect to FileServer.

 */

	{

	if (aConnectPassword->Length())

		{

		// take our own copy of the connection password

		HBufC* password=aConnectPassword->AllocL();

		iConnectPassword=password;

		}

	BuildSpecificConstructL();

	TRequestStatus* observerStatus = &iObserverRequestStatus;

	*observerStatus = KRequestPending;

	// If no attachments have been found, try using the Attachment API

		// Try Attachment API...

		CMsvStore* store = iMsvSendParent.ReadStoreL();

		CleanupStack::PushL(store);

		MMsvAttachmentManager& manager = store->AttachmentManagerL();

		iAttachmentEntryCount = manager.AttachmentCount();

		iNextAttachment = iAttachmentEntryCount-1;

		CleanupStack::PopAndDestroy(store);

	iTimeoutTimer = CObexSendOpTimeout::NewL(this);

	CActiveScheduler::Add(this);

	iStatus = KRequestPending;

	SetActive();

	if ( iAttachmentEntryCount > 0 )

		{

		// START SENDING

		iSendState = TObexMtmProgress::EInitialise;

		CompleteSelf(KErrNone);

		}

	else

		{

		//Nothing to send

		iSendState = TObexMtmProgress::ESendError;

		CompleteSelf(KErrNone);

		}

	}

EXPORT_C CObexServerSendOperation::~CObexServerSendOperation()

/**

 * Destructor. Cancel()s, deletes owned objects and Close()s the connection to the FileServer.

 */

	{

	Cancel();

	delete iObexClient;

	delete iObexObject;

	delete iTimeoutTimer;

	delete iConnectPassword;

	delete iMoveOperation;

	delete iMoveEntrySelection;

	BuildSpecificDestructor();

	}

void CObexServerSendOperation::TimeOut()

/**

 * Called when the current operation times out. Causes the current operation to be cancelled, then reactivates with

 * the appropriate error code (KErrIrObexClientNoDevicesFound or KErrIrObexClientPutPeerAborted).

 */

	{

	switch (iSendState)

		{

	case TObexMtmProgress::EInitialise:

	case TObexMtmProgress::EConnect:

	case TObexMtmProgress::EConnectAttemptComplete:

		ActivateRunLWithError(KErrIrObexClientNoDevicesFound);

		break;

	case TObexMtmProgress::ESendObject:		// Next RunL: start first send (not started sending yet)

	case TObexMtmProgress::ESendNextObject:	// Next RunL: start next send (still sending current object)

	case TObexMtmProgress::ESendComplete:		// Next RunL: nothing left to send (still sending current object)

	case TObexMtmProgress::EDisconnected:		// Trying to disconnect

		ActivateRunLWithError(KErrIrObexClientPutPeerAborted);

		break;

	default:

		Panic(EObexSendOperationUnexpectedTimeout);

		}

	}

void CObexServerSendOperation::ActivateRunLWithError(TInt aError)

/**

 * Cancels the current operation, then reactivates with the given error code.

 *

 * @param aError Error code to be passed to CompleteSelf.

 */

{

	ExplicitCancel();

	// Ensure RunL() is called to handle the error

	iSendState=TObexMtmProgress::ESendError;

	SetActive(); // Schedule so can CompleteObserverL() using given error code when RunL() is called again

	CompleteSelf(aError);

}

void CObexServerSendOperation::ExplicitCancel()

/**

 * Cancel any pending obex operation without completing the observer. 

 */

	{

	// Cancel any pending obex operation without completing the observer (the observer

	// owns this messaging operation, it's request status is iObserverRequestStatus)

	iCancelWithoutCompleting = ETrue; //this prevents the observer from completing when DoCancel() is called by the active object framework

	Cancel();

	iCancelWithoutCompleting = EFalse;

	}

EXPORT_C void CObexServerSendOperation::DoCancel()

/**

 * Cancels the current operation, deletes the client and Cancel()s the timeout timer. Only completes the observer

 * (by a call to CompleteObserverL) if an external entity (i.e. the owner) has called Cancel().

 * Otherwise the observer is not completed.

 */

	{

	// Have to delete the Obex client here or it mucks up the active scheduler. 

	// Abort doesn't cut the mustard.

	delete iObexClient;

	iObexClient=NULL;

	// Delete the Obex object as we may try to delete the message store entry

	// when we complete the observer and this will fail as the iObexObject has the

	// associated attachment file open.

	delete iObexObject;

	iObexObject = NULL;

	iTimeoutTimer->Cancel();

	if(!iCancelWithoutCompleting)

		{

		// We will only get here if an external entity has called Cancel() on us, only

		// the user (owner) of this active object will do this. In most cases this

		// will be the direct result of a user action, e.g. cancelling a dialog

		iSendState = TObexMtmProgress::EUserCancelled;

		CompleteObserverL(); // complete the observer which owns this messaging op

		}

	}

EXPORT_C TBool CObexServerSendOperation::CompletingObserver(TInt aErrorCode)

/**

* This is the default implementation that allows the server mtm to continue normally.

* Tells the derived class that the base class is about to complete the observer.

* This is the first thing called when CompleteObserverL is called.

* Since the behaviour of CompleteObserverL is to clean up the message that it was trying to send,

* this calls gives the derived class an opportunity to either stop this deletion or recover any information

* synchronously from the message.

* If the derived class has no need to use this functionality, the default implementation allows deletion.

* @param aErrorCode The last error code encountered during operation

* @return TBool True delete the message

* @return TBool False DO NOT delete the message

*/

	{

	(void)aErrorCode;

	return ETrue;

	}

void CObexServerSendOperation::CompleteObserverL() //CMsvOperation completed.

/**

 * Complete the observer, reporting any error via the progress. THIS METHOD MUST BE CALLED ONCE ONLY.

 *

 */

	{

	ProgressL();

	TObexMtmProgress& progress = iProgressPckg();

	// If the message should be deleted then do it here.

#ifndef MOVE_MESSAGE_TO_SENT

	// this call gives the derived class an opportunity to control this behaviour.

	// note that the error passed into this is the final one which the server mtm wants to

	// report to the UI - occasionally, this will be KErrNone when in fact an Obex error

	// did occur.  To make sure that we tell the derived class exactly what happened, we

	// pass the current state of the progress indicator out to it.

	if(CompletingObserver(progress.iError))

		SynchronousEntryDelete();

#endif

	TRequestStatus* status = &iObserverRequestStatus;

	User::RequestComplete(status, KErrNone);

	}

void CObexServerSendOperation::CompleteSelf(TInt aError)

/**

 * This causes this active object's request to complete which means

 * RunL() will be called again if we are active (immediately if there 

 * are no higher priority active objects in the active scheduler).

 *

 * @param aError Error to be passed forward to the next step of the state machine

 */

	{

	// This causes this active objects request to complete which means

	// RunL() will be called again if we are active (immediately if there 

	// are no higher priority active objects in the active scheduler).

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, aError);

	}

EXPORT_C void CObexServerSendOperation::RunL()

/**

 * Calls RealRunL(), and traps errors

 *

 * @leave Leaves with errors from RealRunL()

 */

	{

	TRAPD(err, RealRunL());

	if(err)

		{

		ExplicitCancel(); //don't complete the observer, just cancel sending activity

		// if RealRunL left in ESendError, sending it back would cause an endless loop!

		if (iSendState == TObexMtmProgress::ESendError)

			{

			iStatus = err;

			CompleteObserverL();

			// update iStatus "manually" so that it shows the REAL error (the error that 

			// made RealRunL leave, not the previous error that made it go to ESendError)

			// NOTE: if we left iStatus unchanged here, the observer would get the error

			// that caused the send operation to fail. If for any reason this were thought to be

			// better, just removing the following line would do.

			}

		else

			{

			iSendState = TObexMtmProgress::ESendError;

			// this is so that RunL-RealRunL are called immediately to handle the error

			// (the observer will be completed in RealRunL)

			SetActive();

			CompleteSelf(err);

			}

		User::Leave(err); // Allow system to display an error.

		}

	}

/**

 * This is not required to do anything in the base implementation.

 */

EXPORT_C void CObexServerSendOperation::SecondPhaseObexClientInitL()

	{

	}

EXPORT_C void CObexServerSendOperation::PreConnectOperations()

	{

	}

EXPORT_C void CObexServerSendOperation::PostConnectOperations()

	{

	}

EXPORT_C void CObexServerSendOperation::PreSendOperations()

	{

	}

EXPORT_C void CObexServerSendOperation::PostSendOperations()

	{

	}

TInt CObexServerSendOperation::SynchronousEntryDelete()

/**

 * Delete the outbox entry as operation has 'completed'.

 * Will be invisible&InPreparation anyway (MS delete will delete it the next 

 * time it starts).

 */

	{

	// Delete the outbox entry as operation has 'completed'.

	// Will be invisible&InPreparation anyway (MS delete will delete it the next 

	// time it starts).

	TInt err;

	const TMsvEntry& tMsvSentEntry = iMsvSendParent.Entry();

	TInt messageId = tMsvSentEntry.Id();

	err = iMsvSendParent.SetEntry(tMsvSentEntry.Parent());

	if (err == KErrNone)

		{

		err = iMsvSendParent.DeleteEntry(messageId);

		}

	return err;

 	}

void CObexServerSendOperation::InitialiseAttachmentL(CMsvServerEntry& aParent, TInt aWhichAttachment)

/**

 * Load an attachment into the obex sending buffer, and create a new Obex object of name TMsvEntry::iDetails.

 *

 * @param aParent Reference to CMsvServerEntry to be sent.

 * @param aWhichAttachment Zero-based index of attachment to send.

 * @leave KErrXXX system wide error codes

 */

	{

	// Load an attachment into the obex sending buffer

		// use the Attachment API to load the attachment files

		CMsvStore* store = aParent.ReadStoreL();

		CleanupStack::PushL(store);

		CMsvAttachment* attachment = store->AttachmentManagerL().GetAttachmentInfoL(aWhichAttachment);

		CleanupStack::PushL(attachment);

		LoadFileIntoObjectL(attachment->FilePath(), attachment->AttachmentName(), attachment->MimeType());

		// if any additional obex headers have been provided, set them

		// in the obex object

		TPtrC8 headerData;

		if( attachment->GetDesC8Attribute(KUidObexHeaders, headerData) == KErrNone )

			{

			// header data exists, try to build an obex header list

			CObexHeaderList* headerList = CObexHeaderList::NewLC();

			headerList->ImportFromAttachmentL(*attachment);

			headerList->AddHeadersToBaseObjectL(*iObexObject);

			CleanupStack::PopAndDestroy(headerList);

			}

		CleanupStack::PopAndDestroy(2, store); // attachment, store

	}

void CObexServerSendOperation::LoadFileIntoObjectL(const TDesC& aFileName, const TDesC& aObexName, const TDesC8& aMimeType)

	{

	// Load the file into our send data buffer.

	// Create a new Obex object from the file.

	// Check we actually have a file

	TEntry fileEntry;

	User::LeaveIfError( FileSession().Entry(aFileName, fileEntry) );

	if(fileEntry.IsDir())

		User::Leave(KErrNotSupported); //Can't send a directory.

	//Store the filename associated with the obex object

	iSendFile = aFileName;

	// Get the file length

	RFile file;

	User::LeaveIfError( file.Open(FileSession(), aFileName, EFileRead  | EFileShareReadersOnly) );

	CleanupClose<RFile>::PushL(file);

	TInt fileLength;

	User::LeaveIfError( file.Size(fileLength) );

	// To allow file type recognition, read the file into sendBody

	// only need the first KMaxBufSizeForRecognition bytes

	HBufC8* sendBody = HBufC8::NewLC(fileLength < KMaxBufSizeForRecognition ? fileLength : KMaxBufSizeForRecognition);

	TPtr8 sendBodyPtr = sendBody->Des();

	User::LeaveIfError( file.Read(sendBodyPtr) );

	CleanupStack::Pop(); //sendBodyPtr;

	CleanupStack::PopAndDestroy(); //file.Close();

	CleanupStack::PushL(sendBody);	//Must be a better way to do this!

	// Create an Obex object from the file.

	delete iObexObject;

	iObexObject=NULL;

	iObexObject = CObexFileObject::NewL(iSendFile);

	// Set the obex object name field 

	if(aObexName.Length()!=0)

		{

		iObexObject->SetNameL(aObexName); // Only *set* a header field if have some data, otherwise Obex will assert.

		}

	if( aMimeType.Length() > 0 )

		{

		iObexObject->SetTypeL(aMimeType);

		}

	else

		{

		// Attempt to recognise the datatype (MIME type) of the data in the send buffer

		// but only set obex object type field if we are pretty confident of the 

		// Recogniser's result

		RApaLsSession lsSess;

		if( lsSess.Connect() == KErrNone)

			{

			CleanupClosePushL(lsSess);

			TDataRecognitionResult result;

			User::LeaveIfError( lsSess.RecognizeData(aObexName, sendBodyPtr, result) );

			if (result.iConfidence>=CApaDataRecognizerType::EProbable)

				{

				iObexObject->SetTypeL(result.iDataType.Des8());	//only set a header field if have some data, otherwise Obex will assert.

				}

			CleanupStack::PopAndDestroy();	// lsSess;

			}

		}

	// Set obex object length field for benefit of remote device's UI

	iObexObject->SetLengthL(fileLength);

	// Set obex object time field

	TTime modifiedTime;

	FileSession().Modified(aFileName, modifiedTime);

	iObexObject->SetTimeL(modifiedTime);

	//Cleanup

	CleanupStack::PopAndDestroy();	//sendBody

	}

EXPORT_C void CObexServerSendOperation::GetUserPasswordL(const TDesC& /*aRelm*/)

/**

 * Called by the Obex Client when authentication is requested to pass the password back. If the password is invalid, this

 * call should succeed but the send operation as a whole will inevitably fail.

 *

 * @param aRelm ignored, but could be used to indicate which password to use.

 * @leave KErrXXX system wide error codes. Shouldn't leave just because the password is invalid.

 * @leave KErrIrObexConnectChallRejected, if password is found empty.

 */

	{

	//A "pusher" may not know in advance that the remote will issue an OBEX authentication challenge when connecting an OBEX session.  

	// As such if a password is not provided the MTM will return, KErrIrObexConnectChallRejected

	if(!iConnectPassword)

		{

		User::Leave(KErrIrObexConnectChallRejected);		

		}

	//Simply pass back the default user password

	iObexClient->UserPasswordL(*iConnectPassword);

	}

TBool CObexServerSendOperation::CheckStatusOfLastObject(TInt aStatus, TObexMtmProgress::TSendState aSendState)

/**

 * Checks the last object was sent correctly, and tries to action appropriate error feedback if not. Only to be called

 * from ESendObject/ESendNextObject or ESendComplete states.