diff -r 000000000000 -r bde4ae8d615e os/mm/mmhais/dvbhreceiverhai/hai/dvbh/teststubs/dvbhreceiverinfo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmhais/dvbhreceiverhai/hai/dvbh/teststubs/dvbhreceiverinfo.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,502 @@ +// 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 + +/** +* 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(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(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 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 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 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(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(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(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(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(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(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 devinfoPckg(aDeviceInfo); + return RProperty::Get(KDvbhPropertyCategory, KMtvAccInfoKey, devinfoPckg); + }