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

// Example implementation of CDvbhReceiverInfo

// 

//

/**

 @file

 @internalComponent

 @prototype

*/

#include "dvbhreceiverinfo.h"

#include "dvbhreceiverinfoobserver.h"

#include "dvbhtypes.h"

#include "dvbhstubcommon.h"

#include <in_sock.h>

/**

* CDvbhReceiverInfo::CPrivateData contains the (implementation specific) private data of CDvbhReceiverInfo.

*/

NONSHARABLE_CLASS(CDvbhReceiverInfo::CPrivateData) : public CBase

    {

public:

	~CPrivateData();

public:

    // Internal observer classes to monitor for RProperty changes.

    CDvbhPropertyObserver*  iStatePropertyObserver;

    CDvbhPropertyObserver*	iSignalQualityPropertyObserver;

    CDvbhPropertyObserver*	iPlatformPropertyObserver;

    CDvbhPropertyObserver*	iNetworkTimePropertyObserver;

    CDvbhPropertyObserver*	iFrequencyPropertyObserver;

    CDvbhPropertyObserver*	iCellIdPropertyObserver;

    CDvbhPropertyObserver*	iNetworkIdPropertyObserver;

    CDvbhPropertyObserver*	iExtBatteryPropertyObserver;

    CDvbhPropertyObserver*	iExtConnectionPropertyObserver;

    CDvbhPropertyObserver*	iMtvAccConnectionPropertyObserver;

    CDvbhPropertyObserver*	iMtvAccAntennaConnectionPropertyObserver;

    // Wrappers around the external observer classes. To be called upon

    // when a property change is detected.

    TDvbhStateNotifier iStateNotifier;

	TDvbhSignalQualityNotifier iSignalQualityNotifier;

	TDvbhPlatformNotifier iPlatformNotifier;	

	TDvbhNetworkTimeNotifier iNetworkTimeNotifier;

	TDvbhFrequencyNotifier iFrequencyNotifier;

	TDvbhCellIdNotifier iCellIdNotifier;

	TDvbhNetworkIdNotifier iNetworkIdNotifier;	

    TDvbhExtBatteryStateNotifier iExtBatteryNotifier;

    TDvbhExtConnectionStateNotifier iExtConnectionNotifier;

    TMtvAccConnectionStateNotifier iMtvAccConnectionNotifier;

    TMtvAccAntennaConnectionStateNotifier iMtvAccAntennaConnectionNotifier;

    };

CDvbhReceiverInfo::CPrivateData::~CPrivateData()

	{

    delete iStatePropertyObserver;

    delete iSignalQualityPropertyObserver;

    delete iPlatformPropertyObserver;

    delete iNetworkTimePropertyObserver;

    delete iFrequencyPropertyObserver;

    delete iCellIdPropertyObserver;

    delete iNetworkIdPropertyObserver;

    delete iExtBatteryPropertyObserver;

    delete iExtConnectionPropertyObserver;

    delete iMtvAccConnectionPropertyObserver;

    delete iMtvAccAntennaConnectionPropertyObserver;

	}

/**

* Helper function to check if the current receiver state is EDvbhStateReceiving or EDvbhStateReady.

* If aCheckReceivingOnly is EFalse, then it returns KErrNone if the current state is either EDvbhStateReceiving or EDvbhStateReady.

* If aCheckReceivingOnly is ETrue, then will only return KErrNone if the current state is EDvbhStateReceiving.

*

* @param aCheckReceivingOnly ETrue if you only want to check for EDvbhStateReceiving, otherwise will check for EDvbhStateReceiving or EDvbhStateReady.

* @return KErrNone if the current state equals EDvbhStateReceiving or EDvbhStateReady, and aCheckReceivingOnly equals EFalse.  If aCheckReceivingOnly equals ETrue, the KErrNone only if current state is EDvbhStateReceiving.  Otherwise a system-wide error code.

*/

static TInt VerifyReadyOrReceiving(TBool aCheckReceivingOnly = EFalse)

	{

	TDvbhState state = EDvbhStateInactive;

	TInt result = CDvbhReceiverInfo::GetState(state);

	if (result != KErrNone)

		{

		return result;

		}		

	if (state != EDvbhStateReceiving && (state != EDvbhStateReady || aCheckReceivingOnly) )

		{

		return KErrNotReady;

		}	

	return KErrNone;

	}

