// Get status text (e.g. "OK")
		TBuf<32> statusText;
		statusText.Copy(resp.StatusText().DesC());

		TBuf<256> text;
		_LIT(KHeaderReceived, "Header received. Status: %d %S");
		text.Format(KHeaderReceived, status, &statusText);
		iObserver.ClientEvent(text);
		}
		break;

	case THTTPEvent::EGotResponseBodyData:
		{
		// Part (or all) of response's body data received. Use 
		// aTransaction.Response().Body()->GetNextDataPart() to get the actual
		// body data.

		// Get the body data supplier
		MHTTPDataSupplier* body = aTransaction.Response().Body();
		TPtrC8 dataChunk;

		// GetNextDataPart() returns ETrue, if the received part is the last 
		// one.
		TBool isLast = body->GetNextDataPart(dataChunk);
		iObserver.ClientBodyReceived(dataChunk);

		TBuf<64> text;
		_LIT(KBodyPartReceived, "%d bytes received... ");
		text.Format(KBodyPartReceived, dataChunk.Length());
		iObserver.ClientEvent(text);
	
		// NOTE: isLast may not be ETrue even if last data part received.
		// (e.g. multipart response without content length field)
		// Use EResponseComplete to reliably determine when body is completely
		// received.
		if (isLast)
			{
			_LIT(KBodyReceived,"Body received");
			iObserver.ClientEvent(KBodyReceived);
			}

		// Always remember to release the body data.
		body->ReleaseData();
		}
		break;

	case THTTPEvent::EResponseComplete:
		{
		// Indicates that header & body of response is completely received.
		// No further action here needed.
		_LIT(KTransactionComplete, "Transaction Complete");
		iObserver.ClientEvent(KTransactionComplete);
		}
		break;

	case THTTPEvent::ESucceeded:
		{
		// Indicates that transaction succeeded. 
		_LIT(KTransactionSuccessful, "Transaction Successful");
		iObserver.ClientEvent(KTransactionSuccessful);

		// Transaction can be closed now. It's not needed anymore.
		aTransaction.Close();
		iRunning = EFalse;
		}
		break;

	case THTTPEvent::EFailed:
		{
		// Transaction completed with failure. 
		_LIT(KTransactionFailed, "Transaction Failed");
		iObserver.ClientEvent(KTransactionFailed);
		aTransaction.Close();
		iRunning = EFalse;
		}
		break;

	default:
		// There are more events in THTTPEvent, but they are not usually 
		// needed. However, event status smaller than zero should be handled 
		// correctly since it's error.
		{
		TBuf<64> text;
		if (aEvent.iStatus < 0)
			{
			_LIT(KErrorStr, "Error: %d");
			text.Format(KErrorStr, aEvent.iStatus);
			// Just close the transaction on errors
			aTransaction.Close();
			iRunning = EFalse;
			} else {
			// Other events are not errors (e.g. permanent and temporary
			// redirections)
			_LIT(KUnrecognisedEvent, "Unrecognised event: %d");
			text.Format(KUnrecognisedEvent, aEvent.iStatus);
			}
		iObserver.ClientEvent(text);
		}
		break;
	}
	}


// ----------------------------------------------------------------------------
// CClientEngine::MHFRunError()
//
// Inherited from MHTTPTransactionCallback
// Called by framework when *leave* occurs in handling of transaction event.
// These errors must be handled, or otherwise HTTP-CORE 6 panic is thrown.
// ----------------------------------------------------------------------------
TInt CClientEngine::MHFRunError(TInt aError, 
							  RHTTPTransaction /*aTransaction*/, 
							  const THTTPEvent& /*aEvent*/)
	{
	// Just notify about the error and return KErrNone.
	TBuf<64>	text;
	_LIT(KRunError, "MHFRunError: %d");
	text.Format(KRunError, aError);
	iObserver.ClientEvent(text);
	return KErrNone;
	}


