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

//

#include "CFAX32.H"

#include "dial.h"	                      // we no longer depend on DialStor, so must depend directly on Dial

#include "FAXLOG.H"

#include "faxsettings.h"

 #include <commsdattypesv1_1.h>

 #include <commsdatutils.h>

 #include <commsdat_partner.h>

 using namespace CommsDat;

TInt FaxClientThread (TAny * session);  // function declaration needed here

//TInt FaxConverterThread (TAny *);

//RSemaphore jerry;

/********************************************************************/

/********************************************************************/

CFaxTransfer::CFaxTransfer()

	: CBase()

	{}

EXPORT_C CFaxTransfer *CFaxTransfer::NewLC (const TFaxSettings & aFaxSettings)

/** Constructs a CFaxTransfer object, which offers the publicly exported 

Symbian OS Fax Client API. 

As is usual in Symbian OS, the only difference between this function and 

NewL() is that this variant pushes the object to the cleanup stack.

@param aFaxSettings  A reference to a TFaxSettings object which contains 

persistent information applicable to all fax sessions. 

@return  Pointer to the newly created object. 

@leave KErrNoMemory There is insufficient memory to perform the operation. 

@capability None

*/

   {

   CFaxTransfer *self = new (ELeave) CFaxTransfer;

   CleanupStack::PushL (self);

   self->ConstructL (aFaxSettings);

   return self;

   }

EXPORT_C CFaxTransfer *CFaxTransfer::NewL (const TFaxSettings & aFaxSettings)

/** Constructs a CFaxTransfer object, which offers the publicly exported 

Symbian OS Fax Client API.

@param aFaxSettings A reference to a TFaxSettings object, which

contains persistent information applicable to all fax sessions. 

@return A pointer to the newly created object. 

@leave KErrNoMemory There is insufficient memory to perform the operation. 

@capability None

*/

   {

   CFaxTransfer *self = NewLC (aFaxSettings);

   CleanupStack::Pop ();

   return self;

   }

/********************************************************************/

void CFaxTransfer::ConstructL (const TFaxSettings & aFaxSettings)

   {

   // we now copy the TFaxSettings passed to us - we then

   // validate the contents and fill in the DialStor bits.

   // if we don't know the modem class we find it our here

   iFaxSettings = aFaxSettings;

   CFaxSettings *currentsettings;

   currentsettings = CFaxSettings::NewL ();     // bug fix thanks to MartinA

   CleanupStack::PushL (currentsettings);       // currentsettings saved

   currentsettings->ValidateAndSetClassL (&iFaxSettings);       // since this could leave

   CleanupStack::PopAndDestroy ();      // currentsettings deleted

	//   if (((TFaxClass) iFaxSettings.iFaxClass != EClass1) &&

	//     ((TFaxClass) iFaxSettings.iFaxClass != EClass2) &&

	//       ((TFaxClass) iFaxSettings.iFaxClass != EClass2point0))

	//      User::Leave (KFaxCannotAutodetect);

   iFaxSessionSettings.iFaxClass = (TFaxClass) iFaxSettings.iFaxClass;

   iFaxSessionSettings.iFaxId.Copy (iFaxSettings.iFaxId);

   iFaxSessionSettings.iMaxSpeed = iFaxSettings.iMaxSpeed;

   iFaxSessionSettings.iMinSpeed = iFaxSettings.iMinSpeed;

   iFaxSessionSettings.iRxResolution = iFaxSettings.iPreferredResolution;

   iFaxSessionSettings.iRxCompression = iFaxSettings.iPreferredCompression;

   iFaxSessionSettings.iPreferredECM = iFaxSettings.iPreferredECM;

   iFaxSessionSettings.iFaxOnDemandDelay = iFaxSettings.iFaxOnDemandDelay;

   iSource = CFaxTransferSource::NewL ();

   }

/********************************************************************/

CFaxTransfer::~CFaxTransfer ()

/** Destructor

Frees all resources owned by the object, prior to its destruction. */

   {

   delete iSource;

   }

/********************************************************************/

// this function updates the TFaxTransferProgress structure for the

// caller. It should be prior to inspection.

EXPORT_C TInt CFaxTransfer::Progress ()

/** Causes ETel to update the fax progress information in RFax::TProgress.

It should be called prior to displaying the fax progress information.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. 

@capability None

*/

{

	if (iFaxStarted)

		{

		iFaxClientProgress=EProgressRxTx;

		return (iFax.GetProgress (iProgress));

		}

	if (iConverting)

		{

		iFaxClientProgress=EProgressConverting;

		//aProgress=EProgressPreparing;

		return (KErrNone);

		}

	//aProgress=EProgressInitialising;

	return (KErrNone);

}