/*

* Example implementation of CDvbhReceiverInfo

*/

EXPORT_C CDvbhReceiverInfo* CDvbhReceiverInfo::NewL()

	{

	CDvbhReceiverInfo* self = CDvbhReceiverInfo::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CDvbhReceiverInfo* CDvbhReceiverInfo::NewLC()

	{

	CDvbhReceiverInfo* self = new (ELeave) CDvbhReceiverInfo;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;	

	}

EXPORT_C CDvbhReceiverInfo::CDvbhReceiverInfo()

	{

	}

void CDvbhReceiverInfo::ConstructL()

	{

	iData = new (ELeave) CPrivateData;

	}

EXPORT_C CDvbhReceiverInfo::~CDvbhReceiverInfo()

	{

	delete iData;

	}

EXPORT_C TInt CDvbhReceiverInfo::GetState( TDvbhState& aState )

	{

	TInt state = 0;

	TInt result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyState, state);

	if (result == KErrNone)

		{

		aState = static_cast<TDvbhState>(state);

		}

	return result;	

	}

EXPORT_C TInt CDvbhReceiverInfo::SetStateObserver( MDvbhStateObserver& aObserver )

	{

	delete iData->iStatePropertyObserver;

	iData->iStatePropertyObserver = NULL;

	if ((iData->iStatePropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iStateNotifier.SetExternalObserver(&aObserver);

	return iData->iStatePropertyObserver->SetObserver(&iData->iStateNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetSignalQuality( TDvbhSignalQuality& aSignalQuality )

	{

	// API documentation states that this method may only be called if the receiver 

	// is in the Receiving state.

	TInt result = VerifyReadyOrReceiving(ETrue); //ETrue parameter means check for Receiving state only

	if (result != KErrNone)

		{

		return result;

		}

	// The receiver is in the correct state so we may proceed.

	TInt quality = 0;

	result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeySignalQuality, quality);

	if (result == KErrNone)

		{

		aSignalQuality = static_cast<TDvbhSignalQuality>(quality);

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetSignalQualityObserver( MDvbhSignalQualityObserver& aObserver )

	{

	delete iData->iSignalQualityPropertyObserver;

	iData->iSignalQualityPropertyObserver = NULL;

	if ((iData->iSignalQualityPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iSignalQualityNotifier.SetExternalObserver(&aObserver);

	return iData->iSignalQualityPropertyObserver->SetObserver(&iData->iSignalQualityNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetPlatform( TDvbhPlatform& aPlatform, TIp6Addr& aESGRoot )

	{

	// API documentation states that this method may only be called if the receiver 

	// is in the Ready or Receiving state.

	TInt result = VerifyReadyOrReceiving();

	if (result != KErrNone)

		{

		return result;

		}

	// The receiver is in the correct state so we may proceed.

	TDvbhPlatformProperty platform;		

	TPckg<TDvbhPlatformProperty> platformPckg(platform);

	result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyPlatform, platformPckg);

	if (result == KErrNone)

		{

		aPlatform.iId = platform.iPlatform.iId;

		aPlatform.iName = platform.iPlatform.iName;

		aESGRoot = platform.iEsgRoot;

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetPlatformObserver( MDvbhPlatformObserver& aObserver )

	{

	delete iData->iPlatformPropertyObserver;

	iData->iPlatformPropertyObserver = NULL;

	if ((iData->iPlatformPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iPlatformNotifier.SetExternalObserver(&aObserver);

	return iData->iPlatformPropertyObserver->SetObserver(&iData->iPlatformNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetNetworkTime( TTime& aNetworkTime, TBool& aValid )

	{		

	TDvbhNetworkTime networkTime;

	TPckg<TDvbhNetworkTime> timePckg(networkTime);

	TInt result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyNetworkTime, timePckg);

	if (result == KErrNone)

		{

		//API documentation states that KErrNotReady should be returned if a platform has

		//never been set on the receiver.

		if (networkTime.iPlatformId == KDvbhInvalidPlatform)

			{

			result = KErrNotReady;

			}

		else

			{

			//The platform is valid, but it might be old.  It will be old if there is no

			//current platform set, i.e. if the state is not Ready or Receiving.  Set the aValid

			//bool based on whether or not it the platform is old.

			if (VerifyReadyOrReceiving() == KErrNone)

				{

				aValid = ETrue;

				}

			else

				{

				aValid = EFalse;

				}

			//Finally, update the time

			aNetworkTime = networkTime.iNetworkTime;	

			}

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetNetworkTimeObserver( MDvbhNetworkTimeObserver& aObserver )

	{

	delete iData->iNetworkTimePropertyObserver;

	iData->iNetworkTimePropertyObserver = NULL;

	if ((iData->iNetworkTimePropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iNetworkTimeNotifier.SetExternalObserver(&aObserver);

	return iData->iNetworkTimePropertyObserver->SetObserver(&iData->iNetworkTimeNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetPerformanceData( TDvbhPerformanceData& aPerformanceData )

	{

	TPckg<TDvbhPerformanceData> performancePckg(aPerformanceData);

	return RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyPerformanceData, performancePckg);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetFrequency( TDvbhFrequency& aFrequency )

	{

	// API documentation states that this method may only be called if the receiver 

	// is in the Ready or Receiving state.

	TInt result = VerifyReadyOrReceiving();

	if (result != KErrNone)

		{

		return result;

		}

	// The receiver is in the correct state so we may proceed.	

	TInt frequency = 0;

	result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyFrequency, frequency);

	if (result == KErrNone)

		{

		aFrequency = static_cast<TDvbhFrequency>(frequency);

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetFrequencyObserver( MDvbhFrequencyObserver& aObserver )

	{

	delete iData->iFrequencyPropertyObserver;

	iData->iFrequencyPropertyObserver = NULL;

	if ((iData->iFrequencyPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iFrequencyNotifier.SetExternalObserver(&aObserver);

	return iData->iFrequencyPropertyObserver->SetObserver(&iData->iFrequencyNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetCellId( TDvbhCellId& aCellId )

	{

	// API documentation states that this method may only be called if the receiver 

	// is in the Ready or Receiving state.

	TInt result = VerifyReadyOrReceiving();

	if (result != KErrNone)

		{

		return result;

		}

	// The receiver is in the correct state so we may proceed.

	TInt cellId = 0;

	result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyCellId, cellId);

	if (result == KErrNone)

		{

		aCellId = static_cast<TDvbhCellId>(cellId);

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetCellIdObserver( MDvbhCellIdObserver& aObserver )

	{

	delete iData->iCellIdPropertyObserver;

	iData->iCellIdPropertyObserver = NULL;

	if ((iData->iCellIdPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iCellIdNotifier.SetExternalObserver(&aObserver);

	return iData->iCellIdPropertyObserver->SetObserver(&iData->iCellIdNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetNetworkId( TDvbhNetworkId& aNetworkId )

	{

	// API documentation states that this method may only be called if the receiver 

	// is in the Ready or Receiving state.

	TInt result = VerifyReadyOrReceiving();

	if (result != KErrNone)

		{

		return result;

		}

	// The receiver is in the correct state so we may proceed.

	TInt networkId = 0;

	result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyNetworkId, networkId);

	if (result == KErrNone)

		{

		aNetworkId = static_cast<TDvbhNetworkId>(networkId);

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetNetworkIdObserver( MDvbhNetworkIdObserver& aObserver )

	{

	delete iData->iNetworkIdPropertyObserver;

	iData->iNetworkIdPropertyObserver = NULL;

	if ((iData->iNetworkIdPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iNetworkIdNotifier.SetExternalObserver(&aObserver);

	return iData->iNetworkIdPropertyObserver->SetObserver(&iData->iNetworkIdNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetBatteryState( TDvbhExtBatteryState& aState )

	{

	// The receiver is in the correct state so we may proceed.

	TInt state = 0;

	TInt result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyExtBatteryState, state);

	if (result == KErrNone)

		{

		aState = static_cast<TDvbhExtBatteryState>(state);

		}

	return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetBatteryStateObserver( MDvbhExtBatteryStateObserver& aObserver )

	{

	delete iData->iExtBatteryPropertyObserver;

	iData->iExtBatteryPropertyObserver = NULL;

	if ((iData->iExtBatteryPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iExtBatteryNotifier.SetExternalObserver(&aObserver);

	return iData->iExtBatteryPropertyObserver->SetObserver(&iData->iExtBatteryNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetExtConnectionState( TDvbhExtConnectionState& aConnectionState, const TDvbhReceiverType& aReceiver )

	{

	// The receiver is in the correct state so we may proceed.

	TInt state = 0;

    TInt result = KErrNone;

    switch (aReceiver)

        {

        case EDvbhReceiverIntegrated:

            result = KErrArgument;

            break;

	    case EDvbhReceiverBluetooth:

            result = RProperty::Get(KDvbhPropertyCategory, KDvbhPropertyKeyExtConnectionState, state);

            break;

	    case EDvbhReceiverUsbAccessory:

            result = RProperty::Get(KDvbhPropertyCategory, KMtvAccAttachedKey, state);

            break;

        default:

            result = KErrArgument;

            break;

        }

    aConnectionState = EDvbhExtNotConnected;

    if (result == KErrNone)

		{

		aConnectionState = static_cast<TDvbhExtConnectionState>(state);

		}

	result = KErrNone;

    return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetExtConnectionStateObserver( MDvbhExtConnectionObserver& aObserver )

	{

	delete iData->iExtConnectionPropertyObserver;

	delete iData->iMtvAccConnectionPropertyObserver;

	iData->iExtConnectionPropertyObserver = NULL;

	iData->iMtvAccConnectionPropertyObserver = NULL;

	if ((iData->iExtConnectionPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	if ((iData->iMtvAccConnectionPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iExtConnectionNotifier.SetExternalObserver(&aObserver);

	TInt result = iData->iExtConnectionPropertyObserver->SetObserver(&iData->iExtConnectionNotifier);

	if (result == KErrNone)

	    {

        iData->iMtvAccConnectionNotifier.SetExternalObserver(&aObserver);

        result = iData->iMtvAccConnectionPropertyObserver->SetObserver(&iData->iMtvAccConnectionNotifier);

	    }

    return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::GetExtAntennaConnectionState( TDvbhExtAntennaConnectionState& aConnectionState, const TDvbhReceiverType& aReceiver )

	{

	// The receiver is in the correct state so we may proceed.

	TInt state = 0;

    TInt result = KErrNone;

    switch (aReceiver)

        {

        case EDvbhReceiverIntegrated:

            result = KErrArgument;

            break;

	    case EDvbhReceiverBluetooth:

            result = KErrArgument;

            break;

	    case EDvbhReceiverUsbAccessory:

            result = RProperty::Get(KDvbhPropertyCategory, KMtvAccAntennaKey, state);

            break;

        default:

            result = KErrArgument;

            break;

        }

    aConnectionState = EDvbhExtAntennaNotConnected;

    if (result == KErrNone)

		{

		aConnectionState = static_cast<TDvbhExtAntennaConnectionState>(state);

		}

	result = KErrNone;

    return result;

	}

EXPORT_C TInt CDvbhReceiverInfo::SetExtAntennaConnectionStateObserver( MDvbhExtAntennaConnectionObserver& aObserver )

	{

	delete iData->iMtvAccAntennaConnectionPropertyObserver;

	iData->iMtvAccAntennaConnectionPropertyObserver = NULL;

	if ((iData->iMtvAccAntennaConnectionPropertyObserver = new CDvbhPropertyObserver) == NULL)

		{

		return KErrNoMemory;

		}

	iData->iMtvAccAntennaConnectionNotifier.SetExternalObserver(&aObserver);

    return iData->iMtvAccAntennaConnectionPropertyObserver->SetObserver(&iData->iMtvAccAntennaConnectionNotifier);

	}

EXPORT_C TInt CDvbhReceiverInfo::GetExtDeviceInfo( TDvbhAccessoryInfo& aDeviceInfo, const TDvbhReceiverType& /*aReceiver*/ )

    {

	TPckg<TDvbhAccessoryInfo> devinfoPckg(aDeviceInfo);

	return RProperty::Get(KDvbhPropertyCategory, KMtvAccInfoKey, devinfoPckg);

    }