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

// CLtsyPhoneHandler

#include <ctsy/ltsy/cctsydispatchercallback.h>

#include <mmtsy_ipcdefs.h>

#include <etelmm.h>

#include <ctsy/ltsy/ltsylogger.h>

#include <ctsy/ltsy/mltsydispatchphoneinterface.h>

#include "cltsyphonehandler.h"

#include "ltsymacros.h"

#include "atgetmodemstatus.h"

#include "atgetnetworkregistrationstatus.h"

#include "atgetsimstatusready.h"

#include "atgetnetworkinfo.h"

#include "atgetsignalstrength.h"

#include "atgetbatteryinfo.h"

#include "atdetectnetwork.h"

#include "getphoneid.h"

#include "initializephone.h"

#include "mslogger.h"

#include "athangup.h"

#include "getoperatorname.h"

#include "atselectnetworkmode.h"

#include "atselectnetwork.h"

#include "atgetphonecellinfo.h"

#include "atgetcellinfo.h"

#include "atsetnotifycell.h"

#include "asynchelperrequest.h"

#include "atnetworkregstatuschange.h"

#include "atnotifycellinfo.h"

#include "notifybatteryandsignal.h"

#include "getfdnstatus.h"

#include "getcurrentnetworkinfo.h"

#include "atgetphonecellinfo.h"

CLtsyPhoneHandler::CLtsyPhoneHandler(

	CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)

	: iCtsyDispatcherCallback(aCtsyDispatcherCallback),iGloblePhone(aGloblePhone)

	{

	}

CLtsyPhoneHandler::~CLtsyPhoneHandler()

	{

	if(iAsyncHelperRequest)

		{

		delete iAsyncHelperRequest;

		iAsyncHelperRequest = NULL;

		}	

	if(iNetworkRegStatusChange)

		{

		delete iNetworkRegStatusChange;

		iNetworkRegStatusChange = NULL;

		}

	if(iNotifyCellInfo)

		{

		delete iNotifyCellInfo;

		iNotifyCellInfo = NULL;

		}

	if(iNotifyBatteryAndSignal)

		{

		delete iNotifyBatteryAndSignal;

		iNotifyBatteryAndSignal = NULL;

		}

	if(iInitializePhone)

		{

		delete iInitializePhone;

		iInitializePhone = NULL;

		}

	if(iATDetectNetwork)

		{

		delete iATDetectNetwork;

		iATDetectNetwork = NULL;

		}

	}

CLtsyPhoneHandler* CLtsyPhoneHandler::NewLC(

	CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)

	{

	TSYLOGENTRYEXIT;

	CLtsyPhoneHandler* self = new (ELeave) CLtsyPhoneHandler(aCtsyDispatcherCallback,aGloblePhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CLtsyPhoneHandler* CLtsyPhoneHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback,

		CGlobalPhonemanager* aGloblePhone)

	{

	TSYLOGENTRYEXIT;

	CLtsyPhoneHandler* self=

			CLtsyPhoneHandler::NewLC(aCtsyDispatcherCallback,aGloblePhone);

	CleanupStack::Pop(self);

	return self;

	}

void CLtsyPhoneHandler::ConstructL()

/**

 * Second phase constructor.

 */

	{

	TSYLOGENTRYEXIT;

	//for temp

	iNetworkRegStatusChange = CATNetworkRegStatusChange::NewL((*iGloblePhone), iCtsyDispatcherCallback);

	iAsyncHelperRequest = CAsyncHelperRequest::NewL((*iGloblePhone), iCtsyDispatcherCallback);

	iNotifyCellInfo = CATNotifyCellInfo::NewL((*iGloblePhone), iCtsyDispatcherCallback);

	iNotifyBatteryAndSignal = CNotifyBatteryAndSignal::NewL((*iGloblePhone), iCtsyDispatcherCallback);

	iInitializePhone = CInitializePhone::NewL(*iGloblePhone,

			                                  iCtsyDispatcherCallback,

			                                  *iNetworkRegStatusChange,

			                                  *iNotifyBatteryAndSignal);

	iATDetectNetwork  = CATDetectNetwork::NewL(*iGloblePhone,iCtsyDispatcherCallback);

	iATSelectNetwork  = CATSelectNetwork::NewL(*iGloblePhone,iCtsyDispatcherCallback);

	} // CLtsyPhoneHandler::ConstructL

TBool CLtsyPhoneHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)