/********************************************************************/

// this function tells faxtrans what phone number to dial

// obviously only useful in a dialling mode !

// the phone number is translated for the modem and service

// and location required using dialstor facilities if they are

// available - if not, the number is used in its raw state

//

// if use of a raw phonenumber is required then the inline function

// SetPhoneNumber should be called instead.

EXPORT_C void CFaxTransfer::SetPhoneNumberL (TDesC8 & aNumber)

/** Resolves a local telephone number into an international number by 

taking account of the current location and country.

The alternative SetPhoneNumber() should be used if the phone number 

must be used in its raw state. One of these functions must be called 

before CFaxTransfer::Start() when a fax is to be sent. 

This function may leave with KErrNoMemory if there is insufficient 

memory to perform the operation. The leave code is one of the system 

error codes: see system-wide error codes. 

The current location and country information is obtained from the 

location table in the communications database.

The resolved number is then set as the actual phone number to dial.

@param aNumber  Descriptor containing the phone number to be resolved. 

@capability WriteUserData

*/

	{

	SetPhoneNumber (aNumber);

	TBuf < KMaxDialString > rawPhoneNumber;

	rawPhoneNumber.Copy (aNumber);

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	// Read the currently selected connection preference and find preferred IAP

	TInt prefRank  = 1;

	CCDConnectionPrefsRecord *connectionPrefs =

		static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));

	CleanupStack::PushL(connectionPrefs);

	connectionPrefs->iRanking = prefRank;

	connectionPrefs->iDirection = ECommDbConnectionDirectionOutgoing;

	TBool error = connectionPrefs->FindL(*db);	

	// The following code is a temporary solution until an issue has been resolved in CommsDat

	// start

	CCDIAPRecord* tempPIapRecord =

		static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

	tempPIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);

	connectionPrefs->iDefaultIAP.iLinkedRecord = tempPIapRecord;

	CCDIAPRecord* pIapRecord = (CCDIAPRecord*)connectionPrefs->iDefaultIAP.iLinkedRecord;

	pIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);

	pIapRecord->LoadL(*db);

	CCDBearerRecordBase* tempBearerRecord =

		static_cast<CCDBearerRecordBase*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));

	tempBearerRecord->SetRecordId(pIapRecord->iBearer);

	pIapRecord->iBearer.iLinkedRecord = tempBearerRecord;

	CCDBearerRecordBase* pBearerRecord = (CCDBearerRecordBase*) pIapRecord->iBearer.iLinkedRecord;

	pBearerRecord->SetRecordId(pIapRecord->iBearer);

	pBearerRecord->LoadL(*db);

	// end

	TUint32 iapId = pBearerRecord->iRecordTag;

	CCDIAPRecord *iapRecord =

		static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

	CleanupStack::PushL(iapRecord);

	iapRecord->SetRecordId(iapId);

	iapRecord->LoadL(*db);

	// more temporary code

	// start	

	CCDBearerRecordBase* tempLocationRecord =

		static_cast<CCDBearerRecordBase*>(CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord));

	tempLocationRecord->SetRecordId(iapRecord->iLocation);

	iapRecord->iLocation.iLinkedRecord = tempLocationRecord;

	CCDLocationRecord* pLocationRecord = (CCDLocationRecord*)iapRecord->iLocation.iLinkedRecord;

	pLocationRecord->SetRecordId(iapRecord->iLocation);

	pLocationRecord->LoadL(*db);

	// end

	//CommsDat Migration: Would this be the correct way to check whether or not a linked record exists:

	if (pLocationRecord == NULL)	

		{

		iPhoneNumber.Copy(rawPhoneNumber);

		}

	else

		{

		TBuf<32> serviceType;

		serviceType.Copy(iapRecord->iServiceType);

		if (!serviceType.Compare(TBuf<32>(DIAL_OUT_ISP)))	// Chargecard only valid for dial out ISP

			{

			// Get service type id

			TUint32 serviceId = iapRecord->iService;

			CCDDialOutISPRecord *ispRecord =

				static_cast<CCDDialOutISPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdDialOutISPRecord));

			CleanupStack::PushL(ispRecord);

			ispRecord->SetRecordId(serviceId);

			ispRecord->LoadL(*db);

			TUint32 locationId = 0;

			TUint32 chargecardId = 0;

			TRAPD(err,CommsDatUtils::CCommsDatUtils::ResolvePhoneNumberL(rawPhoneNumber, iPhoneNumber, TParseMode(EForDialing), locationId, chargecardId));

			// if resolving the phone number fails, use the raw phone number

			if (err)

				{

				iPhoneNumber.Copy(rawPhoneNumber);

				}

			CleanupStack::PopAndDestroy(ispRecord);

			}

		else

			{

			iPhoneNumber.Copy(rawPhoneNumber);

			}

		}

	CleanupStack::PopAndDestroy(3); // db, connectionPrefs, iapRecord

	}

