util/nanotool/androidcontexthub.cpp - device/google/contexthub - 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 "androidcontexthub.h"

 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <time.h>
 #include <unistd.h>
 #include <sys/stat.h>

 #include <chrono>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <thread>
 #include <vector>

 #include "calibrationfile.h"
 #include "log.h"

 namespace android {

 constexpr char kSensorDeviceFile[] = "/dev/nanohub";
 constexpr char kCommsDeviceFile[] = "/dev/nanohub_comms";
 constexpr char kLockDirectory[] = "/data/vendor/sensor/nanohub_lock";
 constexpr char kLockFile[] = "/data/vendor/sensor/nanohub_lock/lock";

 constexpr mode_t kLockDirPermissions = (S_IRUSR | S_IWUSR | S_IXUSR);

 constexpr auto kLockDelay = std::chrono::milliseconds(100);

 constexpr int kDeviceFileCount = 2;
 constexpr int kPollNoTimeout = -1;

 static const std::vector<std::tuple<const char *, SensorType>> kCalibrationKeys = {
     std::make_tuple("accel",     SensorType::Accel),
     std::make_tuple("gyro",      SensorType::Gyro),
     std::make_tuple("mag",       SensorType::Magnetometer),
     std::make_tuple("proximity", SensorType::Proximity),
     std::make_tuple("barometer", SensorType::Barometer),
     std::make_tuple("light",     SensorType::AmbientLightSensor),
 };

 static void AppendBytes(const void *data, size_t length, std::vector<uint8_t>& buffer) {
     const uint8_t *bytes = (const uint8_t *) data;
     for (size_t i = 0; i < length; i++) {
         buffer.push_back(bytes[i]);
     }
 }

 static bool CopyInt32Array(const char *key,
         sp<JSONObject> json, std::vector<uint8_t>& bytes) {
     sp<JSONArray> array;
     if (json->getArray(key, &array)) {
         for (size_t i = 0; i < array->size(); i++) {
             int32_t val = 0;
             array->getInt32(i, &val);
             AppendBytes(&val, sizeof(uint32_t), bytes);
         }

         return true;
     }
     return false;
 }

 static bool CopyFloatArray(const char *key,
         sp<JSONObject> json, std::vector<uint8_t>& bytes) {
     sp<JSONArray> array;
     if (json->getArray(key, &array)) {
         for (size_t i = 0; i < array->size(); i++) {
             float val = 0;
             array->getFloat(i, &val);
             AppendBytes(&val, sizeof(float), bytes);
         }

         return true;
     }
     return false;
 }

 static bool GetCalibrationBytes(const char *key, SensorType sensor_type,
         std::vector<uint8_t>& bytes) {
     bool success = true;
     std::shared_ptr<CalibrationFile> cal_file = CalibrationFile::Instance();
     if (!cal_file) {
         return false;
     }
     auto json = cal_file->GetJSONObject();

     switch (sensor_type) {
       case SensorType::Accel:
       case SensorType::Gyro:
         success = CopyInt32Array(key, json, bytes);
         break;

       case SensorType::Magnetometer:
         success = CopyFloatArray(key, json, bytes);
         break;

       case SensorType::AmbientLightSensor:
       case SensorType::Barometer: {
         float value = 0;
         success = json->getFloat(key, &value);
         if (success) {
             AppendBytes(&value, sizeof(float), bytes);
         }
         break;
       }

       case SensorType::Proximity: {
         // Proximity might be an int32 array with 4 values (CRGB) or a single
         // int32 value - try both
         success = CopyInt32Array(key, json, bytes);
         if (!success) {
             int32_t value = 0;
             success = json->getInt32(key, &value);
             if (success) {
                 AppendBytes(&value, sizeof(int32_t), bytes);
             }
         }
         break;
       }

       default:
         // If this log message gets printed, code needs to be added in this
         // switch statement
         LOGE("Missing sensor type to calibration data mapping sensor %d",
              static_cast<int>(sensor_type));
         success = false;
     }

     return success;
 }

 AndroidContextHub::~AndroidContextHub() {
     if (unlink(kLockFile) < 0) {
         LOGE("Couldn't remove lock file: %s", strerror(errno));
     }
     if (sensor_fd_ >= 0) {
         DisableActiveSensors();
         (void) close(sensor_fd_);
     }
     if (comms_fd_ >= 0) {
         (void) close(comms_fd_);
     }
 }

 void AndroidContextHub::TerminateHandler() {
     (void) unlink(kLockFile);
 }

 bool AndroidContextHub::Initialize() {
     // Acquire a lock on nanohub, so the HAL read threads won't take our events.
     // We need to delay after creating the file to have good confidence that
     // the HALs noticed the lock file creation.
     if (access(kLockDirectory, F_OK) < 0) {
         if (mkdir(kLockDirectory, kLockDirPermissions) < 0 && errno != EEXIST) {
             LOGE("Couldn't create lock directory: %s", strerror(errno));
         }
     }
     int lock_fd = open(kLockFile, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
     if (lock_fd < 0) {
         LOGE("Couldn't create lock file: %s", strerror(errno));
         if (errno != EEXIST) {
             return false;
         }
     } else {
         close(lock_fd);
         std::this_thread::sleep_for(kLockDelay);
         LOGD("Lock sleep complete");
     }

     // Sensor device file is used for sensor requests, e.g. configure, etc., and
     // returns sensor events
     sensor_fd_ = open(kSensorDeviceFile, O_RDWR);
     if (sensor_fd_ < 0) {
         LOGE("Couldn't open device file: %s", strerror(errno));
         return false;
     }

     // The comms device file is used for more generic communication with
     // nanoapps. Calibration results are returned through this channel.
     comms_fd_ = open(kCommsDeviceFile, O_RDONLY);
     if (comms_fd_ < 0) {
         // TODO(bduddie): Currently informational only, as the kernel change
         // that adds this device file is not available/propagated yet.
         // Eventually this should be an error.
         LOGI("Couldn't open comms device file: %s", strerror(errno));
     }

     return true;
 }

 void AndroidContextHub::SetLoggingEnabled(bool logging_enabled) {
     if (logging_enabled) {
         LOGE("Logging is not supported on this platform");
     }
 }

 ContextHub::TransportResult AndroidContextHub::WriteEvent(
         const std::vector<uint8_t>& message) {
     ContextHub::TransportResult result;

     LOGD("Writing %zu bytes", message.size());
     LOGD_BUF(message.data(), message.size());
     int ret = write(sensor_fd_, message.data(), message.size());
     if (ret == -1) {
         LOGE("Couldn't write %zu bytes to device file: %s", message.size(),
              strerror(errno));
         result = TransportResult::GeneralFailure;
     } else if (ret != (int) message.size()) {
         LOGW("Write returned %d, expected %zu", ret, message.size());
         result = TransportResult::GeneralFailure;
     } else {
         LOGD("Successfully sent event");
         result = TransportResult::Success;
     }

     return result;
 }

 ContextHub::TransportResult AndroidContextHub::ReadEvent(
         std::vector<uint8_t>& message, int timeout_ms) {
     ContextHub::TransportResult result = TransportResult::GeneralFailure;

     struct pollfd pollfds[kDeviceFileCount];
     int fd_count = ResetPollFds(pollfds, kDeviceFileCount);

     int timeout = timeout_ms > 0 ? timeout_ms : kPollNoTimeout;
     int ret = poll(pollfds, fd_count, timeout);
     if (ret < 0) {
         LOGE("Polling failed: %s", strerror(errno));
         if (errno == EINTR) {
             result = TransportResult::Canceled;
         }
     } else if (ret == 0) {
         LOGD("Poll timed out");
         result = TransportResult::Timeout;
     } else {
         int read_fd = -1;
         for (int i = 0; i < kDeviceFileCount; i++) {
             if (pollfds[i].revents & POLLIN) {
                 read_fd = pollfds[i].fd;
                 break;
             }
         }

         if (read_fd == sensor_fd_) {
             LOGD("Data ready on sensors device file");
         } else if (read_fd == comms_fd_) {
             LOGD("Data ready on comms device file");
         }

         if (read_fd >= 0) {
             result = ReadEventFromFd(read_fd, message);
         } else {
             LOGE("Poll returned but none of expected files are ready");
         }
     }

     return result;
 }

 bool AndroidContextHub::FlashSensorHub(const std::vector<uint8_t>& bytes) {
     (void)bytes;
     LOGE("Flashing is not supported on this platform");
     return false;
 }

 bool AndroidContextHub::LoadCalibration() {
     std::vector<uint8_t> cal_data;
     bool success = true;

     for (size_t i = 0; success && i < kCalibrationKeys.size(); i++) {
         std::string key;
         SensorType sensor_type;

         std::tie(key, sensor_type) = kCalibrationKeys[i];
         if (GetCalibrationBytes(key.c_str(), sensor_type, cal_data)) {
             success = SendCalibrationData(sensor_type, cal_data);
         }

         cal_data.clear();
     }

     return success;
 }

 bool AndroidContextHub::SetCalibration(SensorType sensor_type, int32_t data) {
     LOGI("Setting calibration for sensor %d (%s) to %d",
          static_cast<int>(sensor_type),
          ContextHub::SensorTypeToAbbrevName(sensor_type).c_str(), data);
     auto cal_file = CalibrationFile::Instance();
     const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
     if (cal_file && key) {
         return cal_file->SetSingleAxis(key, data);
     }
     return false;
 }

 bool AndroidContextHub::SetCalibration(SensorType sensor_type, float data) {
     LOGI("Setting calibration for sensor %d (%s) to %f",
          static_cast<int>(sensor_type),
          ContextHub::SensorTypeToAbbrevName(sensor_type).c_str(), data);
     auto cal_file = CalibrationFile::Instance();
     const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
     if (cal_file && key) {
         return cal_file->SetSingleAxis(key, data);
     }
     return false;
 }

 bool AndroidContextHub::SetCalibration(SensorType sensor_type, int32_t x,
         int32_t y, int32_t z) {
     LOGI("Setting calibration for %d to %d %d %d", static_cast<int>(sensor_type),
          x, y, z);
     auto cal_file = CalibrationFile::Instance();
     const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
     if (cal_file && key) {
         return cal_file->SetTripleAxis(key, x, y, z);
     }
     return false;
 }

 bool AndroidContextHub::SetCalibration(SensorType sensor_type, int32_t x,
         int32_t y, int32_t z, int32_t w) {
     LOGI("Setting calibration for %d to %d %d %d %d", static_cast<int>(sensor_type),
          x, y, z, w);
     auto cal_file = CalibrationFile::Instance();
     const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
     if (cal_file && key) {
         return cal_file->SetFourAxis(key, x, y, z, w);
     }
     return false;
 }

 bool AndroidContextHub::SaveCalibration() {
     LOGI("Saving calibration data");
     auto cal_file = CalibrationFile::Instance();
     if (cal_file) {
         return cal_file->Save();
     }
     return false;
 }

 ContextHub::TransportResult AndroidContextHub::ReadEventFromFd(
         int fd, std::vector<uint8_t>& message) {
     ContextHub::TransportResult result = TransportResult::GeneralFailure;

     // Set the size to the maximum, so when we resize later, it's always a
     // shrink (otherwise it will end up clearing the bytes)
     message.resize(message.capacity());

     LOGD("Calling into read()");
     int ret = read(fd, message.data(), message.capacity());
     if (ret < 0) {
         LOGE("Couldn't read from device file: %s", strerror(errno));
         if (errno == EINTR) {
             result = TransportResult::Canceled;
         }
     } else if (ret == 0) {
         // We might need to handle this specially, if the driver implements this
         // to mean something specific
         LOGE("Read unexpectedly returned 0 bytes");
     } else {
         message.resize(ret);
         LOGD_VEC(message);
         result = TransportResult::Success;
     }

     return result;
 }

 int AndroidContextHub::ResetPollFds(struct pollfd *pfds, size_t count) {
     memset(pfds, 0, sizeof(struct pollfd) * count);
     pfds[0].fd = sensor_fd_;
     pfds[0].events = POLLIN;

     int nfds = 1;
     if (count > 1 && comms_fd_ >= 0) {
         pfds[1].fd = comms_fd_;
         pfds[1].events = POLLIN;
         nfds++;
     }
     return nfds;
 }

 const char *AndroidContextHub::SensorTypeToCalibrationKey(SensorType sensor_type) {
     for (size_t i = 0; i < kCalibrationKeys.size(); i++) {
         const char *key;
         SensorType sensor_type_for_key;

         std::tie(key, sensor_type_for_key) = kCalibrationKeys[i];
         if (sensor_type == sensor_type_for_key) {
             return key;
         }
     }

     LOGE("No calibration key mapping for sensor type %d",
          static_cast<int>(sensor_type));
     return nullptr;
 }

 }  // namespace android
	/*
	* 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 "androidcontexthub.h"

	#include <errno.h>
	#include <fcntl.h>
	#include <poll.h>
	#include <time.h>
	#include <unistd.h>
	#include <sys/stat.h>

	#include <chrono>
	#include <cstdint>
	#include <cstdio>
	#include <cstring>
	#include <thread>
	#include <vector>

	#include "calibrationfile.h"
	#include "log.h"

	namespace android {

	constexpr char kSensorDeviceFile[] = "/dev/nanohub";
	constexpr char kCommsDeviceFile[] = "/dev/nanohub_comms";
	constexpr char kLockDirectory[] = "/data/vendor/sensor/nanohub_lock";
	constexpr char kLockFile[] = "/data/vendor/sensor/nanohub_lock/lock";

	constexpr mode_t kLockDirPermissions = (S_IRUSR \| S_IWUSR \| S_IXUSR);

	constexpr auto kLockDelay = std::chrono::milliseconds(100);

	constexpr int kDeviceFileCount = 2;
	constexpr int kPollNoTimeout = -1;

	static const std::vector<std::tuple<const char *, SensorType>> kCalibrationKeys = {
	std::make_tuple("accel", SensorType::Accel),
	std::make_tuple("gyro", SensorType::Gyro),
	std::make_tuple("mag", SensorType::Magnetometer),
	std::make_tuple("proximity", SensorType::Proximity),
	std::make_tuple("barometer", SensorType::Barometer),
	std::make_tuple("light", SensorType::AmbientLightSensor),
	};

	static void AppendBytes(const void *data, size_t length, std::vector<uint8_t>& buffer) {
	const uint8_t bytes = (const uint8_t ) data;
	for (size_t i = 0; i < length; i++) {
	buffer.push_back(bytes[i]);
	}
	}

	static bool CopyInt32Array(const char *key,
	sp<JSONObject> json, std::vector<uint8_t>& bytes) {
	sp<JSONArray> array;
	if (json->getArray(key, &array)) {
	for (size_t i = 0; i < array->size(); i++) {
	int32_t val = 0;
	array->getInt32(i, &val);
	AppendBytes(&val, sizeof(uint32_t), bytes);
	}

	return true;
	}
	return false;
	}

	static bool CopyFloatArray(const char *key,
	sp<JSONObject> json, std::vector<uint8_t>& bytes) {
	sp<JSONArray> array;
	if (json->getArray(key, &array)) {
	for (size_t i = 0; i < array->size(); i++) {
	float val = 0;
	array->getFloat(i, &val);
	AppendBytes(&val, sizeof(float), bytes);
	}

	return true;
	}
	return false;
	}

	static bool GetCalibrationBytes(const char *key, SensorType sensor_type,
	std::vector<uint8_t>& bytes) {
	bool success = true;
	std::shared_ptr<CalibrationFile> cal_file = CalibrationFile::Instance();
	if (!cal_file) {
	return false;
	}
	auto json = cal_file->GetJSONObject();

	switch (sensor_type) {
	case SensorType::Accel:
	case SensorType::Gyro:
	success = CopyInt32Array(key, json, bytes);
	break;

	case SensorType::Magnetometer:
	success = CopyFloatArray(key, json, bytes);
	break;

	case SensorType::AmbientLightSensor:
	case SensorType::Barometer: {
	float value = 0;
	success = json->getFloat(key, &value);
	if (success) {
	AppendBytes(&value, sizeof(float), bytes);
	}
	break;
	}

	case SensorType::Proximity: {
	// Proximity might be an int32 array with 4 values (CRGB) or a single
	// int32 value - try both
	success = CopyInt32Array(key, json, bytes);
	if (!success) {
	int32_t value = 0;
	success = json->getInt32(key, &value);
	if (success) {
	AppendBytes(&value, sizeof(int32_t), bytes);
	}
	}
	break;
	}

	default:
	// If this log message gets printed, code needs to be added in this
	// switch statement
	LOGE("Missing sensor type to calibration data mapping sensor %d",
	static_cast<int>(sensor_type));
	success = false;
	}

	return success;
	}

	AndroidContextHub::~AndroidContextHub() {
	if (unlink(kLockFile) < 0) {
	LOGE("Couldn't remove lock file: %s", strerror(errno));
	}
	if (sensor_fd_ >= 0) {
	DisableActiveSensors();
	(void) close(sensor_fd_);
	}
	if (comms_fd_ >= 0) {
	(void) close(comms_fd_);
	}
	}

	void AndroidContextHub::TerminateHandler() {
	(void) unlink(kLockFile);
	}

	bool AndroidContextHub::Initialize() {
	// Acquire a lock on nanohub, so the HAL read threads won't take our events.
	// We need to delay after creating the file to have good confidence that
	// the HALs noticed the lock file creation.
	if (access(kLockDirectory, F_OK) < 0) {
	if (mkdir(kLockDirectory, kLockDirPermissions) < 0 && errno != EEXIST) {
	LOGE("Couldn't create lock directory: %s", strerror(errno));
	}
	}
	int lock_fd = open(kLockFile, O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
	if (lock_fd < 0) {
	LOGE("Couldn't create lock file: %s", strerror(errno));
	if (errno != EEXIST) {
	return false;
	}
	} else {
	close(lock_fd);
	std::this_thread::sleep_for(kLockDelay);
	LOGD("Lock sleep complete");
	}

	// Sensor device file is used for sensor requests, e.g. configure, etc., and
	// returns sensor events
	sensor_fd_ = open(kSensorDeviceFile, O_RDWR);
	if (sensor_fd_ < 0) {
	LOGE("Couldn't open device file: %s", strerror(errno));
	return false;
	}

	// The comms device file is used for more generic communication with
	// nanoapps. Calibration results are returned through this channel.
	comms_fd_ = open(kCommsDeviceFile, O_RDONLY);
	if (comms_fd_ < 0) {
	// TODO(bduddie): Currently informational only, as the kernel change
	// that adds this device file is not available/propagated yet.
	// Eventually this should be an error.
	LOGI("Couldn't open comms device file: %s", strerror(errno));
	}

	return true;
	}

	void AndroidContextHub::SetLoggingEnabled(bool logging_enabled) {
	if (logging_enabled) {
	LOGE("Logging is not supported on this platform");
	}
	}

	ContextHub::TransportResult AndroidContextHub::WriteEvent(
	const std::vector<uint8_t>& message) {
	ContextHub::TransportResult result;

	LOGD("Writing %zu bytes", message.size());
	LOGD_BUF(message.data(), message.size());
	int ret = write(sensor_fd_, message.data(), message.size());
	if (ret == -1) {
	LOGE("Couldn't write %zu bytes to device file: %s", message.size(),
	strerror(errno));
	result = TransportResult::GeneralFailure;
	} else if (ret != (int) message.size()) {
	LOGW("Write returned %d, expected %zu", ret, message.size());
	result = TransportResult::GeneralFailure;
	} else {
	LOGD("Successfully sent event");
	result = TransportResult::Success;
	}

	return result;
	}

	ContextHub::TransportResult AndroidContextHub::ReadEvent(
	std::vector<uint8_t>& message, int timeout_ms) {
	ContextHub::TransportResult result = TransportResult::GeneralFailure;

	struct pollfd pollfds[kDeviceFileCount];
	int fd_count = ResetPollFds(pollfds, kDeviceFileCount);

	int timeout = timeout_ms > 0 ? timeout_ms : kPollNoTimeout;
	int ret = poll(pollfds, fd_count, timeout);
	if (ret < 0) {
	LOGE("Polling failed: %s", strerror(errno));
	if (errno == EINTR) {
	result = TransportResult::Canceled;
	}
	} else if (ret == 0) {
	LOGD("Poll timed out");
	result = TransportResult::Timeout;
	} else {
	int read_fd = -1;
	for (int i = 0; i < kDeviceFileCount; i++) {
	if (pollfds[i].revents & POLLIN) {
	read_fd = pollfds[i].fd;
	break;
	}
	}

	if (read_fd == sensor_fd_) {
	LOGD("Data ready on sensors device file");
	} else if (read_fd == comms_fd_) {
	LOGD("Data ready on comms device file");
	}

	if (read_fd >= 0) {
	result = ReadEventFromFd(read_fd, message);
	} else {
	LOGE("Poll returned but none of expected files are ready");
	}
	}

	return result;
	}

	bool AndroidContextHub::FlashSensorHub(const std::vector<uint8_t>& bytes) {
	(void)bytes;
	LOGE("Flashing is not supported on this platform");
	return false;
	}

	bool AndroidContextHub::LoadCalibration() {
	std::vector<uint8_t> cal_data;
	bool success = true;

	for (size_t i = 0; success && i < kCalibrationKeys.size(); i++) {
	std::string key;
	SensorType sensor_type;

	std::tie(key, sensor_type) = kCalibrationKeys[i];
	if (GetCalibrationBytes(key.c_str(), sensor_type, cal_data)) {
	success = SendCalibrationData(sensor_type, cal_data);
	}

	cal_data.clear();
	}

	return success;
	}

	bool AndroidContextHub::SetCalibration(SensorType sensor_type, int32_t data) {
	LOGI("Setting calibration for sensor %d (%s) to %d",
	static_cast<int>(sensor_type),
	ContextHub::SensorTypeToAbbrevName(sensor_type).c_str(), data);
	auto cal_file = CalibrationFile::Instance();
	const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
	if (cal_file && key) {
	return cal_file->SetSingleAxis(key, data);
	}
	return false;
	}

	bool AndroidContextHub::SetCalibration(SensorType sensor_type, float data) {
	LOGI("Setting calibration for sensor %d (%s) to %f",
	static_cast<int>(sensor_type),
	ContextHub::SensorTypeToAbbrevName(sensor_type).c_str(), data);
	auto cal_file = CalibrationFile::Instance();
	const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
	if (cal_file && key) {
	return cal_file->SetSingleAxis(key, data);
	}
	return false;
	}

	bool AndroidContextHub::SetCalibration(SensorType sensor_type, int32_t x,
	int32_t y, int32_t z) {
	LOGI("Setting calibration for %d to %d %d %d", static_cast<int>(sensor_type),
	x, y, z);
	auto cal_file = CalibrationFile::Instance();
	const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
	if (cal_file && key) {
	return cal_file->SetTripleAxis(key, x, y, z);
	}
	return false;
	}

	bool AndroidContextHub::SetCalibration(SensorType sensor_type, int32_t x,
	int32_t y, int32_t z, int32_t w) {
	LOGI("Setting calibration for %d to %d %d %d %d", static_cast<int>(sensor_type),
	x, y, z, w);
	auto cal_file = CalibrationFile::Instance();
	const char *key = AndroidContextHub::SensorTypeToCalibrationKey(sensor_type);
	if (cal_file && key) {
	return cal_file->SetFourAxis(key, x, y, z, w);
	}
	return false;
	}

	bool AndroidContextHub::SaveCalibration() {
	LOGI("Saving calibration data");
	auto cal_file = CalibrationFile::Instance();
	if (cal_file) {
	return cal_file->Save();
	}
	return false;
	}

	ContextHub::TransportResult AndroidContextHub::ReadEventFromFd(
	int fd, std::vector<uint8_t>& message) {
	ContextHub::TransportResult result = TransportResult::GeneralFailure;

	// Set the size to the maximum, so when we resize later, it's always a
	// shrink (otherwise it will end up clearing the bytes)
	message.resize(message.capacity());

	LOGD("Calling into read()");
	int ret = read(fd, message.data(), message.capacity());
	if (ret < 0) {
	LOGE("Couldn't read from device file: %s", strerror(errno));
	if (errno == EINTR) {
	result = TransportResult::Canceled;
	}
	} else if (ret == 0) {
	// We might need to handle this specially, if the driver implements this
	// to mean something specific
	LOGE("Read unexpectedly returned 0 bytes");
	} else {
	message.resize(ret);
	LOGD_VEC(message);
	result = TransportResult::Success;
	}

	return result;
	}

	int AndroidContextHub::ResetPollFds(struct pollfd *pfds, size_t count) {
	memset(pfds, 0, sizeof(struct pollfd) * count);
	pfds[0].fd = sensor_fd_;
	pfds[0].events = POLLIN;

	int nfds = 1;
	if (count > 1 && comms_fd_ >= 0) {
	pfds[1].fd = comms_fd_;
	pfds[1].events = POLLIN;
	nfds++;
	}
	return nfds;
	}

	const char *AndroidContextHub::SensorTypeToCalibrationKey(SensorType sensor_type) {
	for (size_t i = 0; i < kCalibrationKeys.size(); i++) {
	const char *key;
	SensorType sensor_type_for_key;

	std::tie(key, sensor_type_for_key) = kCalibrationKeys[i];
	if (sensor_type == sensor_type_for_key) {
	return key;
	}
	}

	LOGE("No calibration key mapping for sensor type %d",
	static_cast<int>(sensor_type));
	return nullptr;
	}

	} // namespace android