/**

 * Returns whether a Dispatch Interface APi is supported or not.

 * 

 * @param aDispatchApiId Id of Dispatch interface being queried

 * @return indication whether interface is supported or not

 */

	{

	switch(aDispatchApiId)

		{

		// Insert ApiIds when support is provided in LTSY e.g.

		case KLtsyDispatchPhoneBootNotifyModemStatusReadyApiId: 

			return ETrue;

		case KLtsyDispatchPhoneBootNotifySimStatusReadyApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetFdnStatusApiId: 

			return ETrue; 

		case KLtsyDispatchPhoneGetHomeNetworkApiId: 

			return ETrue;	

		case KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId: 

			return ETrue;

		case KLtsyDispatchPhoneSimRefreshRegisterApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetServiceProviderNameApiId: 

			return ETrue; //Not finished

		case KLtsyDispatchPhoneGetPhoneIdApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetDetectedNetworksApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetDetectedNetworksCancelApiId: 

			return ETrue; //

		case KLtsyDispatchPhoneSelectNetworkApiId: 

			return ETrue;

		case KLtsyDispatchPhoneSelectNetworkCancelApiId: 

			return ETrue; //KErrNotSupported

		case KLtsyDispatchPhoneSetNetworkSelectionSettingApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetCurrentNetworkInfoApiId: 

			return ETrue; //Finished ?

		case KLtsyDispatchPhoneGetNetworkModeApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetNitzInfoApiId: 

			return ETrue; 

		case KLtsyDispatchPhoneGetSignalStrengthApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetBatteryInfoApiId: 

			return ETrue;

		case KLtsyDispatchPhoneNspsWakeupApiId: 

			return EFalse;

		case KLtsyDispatchPhoneSetSystemNetworkModeApiId: 

			return EFalse;

		case KLtsyDispatchPhoneGetCurrentSystemNetworkModesApiId: 

			return ETrue;

		case KLtsyDispatchPhoneResetNetServerApiId: 

			return EFalse;

		case KLtsyDispatchPhoneSetAlwaysOnModeApiId: 

			return EFalse;

		case KLtsyDispatchPhoneSetDriveModeApiId: 

			return EFalse;

		case KLtsyDispatchPhoneGetHspaStatusApiId: 

			return EFalse;

		case KLtsyDispatchPhoneSetHspaStatusApiId: 

			return EFalse;

		case KLtsyDispatchPhoneGetNetworkProviderNameApiId: 

			return ETrue;  

		case KLtsyDispatchPhoneGetOperatorNameApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetCellInfoApiId: 

			return ETrue;  

		case KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetPhoneCellInfoApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetUsimServiceSupportApiId: 

			return EFalse;

		case KLtsyDispatchPhoneGetCurrentActiveUsimApplicationApiId: 

			return EFalse;

		case KLtsyDispatchPhoneTerminateAllCallsApiId: 

			return ETrue;

		case KLtsyDispatchPhoneGetSystemNetworkBandApiId: 

			return EFalse;

		case KLtsyDispatchPhoneSetSystemNetworkBandApiId: 

			return EFalse;

		default:

			return EFalse;

		}

	}

void CLtsyPhoneHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup aIdGroup, TUint32& aIndIdBitMask)

