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

#include <e32std.h>

#include <bt_sock.h>

#include "BTGPSNokDeviceHandler.h"

#include "BtGpsPsyPrivateCRKeys.h"

#include "BTGPSConnectManager.h"

#include "BTGPSSettingManager.h"

#include "BTGPSDeviceManager.h"

#include "BTGPSNmeaParser.h"

#include "BTGPSMessageDef.h"

#include "BTGPSConstantsManager.h"

#include "BTGPSNokNightModeHandler.h"

#include "BTGPSPanic.h"

#include "BTGPSLogging.h"

#include "btgpsdevicelistmanager.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::NewL

// -----------------------------------------------------------------------------

CBTGPSNokDeviceHandler* CBTGPSNokDeviceHandler::NewL(

        CBTGPSConnectManager& aConnectManager,

        CBTGPSSettingManager& aSettingManager,

        CBTGPSConstantsManager& aConstantsManager,

        CBTGPSDeviceManager& aDeviceManager,

        CBTGPSDeviceListManager& aDeviceListManager)

    {

    CBTGPSNokDeviceHandler* self = new (ELeave) CBTGPSNokDeviceHandler(

        aConnectManager,

        aSettingManager,

        aConstantsManager,

        aDeviceManager,

        aDeviceListManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::~CBTGPSNokDeviceHandler

// -----------------------------------------------------------------------------

CBTGPSNokDeviceHandler::~CBTGPSNokDeviceHandler()

    {

    iConnectManager.RemoveMessageListener(*this);

    iSettingManager.RemoveListener(*this);

    iDeviceManager.RemoveListener(*this);

    delete iNightModeHandler;

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::ConstructL

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::ConstructL()

    {

    iConnectManager.AddMessageListenerL(*this);

    iSettingManager.AddListenerL(*this);

    iDeviceManager.AddListenerL(*this);

    iPreviousDeviceType = iDeviceManager.DeviceType();

    //Get Night Mode setting

    if(iSettingManager.GetNightModeSetting(

        (TBTGPSSettingsApi::TNightModeState &)iNightModeSetting) != KErrNone)

        {

        //In error case, turn night mode off

        iNightModeSetting = TBTGPSSettingsApi::ENightModeOff;

        }

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::CBTGPSNokDeviceHandler

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

CBTGPSNokDeviceHandler::CBTGPSNokDeviceHandler(

        CBTGPSConnectManager& aConnectManager,

        CBTGPSSettingManager& aSettingManager,

        CBTGPSConstantsManager& aConstantsManager,

        CBTGPSDeviceManager& aDeviceManager,

        CBTGPSDeviceListManager& aDeviceListManager)

    : iConnectManager(aConnectManager),

      iSettingManager(aSettingManager),

      iConstantsManager(aConstantsManager),

      iDeviceManager(aDeviceManager),

      iDeviceListManager(aDeviceListManager),

      iNightModeSetting(TBTGPSSettingsApi::ENightModeNA),

      iBattStatus(KErrNotFound),

      iExtPowerStatus(KErrNotFound),

      iExtAntennaStatus(KErrNotFound)

    {

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::HandleMessage

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::HandleMessage(const TBTGPSNmeaParser& aParser)

    {

    TRACESTRING("CBTGPSNokDeviceHandler::HandleMessage start...")

    TInt msgId = aParser.MessageId();

    TInt status(0);

    switch(msgId)

        {

        case ENmeaPNokPeriodicEvents:

            //Handler PNok STAT message

            HandleStatMessage(aParser);

            break;

        case ENmeaPNokNightMode:

            if(aParser.GetFieldData(ENmeaFieldPNOKNightModeStatus, status)==KErrNone)

                {

                CheckNightModeStatus(status);

                }

            break;

        case ENmeaPNokVersionInfo:

            UpdateDeviceVersion(aParser);

            break;

        default:

            //do nothing

            break;

        }

    TRACESTRING("CBTGPSNokDeviceHandler::HandleMessage end")

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::HandleNightModeChange

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::HandleNightModeChange( 

	        const TBTGPSSettingsApi::TNightModeState aSetting )

    {

    TRACESTRING("CBTGPSNokDeviceHandler::HandleNightModeChange start...")

    //Set night mode

    UpdateNightMode(aSetting);

    TRACESTRING("CBTGPSNokDeviceHandler::HandleNightModeChange end")

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::HandleStatMessage

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::HandleStatMessage(const TBTGPSNmeaParser& aParser)

    {

    TRACESTRING("CBTGPSNokDeviceHandler::HandleStatMessage start...")

    TInt battStatus(KErrNotFound);

    TInt battLevel(KErrNotFound);

    TInt extPowStatus(KErrNotFound);

    TInt extAntStatus(KErrNotFound);

    //Check battery status

    if(aParser.GetFieldData(ENmeaFieldPNOKBatteryStatus, battStatus)==KErrNone)

        {

        //Tuning is needed after testing

        if(battStatus != iBattStatus)

            {

            iBattStatus = battStatus;

            }

        }

    //Check ext power status

    if(aParser.GetFieldData(ENmeaFieldPNOKExtPowerStatus, extPowStatus)==KErrNone)

        {

        iExtPowerStatus = extPowStatus;

        }

    //Check ext antenna status

    if(aParser.GetFieldData(ENmeaFieldPNOKExtAntennaStatus, extAntStatus)==KErrNone)

        {

        iExtAntennaStatus = extAntStatus;

        }

    //Get battery level. Error ignored

    aParser.GetFieldData(ENmeaFieldPNOKBatteryLevel, battLevel);

    // Update device status to setting manager

    UpdateDeviceStatus(battLevel,battStatus, extPowStatus, extAntStatus);

    TRACESTRING("CBTGPSNokDeviceHandler::HandleStatMessage end")

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::UpdateDeviceVersion

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::UpdateDeviceVersion(const TBTGPSNmeaParser& aParser)

    {

    TPtrC8 id;

    TPtrC8 btHwVersion;

    TPtrC8 btSwVersion;

    TPtrC8 gpsHwVersion;

    TPtrC8 gpsSwVersion;

    //all errors are ignored

    aParser.GetFieldBlock(ENmeaFieldPNOKProductID, id);

    aParser.GetFieldBlock(ENmeaFieldPNOKBTHWVersionNumber, btHwVersion);

    aParser.GetFieldBlock(ENmeaFieldPNOKBTSWVersionNumber, btSwVersion);

    aParser.GetFieldBlock(ENmeaFieldPNOKGPSHWVersionNumber, gpsHwVersion);

    aParser.GetFieldBlock(ENmeaFieldPNOKGPSSWVersionNumber, gpsSwVersion);

    //Update settings in setting manager. Error ignored

    iSettingManager.UpdateVersions(

        id,

        btHwVersion,

        btSwVersion,

        gpsHwVersion,

        gpsSwVersion);

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::UpdateDeviceStatus

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::UpdateDeviceStatus(

            TInt aBattLevel,

            TInt aBattStatus,

            TInt aExtPowStatus,

            TInt aExtAntStatus)

    {

    //Set batt level

    TInt battLevel(0);

    if(aBattLevel!=KErrNotFound)

        {

        battLevel = aBattLevel;

        }

    //Set batt status

    TBTGPSBatteryState battState(EBatteryStateNA);

    switch(aBattStatus)

        {

        case KPNOKStatBattNormal:

            battState = EBatteryStateNormal;

            break;

        case KPNOKStatBattFull:

            battState = EBatteryStateFull;

            break;

        case KPNOKStatBattLow:

            battState = EBatteryStateLow;

            break;

        default:

            //do nothing

            break;

        }

    //Set ext power state

    TBTGPSExtPowerState extPowState(EExtPowerNA);

    switch (aExtPowStatus)

        {

        case KPNOKStatExtPowerConnected:

            extPowState = EExtPowerOn;

            break;

        case KPNOKStatExtPowerNotConnected:

            extPowState = EExtPowerOff;

            break;

        default: 

            //do nothing

            break;

        }

    //Set ext antenna state

    TBTGPSExtAntennaState extAntState(EExtAntennaNA);

    switch(aExtAntStatus)

        {

        case KPNOKStatExtAntennaNotConnected:

            extAntState = EExtAntennaOff;

            break;

        case KPNOKStatExtAntennaConnected:

            extAntState = EExtAntennaOn;

            break;

        default:

            //do nothing

            break;

        }

    //Set device status to setting manager. Error is ignored

    iSettingManager.UpdateDeviceStatus(

        battLevel,

        extPowState,

        extAntState,

        battState);

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::CheckNightModeStatus

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::CheckNightModeStatus(TInt aStatus)

    {

    if( iNightModeSetting == TBTGPSSettingsApi::ENightModeOn && 

            aStatus == KPNOKNightNightModeOn ||

        iNightModeSetting == TBTGPSSettingsApi::ENightModeOff && 

            aStatus == KPNOKNightNightModeOff)

        {

        //Correctly set

        delete iNightModeHandler;

        iNightModeHandler = NULL;

        }

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::UpdateNightMode

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::UpdateNightMode(

        TBTGPSSettingsApi::TNightModeState aSetting)

    {

    if(iDeviceManager.DeviceType()!=EBTDeviceTypeNokGps)

        {

        return;

        }

    delete iNightModeHandler;

    iNightModeHandler = NULL;

    if(aSetting != TBTGPSSettingsApi::ENightModeNA)

        {

        //ignore error if night mode can't be set

        TInt ignore(KErrNone);

        TRAP(ignore,

            iNightModeHandler = CBTGPSNokNightModeHandler::NewL(

                iConnectManager,

                aSetting));

        }

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::BTDeviceStatusChanged

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::BTDeviceStatusChanged(

            TInt aConnectStatus, 

            TInt aDeviceType,

            TInt /*aErr*/)

    {

    //Update night mode setting

    if(aConnectStatus==EBTDeviceConnected && aDeviceType ==EBTDeviceTypeNokGps)

        {

        //Set night mode

        TBTGPSSettingsApi::TNightModeState setting;

        if(iSettingManager.GetNightModeSetting(setting) == KErrNone)

            {

            UpdateNightMode(setting);

            }

        }

    else

        {

        //Cancel night mode setting

        delete iNightModeHandler;

        iNightModeHandler = NULL;

        }

    //Update PSY state in setting

    UpdatePsyState(aConnectStatus, aDeviceType);

    //Update connected device info in setting

    UpdateBtDeviceInfo(aConnectStatus, aDeviceType);

    //Update previous bt device type

    iPreviousDeviceType = aDeviceType;

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::UpdatePsyState

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::UpdatePsyState(

            TInt aConnectStatus, 

            TInt aDeviceType)

    {

    TBTGPSPSYState psyState(EPSYLoaded);

    switch(aConnectStatus)

        {

        case EBTDeviceDisconnected:

            if(aDeviceType==EBTDeviceTypeNonNokGps || 

                aDeviceType==EBTDeviceTypeNokGps)

                {

                psyState = EPSYInStandBy;

                }

            break;

        case EBTDeviceConnected:

            if(aDeviceType == EBTDeviceTypeNonNokGps)

                {

                psyState = EPSYLoadedAndPNOKNotSupportedBTGPSUsed;

                }

            else if(aDeviceType == EBTDeviceTypeNokGps)

                {

                psyState = EPSYLoadedAndPNOKSupportedBTGPSUsed;

                }

            else

                {

                //do nothing

                }

            break;

        case EBTDeviceConnecting:

        case EBTDeviceConnectError:

        default:

            //do nothing

            break;

        }

    //Update to setting manager

    iSettingManager.UpdatePsyState(psyState);

    }

// -----------------------------------------------------------------------------

// CBTGPSNokDeviceHandler::UpdateBtDeviceInfo

// -----------------------------------------------------------------------------

void CBTGPSNokDeviceHandler::UpdateBtDeviceInfo(

            TInt aConnectStatus, 

            TInt aDeviceType)

    {

    //Update bt device info when device type is changed from unkown or not GPS to 

    //NokGps or NonNokGps

    if(aConnectStatus == EBTDeviceConnected &&

        aDeviceType != iPreviousDeviceType && 

        (aDeviceType == EBTDeviceTypeNonNokGps ||

         aDeviceType == EBTDeviceTypeNokGps))

        {

        //Get bt sock address from device manager

        TBTSockAddr btSockAddr;

        iDeviceManager.BtSockAddr(btSockAddr);

#ifdef SYMBIAN_LOCATION_BTGPSCONFIG

        iDeviceListManager.SetDeviceInfo(aDeviceType, btSockAddr);

#else

        //Determine if the device is valid

        TInt valid = (aDeviceType==EBTDeviceTypeNonNokGps)?

            TBTGPSSettingsApi::EBtDeviceNonNokGps : TBTGPSSettingsApi::EBtDeviceNokGps;

        //Update device info in setting manager

        iSettingManager.UpdateBTDeviceInfo(valid, btSockAddr);

#endif

        }

#ifdef SYMBIAN_LOCATION_BTGPSCONFIG

	else if(aConnectStatus == EBTDeviceConnected)

		{

		//Device address and type has not changed,, but it needs to be moved to the top of the list

		TBTSockAddr btSockAddr;

    	iDeviceManager.BtSockAddr(btSockAddr);

    	iDeviceListManager.SetDeviceInfo(aDeviceType, btSockAddr);

		}

#endif		

    }

//  End of File