/********************************************************************/

// in order to cancel a fax session we set a cancel flag in the lowest

// level (CFaxModem) - if this has not yet been fully created then we set

// a flag in the next level up (CFaxModemDriver) instead, which is always

// going to be there as it is created via CFaxTransfer::ConstructL

//

// because of the way that the CFaxModem monitors its request flag

// we need to avoid multiple cancel requests, so only the first call to

// Cancel has any effect on it

EXPORT_C void CFaxTransfer::Cancel ()

/** Tells the fax engine to cancel the fax session at the first convenient 

opportunity.

The caller should wait for cancellation to complete, which will usually be 

signalled by the fax thread's TRequestStatus completing with a KFaxCancelRequested 

error code. After the fax thread completes, Stop() should be called in the 

normal way.

The function can be called at any time after the call to Start(). 

@capability None

*/

   {

   if ((iClientCancel == KRequestPending) || (iClientCancel == KErrNone))

      {

      TRequestStatus *cancelClient = &iClientCancel;

      iDriverThread.RequestComplete (cancelClient, KErrCancel);

      }

   }

/********************************************************************/

EXPORT_C TInt CFaxTransfer::Start (TRequestStatus & aThreadStat)

/**

Start fax sending or receiving session by launching a separate high priority thread.

A call to Start must be paired with a call to Stop as this is an EPOC32 requirement.

@param     aThreadStat  thread logon request status

@return    thread creation code

@capability NetworkServices

@capability ReadUserData

@capability WriteUserData

*/

   {

    // the heap and stack sizes set here (4K each) are pure guesswork

    // CFaxModemDriver has allocated heap space in the parent thread

    // for any objects it needs to create after this stage

    // stack sizes increased by 512K to allow etel to connect

   TInt state = KErrNone;

   TInt heapSize = 0x14000;

   TInt stackSize = 0x14000;

	__FLOG_FAXCLI(_L8(" "));

	__FLOG_FAXCLI(_L8("-------------------------- new log --------------------------"));

	__FLOG_FAXCLI(_L8("CFaxTransfer::Start, starting FaxClientThread"));

	__FLOG_FAXCLI(_L8(" "));

   state = iDriverThread.Create ((_L ("FaxClientThread")), FaxClientThread, stackSize, heapSize, heapSize, this, EOwnerThread);

   if (state)

      {

      state = KFaxThreadError;

      }

   else

      {

      aThreadStat = KRequestPending;

      if (iClientCancel != KErrCancel)

         iClientCancel = KRequestPending;

      iDriverThread.Logon (aThreadStat);

      iDriverThread.SetPriority (EPriorityRealTime);

      iDriverThread.Resume ();

      }

   return (state);

   }

/*********************************************************************/

EXPORT_C void CFaxTransfer::Stop ()

/** Kills the fax thread once it has completed. 

Fax threads do not kill themselves, so every successful call to CFaxTransfer::Start() 

must be paired with a call to CFaxTransfer::Stop(). 

@capability NetworkServices

@capability ReadUserData

@capability WriteUserData

*/

   {

   iDriverThread.Close ();

   }

/*********************************************************************/

// this is a utility function which is the entry to our thread

// it isn't part of any class, but we pass the address

// of our CFaxTransfer in so that we can check the

// session parameter and get back to the required function

//

// All possible leaves should be trapped as the return

// from this function is the TRequestStatus which the

// caller to CFaxTransfer::Start is waiting for.