/**

 * Returns the set of callback indicators that are supported.

 * 

* @param aIdGroup ID of group that is being queried e.g. aIdGroup=EIndIdGroup1.

* @param aIndIdBitMask [out] argument that should return a bitmask indicating which indicator callbacks are supported.

 */

	{

	//Create bitmask with bitset for each indicator ID that is supported. E.g.

	if(aIdGroup == EIndIdGroup1)

		aIndIdBitMask =   KLtsyDispatchPhoneNotifyNetworkModeChangeIndId |

						  KLtsyDispatchPhoneNotifyEgprsInfoChangeIndId |

						  KLtsyDispatchPhoneNotifySignalStrengthChangeIndId |

						  KLtsyDispatchPhoneNotifyNetworkRegistrationStatusChangeIndId |

						  KLtsyDispatchPhoneNotifyNitzInfoChangeIndId |

						  KLtsyDispatchPhoneNotifyBatteryInfoChangeIndId |

						  KLtsyDispatchPhoneNotifyCurrentNetworkChangeIndId |

						  KLtsyDispatchPhoneNotifyRfStatusChangeIndId |

						  KLtsyDispatchPhoneNotifyCellInfoChangeIndId ;

	else

		aIndIdBitMask = 0; //no indicators from other groups supported

	}

TInt CLtsyPhoneHandler::HandleGetFdnStatusReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetFdnStatusComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	TInt ret = KErrNotSupported;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == KErrNone)

		{

		CGetFdnStatus* GetFdnStatus  = CGetFdnStatus::NewL(*iGloblePhone,iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		iGloblePhone->SetActiveRequest(GetFdnStatus);

		GetFdnStatus->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleGetFdnStatusReqL

TInt CLtsyPhoneHandler::HandleGetNetworkRegistrationStatusReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetNetworkRegistrationStatusComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	TInt ret = KErrNone;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == EPhoneInitialising)

		{

		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId);

		iInitializePhone->ExecutePendingRequest();   

		ret = KErrNone;

		}

	else if(ret == KErrNone)

		{

		CATNetworkRegistration* atNetworkRegStatus  = CATNetworkRegistration::NewL(*iGloblePhone,

				                                                                   iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		iGloblePhone->SetActiveRequest(atNetworkRegStatus);

		atNetworkRegStatus->SetIpcRequestCompleteObserver(this);

		atNetworkRegStatus->SetIpcId(KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId);

		iNetworkRegStatusChange->Disable();

		atNetworkRegStatus->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleGetNetworkRegistrationStatusReqL

TInt CLtsyPhoneHandler::HandleGetHomeNetworkReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetHomeNetworkComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise. 

 */

	{

	TSYLOGENTRYEXIT;

	TInt ret = KErrNotSupported;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == EPhoneInitialising)

		{

		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetHomeNetworkApiId);

        iInitializePhone->ExecutePendingRequest();   

		ret = KErrNone;

		}

	else if(ret == KErrNone)

		{

		CATNetworkInfo* ATNetworkInfo  = CATNetworkInfo::NewL(*iGloblePhone,iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		iGloblePhone->SetActiveRequest(ATNetworkInfo);

		ATNetworkInfo->SetToGetHomeNwk();

		ATNetworkInfo->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleGetHomeNetworkReqL

TInt CLtsyPhoneHandler::HandleBootNotifyModemStatusReadyReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneBootNotifyModemStatusReadyComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise. 

 */

	{

	TSYLOGENTRYEXIT;

    // This function is the entry of phone bootup

	// Let's get the phone bootup

	TInt ret = KErrNone;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == EPhoneNotInitialised)

		{

		iGloblePhone->iPhoneStatus.iInitStatus = EPhoneInitialising;

		iGloblePhone->iEventSignalActive = ETrue;

		iInitializePhone->StartRequest();

		ret = KErrNone;

		}

	else if(ret == KErrNone)

		{

		CATGetModemStatus* ATGetModemStatus = CATGetModemStatus::NewL(*iGloblePhone,iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		iGloblePhone->SetActiveRequest(ATGetModemStatus);

		ATGetModemStatus->StartRequest();

		}	

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleBootNotifyModemStatusReadyReqL

TInt CLtsyPhoneHandler::HandleBootNotifySimStatusReadyReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneBootNotifySimStatusReadyComp()

 * 

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise. 

 */

	{

	TSYLOGENTRYEXIT;

	TInt ret = KErrNone;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == EPhoneInitialising)

		{

		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneBootNotifySimStatusReadyApiId);

        iInitializePhone->ExecutePendingRequest();   

		ret = KErrNone;

		}

	else if(ret == KErrNone)

		{

		CATSIMCard* ATSIMCard  = CATSIMCard::NewL(*iGloblePhone,iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		iGloblePhone->SetActiveRequest(ATSIMCard);

		ATSIMCard->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleBootNotifySimStatusReadyReqL

TInt CLtsyPhoneHandler::HandleSimRefreshRegisterReqL(TUint16 /*aFilesToRegister*/)

/**

 * @param aFilesToRegister  Bitmask containing list of files to register for refresh indications.

 * The list of possible files is specified in TCacheFileTypes.

 * 

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise. 

 */

	{

	TSYLOGENTRYEXIT;

	TInt ret = KErrNotSupported;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == EPhoneInitialising)

		{

		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneSimRefreshRegisterApiId);

        iInitializePhone->ExecutePendingRequest();   

        ret = KErrNone;

		}

	else if(ret == EPhoneInitialised)

		{

		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneSimRefreshRegisterApiId);

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleSimRefreshRegisterReqL

TInt CLtsyPhoneHandler::HandleGetServiceProviderNameReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetServiceProviderNameComp()

 *

 = * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	//TInt ret = KErrNotSupported;

	TInt ret = 0;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == KErrNone)

		{

		CGetOperatorNmae* GetOperatorName  = CGetOperatorNmae::NewL(*iGloblePhone,iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		GetOperatorName->SetRequestTypeL(KLtsyDispatchPhoneGetServiceProviderNameApiId);

		iGloblePhone->SetActiveRequest(GetOperatorName);

		GetOperatorName->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleGetServiceProviderNameReqL

TInt CLtsyPhoneHandler::HandleGetPhoneIdReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetPhoneIdComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	//TInt ret = KErrNotSupported;

	TInt ret = KErrNone;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == KErrNone)

		{

		CGetPhoneID* GetPhoneID  = CGetPhoneID::NewL(*iGloblePhone,iCtsyDispatcherCallback);

		iGloblePhone->iEventSignalActive = ETrue;

		iGloblePhone->SetActiveRequest(GetPhoneID);

		GetPhoneID->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleGetPhoneIdReqL

TInt CLtsyPhoneHandler::HandleGetDetectedNetworksReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	//TInt ret = KErrNotSupported;

	TInt ret = 0;

	ret = KErrNone;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if(ret == KErrNone)

		{

		iGloblePhone->iEventSignalActive = ETrue;

		iATDetectNetwork->StartRequest();

		}

	return TSYLOGSETEXITERR(ret);

	} // CLtsyPhoneHandler::HandleGetDetectedNetworksReqL

TInt CLtsyPhoneHandler::HandleGetDetectedNetworksCancelReqL()

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksCancelComp()

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	//TInt ret = KErrNotSupported;

	TInt ret = 0;

	ret = iGloblePhone->CheckGlobalPhoneStatus();

	if((ret == KErrInUse)&&(iATDetectNetwork->iCommandRunning))

		{

		if(iATDetectNetwork->iCommandCancel)

			{

			ret = KErrNotSupported;

			}

		else

			{

		    iATDetectNetwork->CancelCommand();

		    ret = KErrNone;

			}

		}

	else if(ret == KErrNone)

		{

		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneGetDetectedNetworksCancelApiId);

		}

	return TSYLOGSETEXITERR(ret);