// 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);
    }