--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/sensor/src.s60/cnetworkfieldintensitysensor.cpp	Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,350 @@
+/*
+* Copyright (c) 2008 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:  Network field intensity sensor implementation
+*
+*/
+
+#include <etel3rdparty.h>
+#include <e32math.h>
+#include "cnetworkfieldintensitysensor.h"
+#include "sensorlistener.h"
+#include "csensorproperties.h"
+#include "logger.h"
+
+const TInt KNISensorChannel = 0;
+const TInt KNISensorInvalidValue = 0;
+const TInt KNIMaxBars = 7;
+
+_LIT(KNetworkFieldIntensitySensorDescriptionPart1,
+     "network_field_intensity#"
+     L"device#"
+     L"device#"
+     L"Nokia#"
+     L"description=");
+_LIT(KNetworkFieldIntensitySensorDescriptionPart2,
+     "#model=Nokia#"
+     L"connectiontype=1#"
+     L"1#" // isAvailable
+     L"1#" // channel count
+     L"network_field_intensity#" // channel name. for single channel sensors should be same as model
+     L"0#" // accuracy, 100 steps (?)
+     L"2#" // data type. here TYPE_INT
+     L"0#" // scale. here zero (means that scaling is not used)
+     L"%#" // unit. percent (?)
+     L"1#" // measurement range count
+     L"0#" // smallest measurable value
+     L"100#" // largest measurable value
+     L"1#" // measurement resolution
+     L"@ch_end#");  // channel terminator constant
+
+CNetworkFieldIntensitySensor* CNetworkFieldIntensitySensor::NewL()
+{
+    JELOG2(ESensor);
+    CNetworkFieldIntensitySensor* self = new(ELeave)CNetworkFieldIntensitySensor();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(); // self
+    return self;
+}
+
+CNetworkFieldIntensitySensor::CNetworkFieldIntensitySensor()
+{
+    JELOG2(ESensor);
+}
+
+void CNetworkFieldIntensitySensor::ConstructL()
+{
+    JELOG2(ESensor);
+    CSensorBase::ConstructL();
+}
+
+CNetworkFieldIntensitySensor::~CNetworkFieldIntensitySensor()
+{
+    JELOG2(ESensor);
+    delete iNotifier;
+}
+
+int CNetworkFieldIntensitySensor::OpenChannel(SensorListener* aListener)
+{
+    JELOG2(ESensor);
+    iSensorListener = aListener;
+    TRAPD(err, iNotifier = CSignalAsyncHandler::NewL(*this));
+    return err; // KErrNone if succesful
+}
+
+void CNetworkFieldIntensitySensor::StartDataListeningL()
+{
+    JELOG2(ESensor);
+    iNotifier->Cancel();
+    ResetAccumulationData();
+    iNotifier->SetDataListeningMode(ETrue);
+}
+
+void CNetworkFieldIntensitySensor::CancelDataListeningL()
+{
+    JELOG2(ESensor);
+    iNotifier->Cancel();
+    iNotifier->SetDataListeningMode(EFalse);
+}
+
+void CNetworkFieldIntensitySensor::CloseChannelL()
+{
+    JELOG2(ESensor);
+    iSensorListener = NULL;
+    delete iNotifier;
+    iNotifier = NULL;
+}
+
+void CNetworkFieldIntensitySensor::StartConditionListeningL()
+{
+    JELOG2(ESensor);
+    iNotifier->Cancel();
+    iNotifier->SetConditionListeningMode(ETrue);
+}
+
+void CNetworkFieldIntensitySensor::StopConditionListeningL()
+{
+    JELOG2(ESensor);
+    iNotifier->Cancel();
+    iNotifier->SetConditionListeningMode(EFalse);
+}
+
+void CNetworkFieldIntensitySensor::ResetAccumulationData()
+{
+    JELOG2(ESensor);
+    iData[ KNISensorChannel ]->iNumOfValues = 0;
+    iStartTime = KErrNotFound;
+}
+
+void CNetworkFieldIntensitySensor::SendData()
+{
+    JELOG2(ESensor);
+    if (iIsOneShot)
+    {
+        iNotifier->Cancel();
+        iNotifier->SetDataListeningMode(EFalse);
+    }
+    iSensorListener->DataReceived(iData, EFalse);
+    ResetAccumulationData();
+}
+
+void CNetworkFieldIntensitySensor::SignalLevelReceivedL(TInt aLevel)
+{
+    JELOG2(ESensor);
+    __ASSERT_DEBUG(iData != NULL, User::Invariant());
+    SensorData* data = iData[ KNISensorChannel ];
+
+    TTime currentTime;
+    if (data->iTimeStamps || (iBufferingPeriod > 0))
+    {
+        currentTime.UniversalTime();
+        if (iStartTime == KErrNotFound)
+        {
+            iStartTime = currentTime;
+        }
+    }
+
+    // P&S sensors are assumed to have one channel only
+    TInt interpretedValue = InterpretValue(aLevel);
+
+    // Negative values are error codes and therefore marked
+    // as invalid. Returned value for invalid values is zero.
+    if (interpretedValue < 0)
+    {
+        data->iIntValues[ data->iNumOfValues ] = KNISensorInvalidValue;
+        if (data->iValiditiesIncluded)
+        {
+            data->iValidities[ data->iNumOfValues ] = EFalse;
+        }
+    }
+    else
+    {
+        data->iIntValues[ data->iNumOfValues ] = interpretedValue;
+        if (data->iValiditiesIncluded)
+        {
+            data->iValidities[ data->iNumOfValues ] = ETrue;
+        }
+    }
+
+    if (data->iTimeStampsIncluded)
+    {
+        data->iTimeStamps[ data->iNumOfValues ] = TimeStamp(currentTime);
+    }
+    data->iNumOfValues++;
+
+    TInt64 intervalFromStart = -1;
+    if (iBufferingPeriod > 0)
+    {
+        intervalFromStart = currentTime.MicroSecondsFrom(iStartTime).Int64();
+    }
+
+    if ((data->iNumOfValues == iBufferSize) ||
+            (iBufferingPeriod > 0 && intervalFromStart > iBufferingPeriod))
+    {
+        SendData();
+    }
+}
+
+void CNetworkFieldIntensitySensor::SignalLevelChangedL(TInt aLevel)
+{
+    JELOG2(ESensor);
+    // Values lower than zero are error code and do not qualify for
+    // signal change notification
+    if (aLevel >= 0)
+    {
+        EvaluateConditions(aLevel, KNISensorChannel);
+    }
+}
+
+HBufC* CNetworkFieldIntensitySensor::CreateDescriptionLC()
+{
+    JELOG2(ESensor);
+    HBufC* desc = HBufC::NewLC(KMaxSensorDescriptionLength);
+    TPtr desPtr = desc->Des();
+    desPtr.Append(KNetworkFieldIntensitySensorDescriptionPart1);
+    desPtr.Append(SensorProperties::GetPropertyString(KSensorDescription,
+                  ENetworkFieldIntensitySensor));
+    desPtr.Append(KNetworkFieldIntensitySensorDescriptionPart2);
+    return desc;
+}
+
+CSensorBase* CNetworkFieldIntensitySensor::DuplicateL()
+{
+    JELOG2(ESensor);
+    return NewL();
+}
+
+TReal CNetworkFieldIntensitySensor::InterpretValue(TReal aValue)
+{
+    JELOG2(ESensor);
+    // Network intensity is between 0 and 100. Values below zero
+    // are error codes and are returned as they are.
+    return aValue > 0  ? aValue / KNIMaxBars * 100 : aValue;
+}
+
+// **************************************************************************
+// CSignalAsyncHandler
+// **************************************************************************
+
+CNetworkFieldIntensitySensor::CSignalAsyncHandler*
+CNetworkFieldIntensitySensor::CSignalAsyncHandler::NewL(
+    CNetworkFieldIntensitySensor& aSensor)
+{
+    JELOG2(ESensor);
+    CSignalAsyncHandler* self =
+        new(ELeave)CSignalAsyncHandler(aSensor);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(); // self
+    return self;
+}
+
+CNetworkFieldIntensitySensor::CSignalAsyncHandler::CSignalAsyncHandler(
+    CNetworkFieldIntensitySensor& aSensor)
+        : CActive(EPriorityStandard), iSensor(aSensor),
+        iSigStrengthV1Pckg(iSigStrengthV1), iCurrentOperation(EOperationNone),
+        iPrevSignalStrength(KErrNotFound)
+{
+    JELOG2(ESensor);
+}
+
+CNetworkFieldIntensitySensor::CSignalAsyncHandler::~CSignalAsyncHandler()
+{
+    JELOG2(ESensor);
+    Cancel();
+    delete iTelephony;
+}
+
+void CNetworkFieldIntensitySensor::CSignalAsyncHandler::ConstructL()
+{
+    JELOG2(ESensor);
+    iTelephony = CTelephony::NewL();
+    CActiveScheduler::Add(this);
+}
+
+void CNetworkFieldIntensitySensor::CSignalAsyncHandler::RunL()
+{
+    JELOG2(ESensor);
+#ifdef __WINS__
+#pragma message("CNetworkFieldIntensitySensor: Test value used for WINS.")
+    TInt signalStrength = 1;
+#else
+    TInt signalStrength = (iStatus == KErrNone) ?
+                          iSigStrengthV1.iBar : KErrNotFound;
+#endif
+
+    if (iDataListening)
+    {
+        iCurrentOperation = EGetSignalIntensity;
+        iTelephony->GetSignalStrength(iStatus, iSigStrengthV1Pckg);
+        SetActive();
+        iSensor.SignalLevelReceivedL(signalStrength);
+        if (iConditionListening && (signalStrength != iPrevSignalStrength))
+        {
+            iSensor.SignalLevelChangedL(signalStrength);
+        }
+    }
+    else if (iConditionListening)
+    {
+        iCurrentOperation = ENotifySignalIntensityChange;
+        iTelephony->NotifyChange(iStatus,
+                                 CTelephony::ESignalStrengthChange, iSigStrengthV1Pckg);
+        SetActive();
+        iSensor.SignalLevelChangedL(signalStrength);
+    }
+    iPrevSignalStrength = signalStrength;
+}
+
+void CNetworkFieldIntensitySensor::CSignalAsyncHandler::DoCancel()
+{
+    JELOG2(ESensor);
+    if (iCurrentOperation == EGetSignalIntensity)
+    {
+        iTelephony->CancelAsync(CTelephony::EGetSignalStrengthCancel);
+    }
+    else if (iCurrentOperation == ENotifySignalIntensityChange)
+    {
+        iTelephony->CancelAsync(CTelephony::ESignalStrengthChangeCancel);
+    }
+    iCurrentOperation = EOperationNone;
+}
+
+void CNetworkFieldIntensitySensor::CSignalAsyncHandler::
+SetDataListeningMode(TBool aIsDataListening)
+{
+    JELOG2(ESensor);
+    __ASSERT_DEBUG(!IsActive(), User::Invariant());
+    iDataListening = aIsDataListening;
+    Start();
+}
+
+void CNetworkFieldIntensitySensor::CSignalAsyncHandler::
+SetConditionListeningMode(TBool aIsConditionListening)
+{
+    JELOG2(ESensor);
+    __ASSERT_DEBUG(!IsActive(), User::Invariant());
+    iConditionListening = aIsConditionListening;
+    Start();
+}
+void CNetworkFieldIntensitySensor::CSignalAsyncHandler::Start()
+{
+    JELOG2(ESensor);
+    if (iDataListening || iConditionListening)
+    {
+        iPrevSignalStrength = KErrNotFound;
+        iCurrentOperation = EGetSignalIntensity;
+        iTelephony->GetSignalStrength(iStatus, iSigStrengthV1Pckg);
+        SetActive();
+    }
+}