Merge changes from topic "wifiactivityenergyinfo" (9fbf3bef) · Commits · e / os / android_frameworks_base

apex/statsd/service/java/com/android/server/stats/StatsCompanionService.java

+5 −5

Original line number	Diff line number	Diff line
		@@ -1163,12 +1163,12 @@ public class StatsCompanionService extends IStatsCompanionService.Stub {
		final WifiActivityEnergyInfo wifiInfo = awaitControllerInfo(wifiReceiver);
		StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
		wallClockNanos);
		e.writeLong(wifiInfo.getTimeStamp());
		e.writeLong(wifiInfo.getTimeSinceBootMillis());
		e.writeInt(wifiInfo.getStackState());
		e.writeLong(wifiInfo.getControllerTxTimeMillis());
		e.writeLong(wifiInfo.getControllerRxTimeMillis());
		e.writeLong(wifiInfo.getControllerIdleTimeMillis());
		e.writeLong(wifiInfo.getControllerEnergyUsed());
		e.writeLong(wifiInfo.getControllerTxDurationMillis());
		e.writeLong(wifiInfo.getControllerRxDurationMillis());
		e.writeLong(wifiInfo.getControllerIdleDurationMillis());
		e.writeLong(wifiInfo.getControllerEnergyUsedMicroJoules());
		pulledData.add(e);
		} catch (RemoteException e) {
		Slog.e(TAG,

api/system-current.txt

+26 −0

Original line number	Diff line number	Diff line
		@@ -5307,6 +5307,32 @@ package android.net.wifi {
		field @NonNull public static final android.os.Parcelable.Creator<android.net.wifi.SoftApInfo> CREATOR;
		}

		public final class WifiActivityEnergyInfo implements android.os.Parcelable {
		ctor public WifiActivityEnergyInfo(long, int, long, long, long, long, long);
		method public int describeContents();
		method public long getControllerEnergyUsedMicroJoules();
		method public long getControllerIdleDurationMillis();
		method public long getControllerRxDurationMillis();
		method public long getControllerScanDurationMillis();
		method public long getControllerTxDurationMillis();
		method public int getStackState();
		method public long getTimeSinceBootMillis();
		method public boolean isValid();
		method public void setControllerEnergyUsedMicroJoules(long);
		method public void setControllerIdleDurationMillis(long);
		method public void setControllerRxDurationMillis(long);
		method public void setControllerScanDurationMillis(long);
		method public void setControllerTxDurationMillis(long);
		method public void setStackState(int);
		method public void setTimeSinceBootMillis(long);
		method public void writeToParcel(@NonNull android.os.Parcel, int);
		field @NonNull public static final android.os.Parcelable.Creator<android.net.wifi.WifiActivityEnergyInfo> CREATOR;
		field public static final int STACK_STATE_INVALID = 0; // 0x0
		field public static final int STACK_STATE_STATE_ACTIVE = 1; // 0x1
		field public static final int STACK_STATE_STATE_IDLE = 3; // 0x3
		field public static final int STACK_STATE_STATE_SCANNING = 2; // 0x2
		}

		public final class WifiClient implements android.os.Parcelable {
		method public int describeContents();
		method @NonNull public android.net.MacAddress getMacAddress();

core/java/com/android/internal/os/BatteryStatsImpl.java

+10 −9

Original line number	Diff line number	Diff line
		@@ -10801,10 +10801,10 @@ public class BatteryStatsImpl extends BatteryStats {
		mHasWifiReporting = true;

		// Measured in mAms
		final long txTimeMs = info.getControllerTxTimeMillis();
		final long rxTimeMs = info.getControllerRxTimeMillis();
		final long scanTimeMs = info.getControllerScanTimeMillis();
		final long idleTimeMs = info.getControllerIdleTimeMillis();
		final long txTimeMs = info.getControllerTxDurationMillis();
		final long rxTimeMs = info.getControllerRxDurationMillis();
		final long scanTimeMs = info.getControllerScanDurationMillis();
		final long idleTimeMs = info.getControllerIdleDurationMillis();
		final long totalTimeMs = txTimeMs + rxTimeMs + idleTimeMs;

		long leftOverRxTimeMs = rxTimeMs;
		@@ -10947,13 +10947,14 @@ public class BatteryStatsImpl extends BatteryStats {


		// Update WiFi controller stats.
		mWifiActivity.getRxTimeCounter().addCountLocked(info.getControllerRxTimeMillis());
		mWifiActivity.getRxTimeCounter().addCountLocked(
		info.getControllerRxDurationMillis());
		mWifiActivity.getTxTimeCounters()[0].addCountLocked(
		info.getControllerTxTimeMillis());
		info.getControllerTxDurationMillis());
		mWifiActivity.getScanTimeCounter().addCountLocked(
		info.getControllerScanTimeMillis());
		info.getControllerScanDurationMillis());
		mWifiActivity.getIdleTimeCounter().addCountLocked(
		info.getControllerIdleTimeMillis());
		info.getControllerIdleDurationMillis());

		// POWER_WIFI_CONTROLLER_OPERATING_VOLTAGE is measured in mV, so convert to V.
		final double opVolt = mPowerProfile.getAveragePower(
		@@ -10961,7 +10962,7 @@ public class BatteryStatsImpl extends BatteryStats {
		if (opVolt != 0) {
		// We store the power drain as mAms.
		mWifiActivity.getPowerCounter().addCountLocked(
		(long) (info.getControllerEnergyUsed() / opVolt));
		(long) (info.getControllerEnergyUsedMicroJoules() / opVolt));
		}
		// Converting uWs to mAms.
		// Conversion: (uWs * (1000ms / 1s) * (1mW / 1000uW)) / mV = mAms

services/core/java/com/android/server/am/BatteryExternalStatsWorker.java

+39 −34

Original line number	Diff line number	Diff line
		@@ -126,7 +126,7 @@ class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync {
		// Keep the last WiFi stats so we can compute a delta.
		@GuardedBy("mWorkerLock")
		private WifiActivityEnergyInfo mLastInfo =
		new WifiActivityEnergyInfo(0, 0, 0, new long[]{0}, 0, 0, 0, 0);
		new WifiActivityEnergyInfo(0, 0, 0, 0, 0, 0, 0);

		/**
		* Timestamp at which all external stats were last collected in
		@@ -548,42 +548,45 @@ class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync {

		@GuardedBy("mWorkerLock")
		private WifiActivityEnergyInfo extractDeltaLocked(WifiActivityEnergyInfo latest) {
		final long timePeriodMs = latest.mTimestamp - mLastInfo.mTimestamp;
		final long lastScanMs = mLastInfo.mControllerScanTimeMs;
		final long lastIdleMs = mLastInfo.mControllerIdleTimeMs;
		final long lastTxMs = mLastInfo.mControllerTxTimeMs;
		final long lastRxMs = mLastInfo.mControllerRxTimeMs;
		final long lastEnergy = mLastInfo.mControllerEnergyUsed;
		final long timePeriodMs = latest.getTimeSinceBootMillis()
		- mLastInfo.getTimeSinceBootMillis();
		final long lastScanMs = mLastInfo.getControllerScanDurationMillis();
		final long lastIdleMs = mLastInfo.getControllerIdleDurationMillis();
		final long lastTxMs = mLastInfo.getControllerTxDurationMillis();
		final long lastRxMs = mLastInfo.getControllerRxDurationMillis();
		final long lastEnergy = mLastInfo.getControllerEnergyUsedMicroJoules();

		// We will modify the last info object to be the delta, and store the new
		// WifiActivityEnergyInfo object as our last one.
		final WifiActivityEnergyInfo delta = mLastInfo;
		delta.mTimestamp = latest.getTimeStamp();
		delta.mStackState = latest.getStackState();
		delta.setTimeSinceBootMillis(latest.getTimeSinceBootMillis());
		delta.setStackState(latest.getStackState());

		final long txTimeMs = latest.mControllerTxTimeMs - lastTxMs;
		final long rxTimeMs = latest.mControllerRxTimeMs - lastRxMs;
		final long idleTimeMs = latest.mControllerIdleTimeMs - lastIdleMs;
		final long scanTimeMs = latest.mControllerScanTimeMs - lastScanMs;
		final long txTimeMs = latest.getControllerTxDurationMillis() - lastTxMs;
		final long rxTimeMs = latest.getControllerRxDurationMillis() - lastRxMs;
		final long idleTimeMs = latest.getControllerIdleDurationMillis() - lastIdleMs;
		final long scanTimeMs = latest.getControllerScanDurationMillis() - lastScanMs;

		if (txTimeMs < 0 \|\| rxTimeMs < 0 \|\| scanTimeMs < 0 \|\| idleTimeMs < 0) {
		// The stats were reset by the WiFi system (which is why our delta is negative).
		// Returns the unaltered stats. The total on time should not exceed the time
		// duartion between reports.
		final long totalOnTimeMs = latest.mControllerTxTimeMs + latest.mControllerRxTimeMs
		+ latest.mControllerIdleTimeMs;
		final long totalOnTimeMs = latest.getControllerTxDurationMillis()
		+ latest.getControllerRxDurationMillis()
		+ latest.getControllerIdleDurationMillis();
		if (totalOnTimeMs <= timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) {
		delta.mControllerEnergyUsed = latest.mControllerEnergyUsed;
		delta.mControllerRxTimeMs = latest.mControllerRxTimeMs;
		delta.mControllerTxTimeMs = latest.mControllerTxTimeMs;
		delta.mControllerIdleTimeMs = latest.mControllerIdleTimeMs;
		delta.mControllerScanTimeMs = latest.mControllerScanTimeMs;
		delta.setControllerEnergyUsedMicroJoules(
		latest.getControllerEnergyUsedMicroJoules());
		delta.setControllerRxDurationMillis(latest.getControllerRxDurationMillis());
		delta.setControllerTxDurationMillis(latest.getControllerTxDurationMillis());
		delta.setControllerIdleDurationMillis(latest.getControllerIdleDurationMillis());
		delta.setControllerScanDurationMillis(latest.getControllerScanDurationMillis());
		} else {
		delta.mControllerEnergyUsed = 0;
		delta.mControllerRxTimeMs = 0;
		delta.mControllerTxTimeMs = 0;
		delta.mControllerIdleTimeMs = 0;
		delta.mControllerScanTimeMs = 0;
		delta.setControllerEnergyUsedMicroJoules(0);
		delta.setControllerRxDurationMillis(0);
		delta.setControllerTxDurationMillis(0);
		delta.setControllerIdleDurationMillis(0);
		delta.setControllerScanDurationMillis(0);
		}
		Slog.v(TAG, "WiFi energy data was reset, new WiFi energy data is " + delta);
		} else {
		@@ -608,28 +611,30 @@ class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync {
		sb.append(" e=").append(lastEnergy);
		sb.append("\n");
		sb.append("Current WiFi snapshot: ").append("idle=");
		TimeUtils.formatDuration(latest.mControllerIdleTimeMs, sb);
		TimeUtils.formatDuration(latest.getControllerIdleDurationMillis(), sb);
		sb.append(" rx=");
		TimeUtils.formatDuration(latest.mControllerRxTimeMs, sb);
		TimeUtils.formatDuration(latest.getControllerRxDurationMillis(), sb);
		sb.append(" tx=");
		TimeUtils.formatDuration(latest.mControllerTxTimeMs, sb);
		sb.append(" e=").append(latest.mControllerEnergyUsed);
		TimeUtils.formatDuration(latest.getControllerTxDurationMillis(), sb);
		sb.append(" e=").append(latest.getControllerEnergyUsedMicroJoules());
		Slog.wtf(TAG, sb.toString());
		}
		} else {
		maxExpectedIdleTimeMs = timePeriodMs - totalActiveTimeMs;
		}
		// These times seem to be the most reliable.
		delta.mControllerTxTimeMs = txTimeMs;
		delta.mControllerRxTimeMs = rxTimeMs;
		delta.mControllerScanTimeMs = scanTimeMs;
		delta.setControllerTxDurationMillis(txTimeMs);
		delta.setControllerRxDurationMillis(rxTimeMs);
		delta.setControllerScanDurationMillis(scanTimeMs);
		// WiFi calculates the idle time as a difference from the on time and the various
		// Rx + Tx times. There seems to be some missing time there because this sometimes
		// becomes negative. Just cap it at 0 and ensure that it is less than the expected idle
		// time from the difference in timestamps.
		// b/21613534
		delta.mControllerIdleTimeMs = Math.min(maxExpectedIdleTimeMs, Math.max(0, idleTimeMs));
		delta.mControllerEnergyUsed = Math.max(0, latest.mControllerEnergyUsed - lastEnergy);
		delta.setControllerIdleDurationMillis(
		Math.min(maxExpectedIdleTimeMs, Math.max(0, idleTimeMs)));
		delta.setControllerEnergyUsedMicroJoules(
		Math.max(0, latest.getControllerEnergyUsedMicroJoules() - lastEnergy));
		}

		mLastInfo = latest;

wifi/java/android/net/wifi/WifiActivityEnergyInfo.java

+141 −119

Original line number	Diff line number	Diff line
		@@ -16,10 +16,14 @@

		package android.net.wifi;

		import android.annotation.IntDef;
		import android.annotation.NonNull;
		import android.annotation.SystemApi;
		import android.os.Parcel;
		import android.os.Parcelable;

		import java.util.Arrays;
		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;

		/**
		* Record of energy and activity information from controller and
		@@ -27,179 +31,197 @@ import java.util.Arrays;
		* real-time.
		* @hide
		*/
		@SystemApi
		public final class WifiActivityEnergyInfo implements Parcelable {
		/**
		* @hide
		*/
		public long mTimestamp;

		/**
		* @hide
		*/
		public int mStackState;

		/**
		* @hide
		*/
		public long mControllerTxTimeMs;

		/**
		* @hide
		*/
		public long[] mControllerTxTimePerLevelMs;

		/**
		* @hide
		*/
		public long mControllerRxTimeMs;

		/**
		* @hide
		*/
		public long mControllerScanTimeMs;

		/**
		* @hide
		*/
		public long mControllerIdleTimeMs;

		/**
		* @hide
		*/
		public long mControllerEnergyUsed;

		private long mTimeSinceBootMillis;
		@StackState
		private int mStackState;
		private long mControllerTxDurationMillis;
		private long mControllerRxDurationMillis;
		private long mControllerScanDurationMillis;
		private long mControllerIdleDurationMillis;
		private long mControllerEnergyUsedMicroJoules;

		/** @hide */
		@Retention(RetentionPolicy.SOURCE)
		@IntDef(prefix = {"STACK_STATE_"}, value = {
		STACK_STATE_INVALID,
		STACK_STATE_STATE_ACTIVE,
		STACK_STATE_STATE_SCANNING,
		STACK_STATE_STATE_IDLE})
		public @interface StackState {}

		/** Invalid Wifi stack state. */
		public static final int STACK_STATE_INVALID = 0;
		/** Wifi stack is active. */
		public static final int STACK_STATE_STATE_ACTIVE = 1;
		/** Wifi stack is scanning. */
		public static final int STACK_STATE_STATE_SCANNING = 2;
		/** Wifi stack is idle. */
		public static final int STACK_STATE_STATE_IDLE = 3;

		public WifiActivityEnergyInfo(long timestamp, int stackState,
		long txTime, long[] txTimePerLevel, long rxTime, long scanTime,
		long idleTime, long energyUsed) {
		mTimestamp = timestamp;
		/**
		* Constructor.
		*
		* @param timeSinceBootMillis the time since boot, in milliseconds.
		* @param stackState The current state of the Wifi Stack. One of {@link #STACK_STATE_INVALID},
		* {@link #STACK_STATE_STATE_ACTIVE}, {@link #STACK_STATE_STATE_SCANNING},
		* or {@link #STACK_STATE_STATE_IDLE}.
		* @param txDurationMillis Cumulative milliseconds of active transmission.
		* @param rxDurationMillis Cumulative milliseconds of active receive.
		* @param scanDurationMillis Cumulative milliseconds when radio is awake due to scan.
		* @param idleDurationMillis Cumulative milliseconds when radio is awake but not transmitting or
		* receiving.
		* @param energyUsedMicroJoules Cumulative energy consumed by Wifi, in microjoules.
		*/
		public WifiActivityEnergyInfo(
		long timeSinceBootMillis,
		@StackState int stackState,
		long txDurationMillis,
		long rxDurationMillis,
		long scanDurationMillis,
		long idleDurationMillis,
		long energyUsedMicroJoules) {
		mTimeSinceBootMillis = timeSinceBootMillis;
		mStackState = stackState;
		mControllerTxTimeMs = txTime;
		mControllerTxTimePerLevelMs = txTimePerLevel;
		mControllerRxTimeMs = rxTime;
		mControllerScanTimeMs = scanTime;
		mControllerIdleTimeMs = idleTime;
		mControllerEnergyUsed = energyUsed;
		mControllerTxDurationMillis = txDurationMillis;
		mControllerRxDurationMillis = rxDurationMillis;
		mControllerScanDurationMillis = scanDurationMillis;
		mControllerIdleDurationMillis = idleDurationMillis;
		mControllerEnergyUsedMicroJoules = energyUsedMicroJoules;
		}

		@Override
		public String toString() {
		return "WifiActivityEnergyInfo{"
		+ " timestamp=" + mTimestamp
		+ " mTimeSinceBootMillis=" + mTimeSinceBootMillis
		+ " mStackState=" + mStackState
		+ " mControllerTxTimeMs=" + mControllerTxTimeMs
		+ " mControllerTxTimePerLevelMs=" + Arrays.toString(mControllerTxTimePerLevelMs)
		+ " mControllerRxTimeMs=" + mControllerRxTimeMs
		+ " mControllerScanTimeMs=" + mControllerScanTimeMs
		+ " mControllerIdleTimeMs=" + mControllerIdleTimeMs
		+ " mControllerEnergyUsed=" + mControllerEnergyUsed
		+ " mControllerTxDurationMillis=" + mControllerTxDurationMillis
		+ " mControllerRxDurationMillis=" + mControllerRxDurationMillis
		+ " mControllerScanDurationMillis=" + mControllerScanDurationMillis
		+ " mControllerIdleDurationMillis=" + mControllerIdleDurationMillis
		+ " mControllerEnergyUsedMicroJoules=" + mControllerEnergyUsedMicroJoules
		+ " }";
		}

		public static final @android.annotation.NonNull Parcelable.Creator<WifiActivityEnergyInfo> CREATOR =
		public static final @NonNull Parcelable.Creator<WifiActivityEnergyInfo> CREATOR =
		new Parcelable.Creator<WifiActivityEnergyInfo>() {
		public WifiActivityEnergyInfo createFromParcel(Parcel in) {
		long timestamp = in.readLong();
		int stackState = in.readInt();
		long txTime = in.readLong();
		long[] txTimePerLevel = in.createLongArray();
		long rxTime = in.readLong();
		long scanTime = in.readLong();
		long idleTime = in.readLong();
		long energyUsed = in.readLong();
		return new WifiActivityEnergyInfo(timestamp, stackState,
		txTime, txTimePerLevel, rxTime, scanTime, idleTime, energyUsed);
		txTime, rxTime, scanTime, idleTime, energyUsed);
		}
		public WifiActivityEnergyInfo[] newArray(int size) {
		return new WifiActivityEnergyInfo[size];
		}
		};

		public void writeToParcel(Parcel out, int flags) {
		out.writeLong(mTimestamp);
		@Override
		public void writeToParcel(@NonNull Parcel out, int flags) {
		out.writeLong(mTimeSinceBootMillis);
		out.writeInt(mStackState);
		out.writeLong(mControllerTxTimeMs);
		out.writeLongArray(mControllerTxTimePerLevelMs);
		out.writeLong(mControllerRxTimeMs);
		out.writeLong(mControllerScanTimeMs);
		out.writeLong(mControllerIdleTimeMs);
		out.writeLong(mControllerEnergyUsed);
		out.writeLong(mControllerTxDurationMillis);
		out.writeLong(mControllerRxDurationMillis);
		out.writeLong(mControllerScanDurationMillis);
		out.writeLong(mControllerIdleDurationMillis);
		out.writeLong(mControllerEnergyUsedMicroJoules);
		}

		@Override
		public int describeContents() {
		return 0;
		}

		/** Get the timestamp (milliseconds since boot) of record creation. */
		public long getTimeSinceBootMillis() {
		return mTimeSinceBootMillis;
		}

		/** Set the timestamp (milliseconds since boot) of record creation. */
		public void setTimeSinceBootMillis(long timeSinceBootMillis) {
		mTimeSinceBootMillis = timeSinceBootMillis;
		}

		/**
		* @return bt stack reported state
		* Get the Wifi stack reported state. One of {@link #STACK_STATE_INVALID},
		* {@link #STACK_STATE_STATE_ACTIVE}, {@link #STACK_STATE_STATE_SCANNING},
		* {@link #STACK_STATE_STATE_IDLE}.
		*/
		@StackState
		public int getStackState() {
		return mStackState;
		}

		/**
		* @return tx time in ms
		* Set the Wifi stack reported state. One of {@link #STACK_STATE_INVALID},
		* {@link #STACK_STATE_STATE_ACTIVE}, {@link #STACK_STATE_STATE_SCANNING},
		* {@link #STACK_STATE_STATE_IDLE}.
		*/
		public long getControllerTxTimeMillis() {
		return mControllerTxTimeMs;
		public void setStackState(@StackState int stackState) {
		mStackState = stackState;
		}

		/**
		* @return tx time at power level provided in ms
		*/
		public long getControllerTxTimeMillisAtLevel(int level) {
		if (level < mControllerTxTimePerLevelMs.length) {
		return mControllerTxTimePerLevelMs[level];
		/** Get the Wifi transmission duration, in milliseconds. */
		public long getControllerTxDurationMillis() {
		return mControllerTxDurationMillis;
		}
		return 0;

		/** Set the Wifi transmission duration, in milliseconds. */
		public void setControllerTxDurationMillis(long controllerTxDurationMillis) {
		mControllerTxDurationMillis = controllerTxDurationMillis;
		}

		/**
		* @return rx time in ms
		*/
		public long getControllerRxTimeMillis() {
		return mControllerRxTimeMs;
		/** Get the Wifi receive duration, in milliseconds. */
		public long getControllerRxDurationMillis() {
		return mControllerRxDurationMillis;
		}

		/**
		* @return scan time in ms
		*/
		public long getControllerScanTimeMillis() {
		return mControllerScanTimeMs;
		/** Set the Wifi receive duration, in milliseconds. */
		public void setControllerRxDurationMillis(long controllerRxDurationMillis) {
		mControllerRxDurationMillis = controllerRxDurationMillis;
		}

		/**
		* @return idle time in ms
		*/
		public long getControllerIdleTimeMillis() {
		return mControllerIdleTimeMs;
		/** Get the Wifi scan duration, in milliseconds. */
		public long getControllerScanDurationMillis() {
		return mControllerScanDurationMillis;
		}

		/**
		* product of current(mA), voltage(V) and time(ms)
		* @return energy used
		*/
		public long getControllerEnergyUsed() {
		return mControllerEnergyUsed;
		/** Set the Wifi scan duration, in milliseconds. */
		public void setControllerScanDurationMillis(long controllerScanDurationMillis) {
		mControllerScanDurationMillis = controllerScanDurationMillis;
		}
		/**
		* @return timestamp(wall clock) of record creation
		*/
		public long getTimeStamp() {
		return mTimestamp;

		/** Get the Wifi idle duration, in milliseconds. */
		public long getControllerIdleDurationMillis() {
		return mControllerIdleDurationMillis;
		}

		/**
		* @return if the record is valid
		*/
		/** Set the Wifi idle duration, in milliseconds. */
		public void setControllerIdleDurationMillis(long controllerIdleDurationMillis) {
		mControllerIdleDurationMillis = controllerIdleDurationMillis;
		}

		/** Get the energy consumed by Wifi, in microjoules. */
		public long getControllerEnergyUsedMicroJoules() {
		return mControllerEnergyUsedMicroJoules;
		}

		/** Set the energy consumed by Wifi, in microjoules. */
		public void setControllerEnergyUsedMicroJoules(long controllerEnergyUsedMicroJoules) {
		mControllerEnergyUsedMicroJoules = controllerEnergyUsedMicroJoules;
		}

		/** Returns true if the record is valid, false otherwise. */
		public boolean isValid() {
		return ((mControllerTxTimeMs >=0) &&
		(mControllerRxTimeMs >=0) &&
		(mControllerScanTimeMs >=0) &&
		(mControllerIdleTimeMs >=0));
		return mControllerTxDurationMillis >= 0
		&& mControllerRxDurationMillis >= 0
		&& mControllerScanDurationMillis >= 0
		&& mControllerIdleDurationMillis >= 0;
		}
		}