// ----------------------------------------------------------------------------
// CClientEngine::GetNextDataPart()
//
// Inherited from MHTTPDataSupplier
// Called by framework when next part of the body is needed. In this example 
// this provides data for HTTP post.
// ----------------------------------------------------------------------------
TBool CClientEngine::GetNextDataPart(TPtrC8& aDataPart)
	{
	if(iPostData) 
		{
		// Provide pointer to next chunk of data (return ETrue, if last chunk)
		// Usually only one chunk is needed, but sending big file could require
		// loading the file in small parts.
		aDataPart.Set(iPostData->Des());
		}
	return ETrue;
	}


// ----------------------------------------------------------------------------
// CClientEngine::ReleaseData()
//
// Inherited from MHTTPDataSupplier
// Called by framework. Allows us to release resources needed for previous
// chunk. (e.g. free buffers)
// ----------------------------------------------------------------------------
void CClientEngine::ReleaseData()
	{
	// It's safe to delete iPostData now.
	delete iPostData;
	iPostData = NULL;

	// When sending data in multiple parts we must notify the framework here:
	// (the framework can call GetNextDataPart() when we notify it by calling
	//  NotifyNewRequestBodyPartL())
	/*
	// Not needed unless we send data in multiple parts
    TRAPD(err, iTransaction.NotifyNewRequestBodyPartL());
    if (err != KErrNone)
		Panic(EClientEngine);
	*/
	}


// ----------------------------------------------------------------------------
// CClientEngine::Reset()
//
// Inherited from MHTTPDataSupplier
// Called by framework to reset the data supplier. Indicates to the data 
// supplier that it should return to the first part of the data.	
// In practise an error has occured while sending data, and framework needs to 
// resend data.
// ----------------------------------------------------------------------------
TInt CClientEngine::Reset()
	{
	// Nothing needed since iPostData still exists and contains all the data. 
	// (If a file is used and read in small parts we should seek to beginning 
	// of file and provide the first chunk again in GetNextDataPart() )
	return KErrNone;
	}


// ----------------------------------------------------------------------------
// CClientEngine::OverallDataSize()
//
// Inherited from MHTTPDataSupplier
// Called by framework. We should return the expected size of data to be sent.
// If it's not know we can return KErrNotFound (it's allowed and does not cause
// problems, since HTTP protocol allows multipart bodys without exact content 
// length in header).
// ----------------------------------------------------------------------------
TInt CClientEngine::OverallDataSize()
	{
	if(iPostData)		
		return iPostData->Length();
	else
		return KErrNotFound ;
	}

// ----------------------------------------------------------------------------
// CClientEngine::GetCredentialsL()
//
// Inherited from MHTTPAuthenticationCallback
// Called by framework when we requested authenticated page and framework 
// needs to know username and password.
// ----------------------------------------------------------------------------
TBool CClientEngine::GetCredentialsL(const TUriC8& aURI,
								   RString aRealm, 
								   RStringF aAuthenticationType,
								   RString& aUsername, 
								   RString& aPassword) 
	{
	// aURI, aReal and aAuthenticationType are informational only. We only need 
	// to set aUsername and aPassword and return ETrue, if aUsername and 
	// aPassword are provided by user.

	// Informational only
	TBuf<128> authType;
	TBuf<128> uri;
	TBuf<256> authText;
	authType.Copy(aAuthenticationType.DesC());
	uri.Copy(aURI.UriDes());
	_LIT(KAuthRequired, "%S requires %S authentication.");
	authText.Format(KAuthRequired, &uri, &authType);
	_LIT(KAuthNote, "Authentication required.");
	CEikonEnv::Static()->InfoWinL(KAuthNote, authText);

	// Query user name and password
	TBuf<256> userName;
	TBuf<256> password;
	CAknMultiLineDataQueryDialog* dlg = 
		CAknMultiLineDataQueryDialog::NewL(userName, password);

	if (!dlg->ExecuteLD(R_DIALOG_USER_PASSWORD_QUERY))
		return EFalse; // No credentials given; must return EFalse

	// Set aUsername and aPassword
	TBuf8<256> temp;
	temp.Copy(userName);
	TRAPD(err, aUsername = aRealm.Pool().OpenStringL(temp));
	if (!err) 
		{
		temp.Copy(password);
		TRAP(err, aPassword = aRealm.Pool().OpenStringL(temp));
		if (!err) return ETrue;
		}

	// Return ETrue if user has given credentials (username and password), 
	// otherwise EFlase
	return EFalse;
	}