core/sensor_request.cc - platform/system/chre - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <algorithm>

 #include "chre/core/sensor_request.h"
 #include "chre/platform/assert.h"
 #include "chre/platform/fatal_error.h"

 namespace chre {
 namespace {

 Nanoseconds getBatchInterval(const SensorRequest& request) {
   // With capping in SensorRequest constructor, interval + latency < UINT64_MAX.
   // When the return value is default, request latency (instead of batch
   // interval) will be used to compute the merged latency.
   if (request.getInterval() == Nanoseconds(CHRE_SENSOR_INTERVAL_DEFAULT)
       || request.getLatency() == Nanoseconds(CHRE_SENSOR_LATENCY_DEFAULT)) {
     return Nanoseconds(CHRE_SENSOR_BATCH_INTERVAL_DEFAULT);
   } else {
     return request.getInterval() + request.getLatency();
   }
 }

 }  // namespace

 const char *getSensorTypeName(SensorType sensorType) {
   switch (sensorType) {
     case SensorType::Unknown:
       return "Unknown";
     case SensorType::Accelerometer:
       return "Accelerometer";
     case SensorType::InstantMotion:
       return "Instant Motion";
     case SensorType::StationaryDetect:
       return "Stationary Detect";
     case SensorType::Gyroscope:
       return "Gyroscope";
     case SensorType::GeomagneticField:
       return "Geomagnetic Field";
     case SensorType::Pressure:
       return "Pressure";
     case SensorType::Light:
       return "Light";
     case SensorType::Proximity:
       return "Proximity";
     case SensorType::AccelerometerTemperature:
       return "Accelerometer Temp";
     case SensorType::GyroscopeTemperature:
       return "Gyroscope Temp";
     case SensorType::UncalibratedAccelerometer:
       return "Uncal Accelerometer";
     case SensorType::UncalibratedGyroscope:
       return "Uncal Gyroscope";
     case SensorType::UncalibratedGeomagneticField:
       return "Uncal Geomagnetic Field";
     default:
       CHRE_ASSERT(false);
       return "";
   }
 }

 uint16_t getSampleEventTypeForSensorType(SensorType sensorType) {
   if (sensorType == SensorType::Unknown) {
     FATAL_ERROR("Tried to obtain the sensor sample event index for an unknown "
                 "sensor type");
   }

   // The enum values of SensorType may not map to the defined values in the
   // CHRE API.
   uint8_t sensorTypeValue = getUnsignedIntFromSensorType(sensorType);
   return CHRE_EVENT_SENSOR_DATA_EVENT_BASE + sensorTypeValue;
 }

 SensorType getSensorTypeForSampleEventType(uint16_t eventType) {
   return getSensorTypeFromUnsignedInt(
       static_cast<uint8_t>(eventType - CHRE_EVENT_SENSOR_DATA_EVENT_BASE));
 }

 SensorType getSensorTypeFromUnsignedInt(uint8_t sensorType) {
   switch (sensorType) {
     case CHRE_SENSOR_TYPE_ACCELEROMETER:
       return SensorType::Accelerometer;
     case CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT:
       return SensorType::InstantMotion;
     case CHRE_SENSOR_TYPE_STATIONARY_DETECT:
       return SensorType::StationaryDetect;
     case CHRE_SENSOR_TYPE_GYROSCOPE:
       return SensorType::Gyroscope;
     case CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD:
       return SensorType::GeomagneticField;
     case CHRE_SENSOR_TYPE_PRESSURE:
       return SensorType::Pressure;
     case CHRE_SENSOR_TYPE_LIGHT:
       return SensorType::Light;
     case CHRE_SENSOR_TYPE_PROXIMITY:
       return SensorType::Proximity;
     case CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE:
       return SensorType::AccelerometerTemperature;
     case CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE:
       return SensorType::GyroscopeTemperature;
     case CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER:
       return SensorType::UncalibratedAccelerometer;
     case CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE:
       return SensorType::UncalibratedGyroscope;
     case CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD:
       return SensorType::UncalibratedGeomagneticField;
     default:
       return SensorType::Unknown;
   }
 }

 uint8_t getUnsignedIntFromSensorType(SensorType sensorType) {
   switch (sensorType) {
     case SensorType::Accelerometer:
       return CHRE_SENSOR_TYPE_ACCELEROMETER;
     case SensorType::InstantMotion:
       return CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT;
     case SensorType::StationaryDetect:
       return CHRE_SENSOR_TYPE_STATIONARY_DETECT;
     case SensorType::Gyroscope:
       return CHRE_SENSOR_TYPE_GYROSCOPE;
     case SensorType::GeomagneticField:
       return CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD;
     case SensorType::Pressure:
       return CHRE_SENSOR_TYPE_PRESSURE;
     case SensorType::Light:
       return CHRE_SENSOR_TYPE_LIGHT;
     case SensorType::Proximity:
       return CHRE_SENSOR_TYPE_PROXIMITY;
     case SensorType::AccelerometerTemperature:
       return CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE;
     case SensorType::GyroscopeTemperature:
       return CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE;
     case SensorType::UncalibratedAccelerometer:
       return CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER;
     case SensorType::UncalibratedGyroscope:
       return CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE;
     case SensorType::UncalibratedGeomagneticField:
       return CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD;
     default:
       // Update implementation to prevent undefined or SensorType::Unknown from
       // being used.
       CHRE_ASSERT(false);
       return 0;
   }
 }

 SensorSampleType getSensorSampleTypeFromSensorType(SensorType sensorType) {
   switch (sensorType) {
     case SensorType::Accelerometer:
     case SensorType::Gyroscope:
     case SensorType::GeomagneticField:
     case SensorType::UncalibratedAccelerometer:
     case SensorType::UncalibratedGyroscope:
     case SensorType::UncalibratedGeomagneticField:
       return SensorSampleType::ThreeAxis;
     case SensorType::Pressure:
     case SensorType::Light:
     case SensorType::AccelerometerTemperature:
     case SensorType::GyroscopeTemperature:
       return SensorSampleType::Float;
     case SensorType::InstantMotion:
     case SensorType::StationaryDetect:
       return SensorSampleType::Occurrence;
     case SensorType::Proximity:
       return SensorSampleType::Byte;
     default:
       CHRE_ASSERT(false);
       return SensorSampleType::Unknown;
   }
 }

 SensorMode getSensorModeFromEnum(enum chreSensorConfigureMode enumSensorMode) {
   switch (enumSensorMode) {
     case CHRE_SENSOR_CONFIGURE_MODE_DONE:
       return SensorMode::Off;
     case CHRE_SENSOR_CONFIGURE_MODE_CONTINUOUS:
       return SensorMode::ActiveContinuous;
     case CHRE_SENSOR_CONFIGURE_MODE_ONE_SHOT:
       return SensorMode::ActiveOneShot;
     case CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_CONTINUOUS:
       return SensorMode::PassiveContinuous;
     case CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_ONE_SHOT:
       return SensorMode::PassiveOneShot;
     default:
       // Default to off since it is the least harmful and has no power impact.
       return SensorMode::Off;
   }
 }

 bool sensorTypeIsOneShot(SensorType sensorType) {
   return (sensorType == SensorType::InstantMotion ||
           sensorType == SensorType::StationaryDetect);
 }

 bool sensorTypeIsOnChange(SensorType sensorType) {
   return (sensorType == SensorType::Light ||
           sensorType == SensorType::Proximity);
 }

 SensorRequest::SensorRequest()
     : SensorRequest(SensorMode::Off,
                     Nanoseconds(CHRE_SENSOR_INTERVAL_DEFAULT),
                     Nanoseconds(CHRE_SENSOR_LATENCY_DEFAULT)) {}

 SensorRequest::SensorRequest(SensorMode mode, Nanoseconds interval,
                              Nanoseconds latency)
     : SensorRequest(nullptr /* nanoapp */, mode, interval, latency) {}

 SensorRequest::SensorRequest(Nanoapp *nanoapp, SensorMode mode,
                              Nanoseconds interval, Nanoseconds latency)
     : mNanoapp(nanoapp), mInterval(interval), mLatency(latency), mMode(mode) {
   // cap non-default interval/latency to ensure no overflow in CHRE internal
   // operations.
   if (interval != Nanoseconds(CHRE_SENSOR_INTERVAL_DEFAULT)) {
     mInterval = std::min(interval, Nanoseconds(kMaxIntervalLatencyNs));
   }
   if (latency != Nanoseconds(CHRE_SENSOR_LATENCY_DEFAULT)) {
     mLatency = std::min(latency, Nanoseconds(kMaxIntervalLatencyNs));
   }
 }

 bool SensorRequest::isEquivalentTo(const SensorRequest& request) const {
   return (mMode == request.mMode
       && mInterval == request.mInterval
       && mLatency == request.mLatency);
 }

 bool SensorRequest::mergeWith(const SensorRequest& request) {
   bool attributesChanged = false;
   if (request.mMode != SensorMode::Off) {
     // Calculate minimum batch interval before mInterval is modified.
     Nanoseconds batchInterval = std::min(getBatchInterval(*this),
                                          getBatchInterval(request));

     if (request.mInterval < mInterval) {
       mInterval = request.mInterval;
       attributesChanged = true;
     }

     if (batchInterval == Nanoseconds(CHRE_SENSOR_BATCH_INTERVAL_DEFAULT)) {
       // If batchInterval is default, it can't be effectively calculated.
       // Use request.mLatency for more aggressive latency merging in this case.
       Nanoseconds latency = request.mLatency;
       if (latency < mLatency) {
         mLatency = latency;
         attributesChanged = true;
       }
     } else {
       Nanoseconds latency = (batchInterval - mInterval);

       // Note that while batchInterval can only shrink after merging, latency
       // can grow if the merged interval is lower.
       // Also, it's guaranteed that latency <= kMaxIntervalLatencyNs.
       if (latency != mLatency) {
         mLatency = latency;
         attributesChanged = true;
       }
     }

     // Compute the highest priority mode. Active continuous is the highest
     // priority and passive one-shot is the lowest.
     SensorMode maximalSensorMode = SensorMode::Off;
     if (mMode == SensorMode::ActiveContinuous
         || request.mMode == SensorMode::ActiveContinuous) {
       maximalSensorMode = SensorMode::ActiveContinuous;
     } else if (mMode == SensorMode::ActiveOneShot
         || request.mMode == SensorMode::ActiveOneShot) {
       maximalSensorMode = SensorMode::ActiveOneShot;
     } else if (mMode == SensorMode::PassiveContinuous
         || request.mMode == SensorMode::PassiveContinuous) {
       maximalSensorMode = SensorMode::PassiveContinuous;
     } else if (mMode == SensorMode::PassiveOneShot
         || request.mMode == SensorMode::PassiveOneShot) {
       maximalSensorMode = SensorMode::PassiveOneShot;
     } else {
       CHRE_ASSERT(false);
     }

     if (mMode != maximalSensorMode) {
       mMode = maximalSensorMode;
       attributesChanged = true;
     }
   }

   return attributesChanged;
 }

 }  // namespace chre
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <algorithm>

	#include "chre/core/sensor_request.h"
	#include "chre/platform/assert.h"
	#include "chre/platform/fatal_error.h"

	namespace chre {
	namespace {

	Nanoseconds getBatchInterval(const SensorRequest& request) {
	// With capping in SensorRequest constructor, interval + latency < UINT64_MAX.
	// When the return value is default, request latency (instead of batch
	// interval) will be used to compute the merged latency.
	if (request.getInterval() == Nanoseconds(CHRE_SENSOR_INTERVAL_DEFAULT)
	\|\| request.getLatency() == Nanoseconds(CHRE_SENSOR_LATENCY_DEFAULT)) {
	return Nanoseconds(CHRE_SENSOR_BATCH_INTERVAL_DEFAULT);
	} else {
	return request.getInterval() + request.getLatency();
	}
	}

	} // namespace

	const char *getSensorTypeName(SensorType sensorType) {
	switch (sensorType) {
	case SensorType::Unknown:
	return "Unknown";
	case SensorType::Accelerometer:
	return "Accelerometer";
	case SensorType::InstantMotion:
	return "Instant Motion";
	case SensorType::StationaryDetect:
	return "Stationary Detect";
	case SensorType::Gyroscope:
	return "Gyroscope";
	case SensorType::GeomagneticField:
	return "Geomagnetic Field";
	case SensorType::Pressure:
	return "Pressure";
	case SensorType::Light:
	return "Light";
	case SensorType::Proximity:
	return "Proximity";
	case SensorType::AccelerometerTemperature:
	return "Accelerometer Temp";
	case SensorType::GyroscopeTemperature:
	return "Gyroscope Temp";
	case SensorType::UncalibratedAccelerometer:
	return "Uncal Accelerometer";
	case SensorType::UncalibratedGyroscope:
	return "Uncal Gyroscope";
	case SensorType::UncalibratedGeomagneticField:
	return "Uncal Geomagnetic Field";
	default:
	CHRE_ASSERT(false);
	return "";
	}
	}

	uint16_t getSampleEventTypeForSensorType(SensorType sensorType) {
	if (sensorType == SensorType::Unknown) {
	FATAL_ERROR("Tried to obtain the sensor sample event index for an unknown "
	"sensor type");
	}

	// The enum values of SensorType may not map to the defined values in the
	// CHRE API.
	uint8_t sensorTypeValue = getUnsignedIntFromSensorType(sensorType);
	return CHRE_EVENT_SENSOR_DATA_EVENT_BASE + sensorTypeValue;
	}

	SensorType getSensorTypeForSampleEventType(uint16_t eventType) {
	return getSensorTypeFromUnsignedInt(
	static_cast<uint8_t>(eventType - CHRE_EVENT_SENSOR_DATA_EVENT_BASE));
	}

	SensorType getSensorTypeFromUnsignedInt(uint8_t sensorType) {
	switch (sensorType) {
	case CHRE_SENSOR_TYPE_ACCELEROMETER:
	return SensorType::Accelerometer;
	case CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT:
	return SensorType::InstantMotion;
	case CHRE_SENSOR_TYPE_STATIONARY_DETECT:
	return SensorType::StationaryDetect;
	case CHRE_SENSOR_TYPE_GYROSCOPE:
	return SensorType::Gyroscope;
	case CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD:
	return SensorType::GeomagneticField;
	case CHRE_SENSOR_TYPE_PRESSURE:
	return SensorType::Pressure;
	case CHRE_SENSOR_TYPE_LIGHT:
	return SensorType::Light;
	case CHRE_SENSOR_TYPE_PROXIMITY:
	return SensorType::Proximity;
	case CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE:
	return SensorType::AccelerometerTemperature;
	case CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE:
	return SensorType::GyroscopeTemperature;
	case CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER:
	return SensorType::UncalibratedAccelerometer;
	case CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE:
	return SensorType::UncalibratedGyroscope;
	case CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD:
	return SensorType::UncalibratedGeomagneticField;
	default:
	return SensorType::Unknown;
	}
	}

	uint8_t getUnsignedIntFromSensorType(SensorType sensorType) {
	switch (sensorType) {
	case SensorType::Accelerometer:
	return CHRE_SENSOR_TYPE_ACCELEROMETER;
	case SensorType::InstantMotion:
	return CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT;
	case SensorType::StationaryDetect:
	return CHRE_SENSOR_TYPE_STATIONARY_DETECT;
	case SensorType::Gyroscope:
	return CHRE_SENSOR_TYPE_GYROSCOPE;
	case SensorType::GeomagneticField:
	return CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD;
	case SensorType::Pressure:
	return CHRE_SENSOR_TYPE_PRESSURE;
	case SensorType::Light:
	return CHRE_SENSOR_TYPE_LIGHT;
	case SensorType::Proximity:
	return CHRE_SENSOR_TYPE_PROXIMITY;
	case SensorType::AccelerometerTemperature:
	return CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE;
	case SensorType::GyroscopeTemperature:
	return CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE;
	case SensorType::UncalibratedAccelerometer:
	return CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER;
	case SensorType::UncalibratedGyroscope:
	return CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE;
	case SensorType::UncalibratedGeomagneticField:
	return CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD;
	default:
	// Update implementation to prevent undefined or SensorType::Unknown from
	// being used.
	CHRE_ASSERT(false);
	return 0;
	}
	}

	SensorSampleType getSensorSampleTypeFromSensorType(SensorType sensorType) {
	switch (sensorType) {
	case SensorType::Accelerometer:
	case SensorType::Gyroscope:
	case SensorType::GeomagneticField:
	case SensorType::UncalibratedAccelerometer:
	case SensorType::UncalibratedGyroscope:
	case SensorType::UncalibratedGeomagneticField:
	return SensorSampleType::ThreeAxis;
	case SensorType::Pressure:
	case SensorType::Light:
	case SensorType::AccelerometerTemperature:
	case SensorType::GyroscopeTemperature:
	return SensorSampleType::Float;
	case SensorType::InstantMotion:
	case SensorType::StationaryDetect:
	return SensorSampleType::Occurrence;
	case SensorType::Proximity:
	return SensorSampleType::Byte;
	default:
	CHRE_ASSERT(false);
	return SensorSampleType::Unknown;
	}
	}

	SensorMode getSensorModeFromEnum(enum chreSensorConfigureMode enumSensorMode) {
	switch (enumSensorMode) {
	case CHRE_SENSOR_CONFIGURE_MODE_DONE:
	return SensorMode::Off;
	case CHRE_SENSOR_CONFIGURE_MODE_CONTINUOUS:
	return SensorMode::ActiveContinuous;
	case CHRE_SENSOR_CONFIGURE_MODE_ONE_SHOT:
	return SensorMode::ActiveOneShot;
	case CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_CONTINUOUS:
	return SensorMode::PassiveContinuous;
	case CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_ONE_SHOT:
	return SensorMode::PassiveOneShot;
	default:
	// Default to off since it is the least harmful and has no power impact.
	return SensorMode::Off;
	}
	}

	bool sensorTypeIsOneShot(SensorType sensorType) {
	return (sensorType == SensorType::InstantMotion \|\|
	sensorType == SensorType::StationaryDetect);
	}

	bool sensorTypeIsOnChange(SensorType sensorType) {
	return (sensorType == SensorType::Light \|\|
	sensorType == SensorType::Proximity);
	}

	SensorRequest::SensorRequest()
	: SensorRequest(SensorMode::Off,
	Nanoseconds(CHRE_SENSOR_INTERVAL_DEFAULT),
	Nanoseconds(CHRE_SENSOR_LATENCY_DEFAULT)) {}

	SensorRequest::SensorRequest(SensorMode mode, Nanoseconds interval,
	Nanoseconds latency)
	: SensorRequest(nullptr /* nanoapp */, mode, interval, latency) {}

	SensorRequest::SensorRequest(Nanoapp *nanoapp, SensorMode mode,
	Nanoseconds interval, Nanoseconds latency)
	: mNanoapp(nanoapp), mInterval(interval), mLatency(latency), mMode(mode) {
	// cap non-default interval/latency to ensure no overflow in CHRE internal
	// operations.
	if (interval != Nanoseconds(CHRE_SENSOR_INTERVAL_DEFAULT)) {
	mInterval = std::min(interval, Nanoseconds(kMaxIntervalLatencyNs));
	}
	if (latency != Nanoseconds(CHRE_SENSOR_LATENCY_DEFAULT)) {
	mLatency = std::min(latency, Nanoseconds(kMaxIntervalLatencyNs));
	}
	}

	bool SensorRequest::isEquivalentTo(const SensorRequest& request) const {
	return (mMode == request.mMode
	&& mInterval == request.mInterval
	&& mLatency == request.mLatency);
	}

	bool SensorRequest::mergeWith(const SensorRequest& request) {
	bool attributesChanged = false;
	if (request.mMode != SensorMode::Off) {
	// Calculate minimum batch interval before mInterval is modified.
	Nanoseconds batchInterval = std::min(getBatchInterval(*this),
	getBatchInterval(request));

	if (request.mInterval < mInterval) {
	mInterval = request.mInterval;
	attributesChanged = true;
	}

	if (batchInterval == Nanoseconds(CHRE_SENSOR_BATCH_INTERVAL_DEFAULT)) {
	// If batchInterval is default, it can't be effectively calculated.
	// Use request.mLatency for more aggressive latency merging in this case.
	Nanoseconds latency = request.mLatency;
	if (latency < mLatency) {
	mLatency = latency;
	attributesChanged = true;
	}
	} else {
	Nanoseconds latency = (batchInterval - mInterval);

	// Note that while batchInterval can only shrink after merging, latency
	// can grow if the merged interval is lower.
	// Also, it's guaranteed that latency <= kMaxIntervalLatencyNs.
	if (latency != mLatency) {
	mLatency = latency;
	attributesChanged = true;
	}
	}

	// Compute the highest priority mode. Active continuous is the highest
	// priority and passive one-shot is the lowest.
	SensorMode maximalSensorMode = SensorMode::Off;
	if (mMode == SensorMode::ActiveContinuous
	\|\| request.mMode == SensorMode::ActiveContinuous) {
	maximalSensorMode = SensorMode::ActiveContinuous;
	} else if (mMode == SensorMode::ActiveOneShot
	\|\| request.mMode == SensorMode::ActiveOneShot) {
	maximalSensorMode = SensorMode::ActiveOneShot;
	} else if (mMode == SensorMode::PassiveContinuous
	\|\| request.mMode == SensorMode::PassiveContinuous) {
	maximalSensorMode = SensorMode::PassiveContinuous;
	} else if (mMode == SensorMode::PassiveOneShot
	\|\| request.mMode == SensorMode::PassiveOneShot) {
	maximalSensorMode = SensorMode::PassiveOneShot;
	} else {
	CHRE_ASSERT(false);
	}

	if (mMode != maximalSensorMode) {
	mMode = maximalSensorMode;
	attributesChanged = true;
	}
	}

	return attributesChanged;
	}

	} // namespace chre