// 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:

// GBATTERY.CPP

// Queries the ME battery. Retrieves charge level and battery status

// 

//

#include <et_phone.h>

#include "Mbattery.h"

#include "mSLOGGER.H"

#include "ATIO.H"

#include "Matstd.h"

CATGetBattery* CATGetBattery::NewL(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

	{

	CATGetBattery* battery = new(ELeave) CATGetBattery(aIo, aTelObject, aInit, aPhoneGlobals);

	CleanupStack::PushL(battery);

	battery->ConstructL();

	CleanupStack::Pop();

	return battery;

	}

CATGetBattery::CATGetBattery(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

: CATCommands(aIo,aTelObject,aInit,aPhoneGlobals),iPhoneGlobals(aPhoneGlobals)

{}

void CATGetBattery::ConstructL()

	{

	CATCommands::ConstructL();

	}

CATGetBattery::~CATGetBattery()

	{

	iIo->RemoveExpectStrings(this);

	iOKExpectString=NULL;

	iErrorExpectString=NULL;

	}

void CATGetBattery::Start(TTsyReqHandle aTsyReqHandle,TAny* aParams)

	{

	LOGTEXT(_L8("MMTsy:\tCATGetBattery:\tStarting ME Battery query."));

	iReqHandle = aTsyReqHandle;

	iBatteryInfo = (RMobilePhone::TMobilePhoneBatteryInfoV1*) aParams;

	iTxBuffer.Format(KGetBatteryChargeCommand);

	iIo->Write(this, iTxBuffer);

	iIo->SetTimeOut(this, 5000);

	iState=EATBatteryWaitForWriteComplete;

	}

void CATGetBattery::EventSignal(TEventSource aSource)

	{

	if (aSource==ETimeOutCompletion)

		{

		LOGTEXT(_L8("MMTsy:\tCATGetBattery:\tTimeout Error during battery-strength query"));

		RemoveStdExpectStrings();

		Complete(KErrTimedOut,aSource);

		return;

		}

	switch(iState)

		{

		case EATBatteryWaitForWriteComplete:

		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

			{

			iIo->WriteAndTimerCancel(this);

			StandardWriteCompletionHandler(aSource, 5);

			iState=EATBatteryReadComplete;

			}

		break;

		case EATBatteryReadComplete:

		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

			{	

			iIo->WriteAndTimerCancel(this);

			TInt ret(ValidateExpectString());

			RemoveStdExpectStrings();

			if (ret)

				{

				iBatteryInfo->iStatus = RMobilePhone::EPowerStatusUnknown;

				Complete(ret,aSource);

				return;

				}

			TRAP(ret,ParseBatteryResponseL());

			Complete(ret,aSource);

			}

		break;

		default:

		break;

		}//switch

	}//EventSignal

void CATGetBattery::Stop(TTsyReqHandle aTsyReqHandle)

	{

	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle, Panic(EIllegalTsyReqHandle));

	LOGTEXT2(_L8("CATGetBattery::Stop - Cancelling from state %d"), iState);

	if (iState==EATBatteryWaitForWriteComplete)

		{

		Complete(KErrCancel, EReadCompletion);

		}

	// else do nothing because we have already sent the AT command

	// or have not actually started doing anything!

	}

void CATGetBattery::Complete(TInt aError,TEventSource aSource)

	{

	iIo->WriteAndTimerCancel(this);

	iIo->RemoveExpectStrings(this);

	iOKExpectString = NULL;

	iErrorExpectString = NULL;

	CATCommands::Complete(aError,aSource);

	iTelObject->ReqCompleted(iReqHandle, aError);

	LOGTEXT2(_L8("MMTsy:CATGetBattery:\tCATGetBattery completed with error code : %d"), aError);

	iState = EATNotInProgress;

	}

void CATGetBattery::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)

	{

	if (iState!=EATNotInProgress)

		{

		iIo->WriteAndTimerCancel(this);

		iTelObject->ReqCompleted(iReqHandle, aStatus);

		iState = EATNotInProgress;

		}

	}

void CATGetBattery::ParseBatteryResponseL()

	{

	ParseBufferLC();

	CATParamListEntry* entry;

	TDblQueIter<CATParamListEntry> iter(iRxResults);

	TBool first = ETrue;

	TUint iCounter = 0;

	TInt ret;

	while (entry = iter++, entry != NULL)

		{

		if (first)

			{

			first = EFalse;

			while (entry->iResultPtr != KCBCResponseString)

				{

				entry->Deque();

				delete entry;

				entry = iter++;

				if (entry == NULL)

					{

					CleanupStack::PopAndDestroy();

					User::Leave(KErrNotFound);

					}

				} //while

			LOGTEXT(_L8("MMTsy:\tCATGetBattery:\tFound +CBC string!"));

			iCounter = 1;

			}

		else

			{

			TLex8 aLex((entry->iResultPtr).Ptr());

			if (iCounter == 1)

				{	

				TInt batteryStatus;

				ret = aLex.Val(batteryStatus);

				if (ret == KErrNone)

					// Have to convert the answer from the AT command format

					// to multimode representation.

					iBatteryInfo->iStatus = ConvertBatteryStatus(batteryStatus);

				}

			else if (iCounter == 2)

				ret = aLex.Val(iBatteryInfo->iChargeLevel);

			iCounter++;

			}//else

		entry->Deque();

		delete entry;

		}//while

	CleanupStack::PopAndDestroy();

	}//ParseBatteryResponseL

RMobilePhone::TMobilePhoneBatteryStatus CATGetBattery::ConvertBatteryStatus(TInt aBatteryStatus)

/** * Converts the batterey status from ETSI standard to multimode representation *

 * This method returns the proper multimode representation for the battery status. 

 * @param aBatteryStatus points to a value representing the battery status the ETSI way(0 - 3, ).

 * @return  Returns the battery status in multimode representation.

*/

	{

	switch (aBatteryStatus)

		{		

	case 0:

		return RMobilePhone::EPoweredByBattery; // equal to 1

	case 1:

		return RMobilePhone::EBatteryConnectedButExternallyPowered; // equal to 2

	case 2:

		return RMobilePhone::ENoBatteryConnected; // equal to 3

	case 3:

		return RMobilePhone::EPowerFault; // equal to 4

	default:

		return RMobilePhone::EPowerStatusUnknown; //equal to 0

		}

	}