TInt FaxClientThread (TAny * session)

   {

   // start of unecessary bureaucracy - error checking left out

/*#define CSY_NAME _L("ECUART")

#define LDD_NAME _L("ECOMM")

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#else

#define PDD_NAME _L("EUART1")

#endif*/

/*

   User::LoadPhysicalDevice (PDD_NAME);

   User::LoadLogicalDevice (LDD_NAME);*/

// jerry.CreateGlobal(_L("FaxCliSem"),0,EOwnerProcess);

   RCommServ server;

   // coverity[check_return]

   server.Connect ();

// end of unecessary bureaucracy

   TInt state;

   CTrapCleanup *cleanup = CTrapCleanup::New ();

// CFaxTransfer *faxsession = (CFaxTransfer *) session;

   CFaxTransfer *faxsession =reinterpret_cast<CFaxTransfer *>(session);

	__FLOG_FAXCLI(_L8("FaxClientThread entering..."));

   state = faxsession->iTelServer.Connect ();

   if (state == KErrNone)

   {

   TBuf<KCommsDbSvrMaxFieldLength> tsyName;

   TRAP(state,faxsession->GetPhoneModuleNameL(tsyName));

   if (state==KErrNone)

	{

      state = faxsession->iTelServer.LoadPhoneModule (tsyName);

      if (state == KErrNone)

         {

		 RTelServer::TPhoneInfo phoneInfo;

		 state = faxsession->GetPhoneInfoForTsy(tsyName,phoneInfo);

		 if (state == KErrNone)

			{

			__FLOG_FAXCLI(_L8("FaxClientThread iPhone.Open"));

			state = faxsession->iPhone.Open (faxsession->iTelServer, phoneInfo.iName);

            if (state == KErrNone)

				{

				__FLOG_FAXCLI(_L8("FaxClientThread iLine.Open"));

				state = faxsession->iLine.Open (faxsession->iPhone, _L ("Fax"));

				if (state == KErrNone)

					{

					//

					// If the call name has been provided, then open the

					// existing call, otherwise open a new call.

					//

					if (faxsession->iCallName.Length() == 0)

						{

						__FLOG_FAXCLI(_L8("FaxClientThread iCall.OpenNewCall"));

						state = faxsession->iCall.OpenNewCall (faxsession->iLine);

						}

					else

						{

						__FLOG_FAXCLI(_L8("FaxClientThread iCall.OpenExistingCall"));

						state = faxsession->iCall.OpenExistingCall(faxsession->iLine, faxsession->iCallName);

						}

					if (state == KErrNone)

						{

						faxsession->iSource->iPage = 0;

						if (faxsession->iMode & KFaxReceive)

							{

							faxsession->iFaxSessionSettings.iMode = RCall::EReceive;

							TRAP (state, faxsession->FaxReceiveL ());

							__FLOG_FAXCLI1(_L8("FaxClientThread FaxReceiveL exited state=%d"),state);

							faxsession->iSource->CloseFaxInStore ();

							}		

			            else

					        {

							faxsession->iFaxSessionSettings.iMode = RCall::ETransmit;

							TRAP (state, faxsession->FaxTransmitL ());

							faxsession->iSource->iInstream.Close ();

							}

	                    // we tidy up by deleting any objects created

						// (it does no harm if their pointers are already NULL)

						// and we close any streams (which also does no harm

						// if they have already been closed)

						faxsession->iFaxStarted = EFalse;

						faxsession->iFax.Close ();

						faxsession->iSource->CloseFaxStore ();

						delete faxsession->iSource->iWriteFaxFile;

						faxsession->iSource->iWriteFaxFile = NULL;

		                delete faxsession->iSource->iReadFaxFile;

						faxsession->iSource->iReadFaxFile = NULL;

						faxsession->iSource->iOutstream.Close ();

						faxsession->iSource->iInstream.Close ();

						RCall::TStatus callStatus;

						faxsession->iCall.GetStatus(callStatus);

						__FLOG_FAXCLI1(_L8("FaxClientThread callStatus=%d"),callStatus);

						if (callStatus!=RCall::EStatusIdle)

							faxsession->iCall.HangUp ();

						__FLOG_FAXCLI(_L8("FaxClientThread iCall.Close"));

						faxsession->iCall.Close ();

						}

					__FLOG_FAXCLI(_L8("FaxClientThread iLine.Close"));

					faxsession->iLine.Close ();

					}

				__FLOG_FAXCLI(_L8("FaxClientThread iPhone.Close"));

				faxsession->iPhone.Close ();

				}

			}

		faxsession->iTelServer.UnloadPhoneModule (tsyName);

		}

		}

    faxsession->iTelServer.Close ();

    }

   delete cleanup;

// intercept the etel wrong modem type error

   if (state == KErrEtelWrongModemType) state = KFaxErrWrongModemType;

   return (state);

   }

/*********************************************************************/

void CFaxTransfer::GetPhoneModuleNameL(TDes& aModuleName) const

	{

	// AnnW, 9/8/99 - This all assumes that we are taking the modem settings from the 

	// dial out IAP, which is fince for now, but may not be in the future?  This may also 

	// need modifying for Linda?

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

	CleanupStack::PushL(db);

	// Read the currently selected connection preference and find preferred IAP

	TInt prefRank  = 1;

	CCDConnectionPrefsRecord *connectionPrefs = 

		static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));

	CleanupStack::PushL(connectionPrefs);

	connectionPrefs->iRanking = prefRank;

	connectionPrefs->iDirection = ECommDbConnectionDirectionOutgoing;

	connectionPrefs->FindL(*db);

	// The following code is a temporary solution until an issue has been resolved in CommsDat