android-7.0.0_r1.0/s

/*
 * 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 <getopt.h>
#include <signal.h>

#include <cstdlib>
#include <cstring>
#include <memory>
#include <sstream>
#include <tuple>
#include <vector>

#include "contexthub.h"
#include "log.h"

#ifdef __ANDROID__
#include "androidcontexthub.h"
#else
#include "cp2130.h"
#include "usbcontext.h"
#include "usbcontexthub.h"
#endif

using namespace android;

enum class NanotoolCommand {
    Invalid,
    Disable,
    DisableAll,
    Calibrate,
    Read,
    Poll,
    LoadCalibration,
    Flash,
};

struct ParsedArgs {
    NanotoolCommand command = NanotoolCommand::Poll;
    std::vector<SensorSpec> sensors;
    int count = 0;
    bool logging_enabled = false;
    std::string filename;
    int device_index = 0;
};

static NanotoolCommand StrToCommand(const char *command_name) {
    static const std::vector<std::tuple<std::string, NanotoolCommand>> cmds = {
        std::make_tuple("disable",     NanotoolCommand::Disable),
        std::make_tuple("disable_all", NanotoolCommand::DisableAll),
        std::make_tuple("calibrate",   NanotoolCommand::Calibrate),
        std::make_tuple("cal",         NanotoolCommand::Calibrate),
        std::make_tuple("read",        NanotoolCommand::Read),
        std::make_tuple("poll",        NanotoolCommand::Poll),
        std::make_tuple("load_cal",    NanotoolCommand::LoadCalibration),
        std::make_tuple("flash",       NanotoolCommand::Flash),
    };

    if (!command_name) {
        return NanotoolCommand::Invalid;
    }

    for (size_t i = 0; i < cmds.size(); i++) {
        std::string name;
        NanotoolCommand cmd;

        std::tie(name, cmd) = cmds[i];
        if (name.compare(command_name) == 0) {
            return cmd;
        }
    }

    return NanotoolCommand::Invalid;
}

static void PrintUsage(const char *name) {
    const char *help_text =
        "options:\n"
        "  -x, --cmd          Argument must be one of:\n"
        "                        disable: send a disable request for one sensor\n"
        "                        disable_all: send a disable request for all sensors\n"
        "                        calibrate: disable the sensor, then perform the sensor\n"
        "                           calibration routine\n"
        "                        load_cal: send data from calibration file to hub\n"
        "                        read: output events for the given sensor, or all events\n"
        "                           if no sensor specified\n"
        "                        poll (default): enable the sensor, output received\n"
        "                           events, then disable the sensor before exiting\n"
        "                        flash: Load a new firmware image to the hub\n"
        "\n"
        "  -s, --sensor       Specify sensor type, and parameters for the command.\n"
        "                     Format is sensor_type[:rate[:latency_ms]][=cal_ref].\n"
        "                     See below for a complete list sensor types. A rate is\n"
        "                     required when enabling a sensor, but latency is optional\n"
        "                     and defaults to 0. Rate can be specified in Hz, or as one\n"
        "                     of the special values \"onchange\", \"ondemand\", or\n"
        "                     \"oneshot\".\n"
        "                     Some sensors require a ground truth value for calibration.\n"
        "                     Use the cal_ref parameter for this purpose (it's parsed as\n"
        "                     a float).\n"
        "                     This argument can be repeated to perform a command on\n"
        "                     multiple sensors.\n"
        "\n"
        "  -c, --count        Number of samples to read before exiting, or set to 0 to\n"
        "                     read indefinitely (the default behavior)\n"
        "\n"
        "  -f, --file\n"
        "                     Specifies the file to be used with flash.\n"
        "\n"
        "  -l, --log          Outputs logs from the sensor hub as they become available.\n"
        "                     The logs will be printed inline with sensor samples.\n"
        "                     The default is for log messages to be ignored.\n"
#ifndef __ANDROID__
        // This option is only applicable when connecting over USB
        "\n"
        "  -i, --index        Selects the device to work with by specifying the index\n"
        "                     into the device list (default: 0)\n"
#endif
        "\n"
        "  -v, -vv            Output verbose/extra verbose debugging information\n";

    fprintf(stderr, "%s %s\n\n", name, NANOTOOL_VERSION_STR);
    fprintf(stderr, "Usage: %s [options]\n\n%s\n", name, help_text);
    fprintf(stderr, "Supported sensors: %s\n\n",
            ContextHub::ListAllSensorAbbrevNames().c_str());
    fprintf(stderr, "Examples:\n"
                    "  %s -s accel:50\n"
                    "  %s -s accel:50:1000 -s gyro:50:1000\n"
                    "  %s -s prox:onchange\n"
                    "  %s -x calibrate -s baro=1000\n",
            name, name, name, name);
}

/*
 * Performs higher-level argument validation beyond just parsing the parameters,
 * for example check whether a required argument is present when the command is
 * set to a specific value.
 */
static bool ValidateArgs(std::unique_ptr<ParsedArgs>& args, const char *name) {
    if (!args->sensors.size()
          && (args->command == NanotoolCommand::Disable
                || args->command == NanotoolCommand::Calibrate
                || args->command == NanotoolCommand::Poll)) {
        fprintf(stderr, "%s: At least 1 sensor must be specified for this "
                        "command (use -s)\n",
                name);
        return false;
    }

    if (args->command == NanotoolCommand::Flash
            && args->filename.empty()) {
        fprintf(stderr, "%s: A filename must be specified for this command "
                        "(use -f)\n",
                name);
        return false;
    }

    if (args->command == NanotoolCommand::Poll) {
        for (unsigned int i = 0; i < args->sensors.size(); i++) {
            if (args->sensors[i].special_rate == SensorSpecialRate::None
                  && args->sensors[i].rate_hz < 0) {
                fprintf(stderr, "%s: Sample rate must be specified for sensor "
                        "%s\n", name,
                        ContextHub::SensorTypeToAbbrevName(
                            args->sensors[i].sensor_type).c_str());
                return false;
            }
        }
    }

    if (args->command == NanotoolCommand::Calibrate) {
        for (unsigned int i = 0; i < args->sensors.size(); i++) {
            if (!args->sensors[i].have_cal_ref
                  && (args->sensors[i].sensor_type == SensorType::Barometer
                        || args->sensors[i].sensor_type ==
                             SensorType::AmbientLightSensor)) {
                fprintf(stderr, "%s: Calibration reference required for sensor "
                                "%s (for example: -s baro=1000)\n", name,
                        ContextHub::SensorTypeToAbbrevName(
                            args->sensors[i].sensor_type).c_str());
                return false;
            }
        }
    }

    return true;
}

static bool ParseRate(const std::string& param, SensorSpec& spec) {
    static const std::vector<std::tuple<std::string, SensorSpecialRate>> rates = {
        std::make_tuple("ondemand", SensorSpecialRate::OnDemand),
        std::make_tuple("onchange", SensorSpecialRate::OnChange),
        std::make_tuple("oneshot",  SensorSpecialRate::OneShot),
    };

    for (size_t i = 0; i < rates.size(); i++) {
        std::string name;
        SensorSpecialRate rate;

        std::tie(name, rate) = rates[i];
        if (param == name) {
            spec.special_rate = rate;
            return true;
        }
    }

    spec.rate_hz = std::stof(param);
    if (spec.rate_hz < 0) {
        return false;
    }

    return true;
}

// Parse a sensor argument in the form of "sensor_name[:rate[:latency]][=cal_ref]"
// into a SensorSpec, and add it to ParsedArgs.
static bool ParseSensorArg(std::vector<SensorSpec>& sensors, const char *arg_str,
        const char *name) {
    SensorSpec spec;
    std::string param;
    std::string pre_cal_ref;
    std::stringstream full_arg_ss(arg_str);
    unsigned int index = 0;

    while (std::getline(full_arg_ss, param, '=')) {
        if (index == 0) {
            pre_cal_ref = param;
        } else if (index == 1) {
            spec.cal_ref = std::stof(param);
            spec.have_cal_ref = true;
        } else {
            fprintf(stderr, "%s: Only one calibration reference may be "
                            "supplied\n", name);
            return false;
        }
        index++;
    }

    index = 0;
    std::stringstream pre_cal_ref_ss(pre_cal_ref);
    while (std::getline(pre_cal_ref_ss, param, ':')) {
        if (index == 0) { // Parse sensor type
            spec.sensor_type = ContextHub::SensorAbbrevNameToType(param);
            if (spec.sensor_type == SensorType::Invalid_) {
                fprintf(stderr, "%s: Invalid sensor name '%s'\n",
                        name, param.c_str());
                return false;
            }
        } else if (index == 1) { // Parse sample rate
            if (!ParseRate(param, spec)) {
                fprintf(stderr, "%s: Invalid sample rate %s\n", name,
                        param.c_str());
                return false;
            }
        } else if (index == 2) { // Parse latency
            long long latency_ms = std::stoll(param);
            if (latency_ms < 0) {
                fprintf(stderr, "%s: Invalid latency %lld\n", name, latency_ms);
                return false;
            }
            spec.latency_ns = static_cast<uint64_t>(latency_ms) * 1000000;
        } else {
            fprintf(stderr, "%s: Too many arguments in -s", name);
            return false;
        }
        index++;
    }

    sensors.push_back(spec);
    return true;
}

static std::unique_ptr<ParsedArgs> ParseArgs(int argc, char **argv) {
    static const struct option long_opts[] = {
        {"cmd",     required_argument, nullptr, 'x'},
        {"sensor",  required_argument, nullptr, 's'},
        {"count",   required_argument, nullptr, 'c'},
        {"flash",   required_argument, nullptr, 'f'},
        {"log",     no_argument,       nullptr, 'l'},
        {"index",   required_argument, nullptr, 'i'},
    };

    auto args = std::unique_ptr<ParsedArgs>(new ParsedArgs());
    int index = 0;
    while (42) {
        int c = getopt_long(argc, argv, "x:s:c:f:v::li:", long_opts, &index);
        if (c == -1) {
            break;
        }

        switch (c) {
          case 'x': {
            args->command = StrToCommand(optarg);
            if (args->command == NanotoolCommand::Invalid) {
                fprintf(stderr, "%s: Invalid command '%s'\n", argv[0], optarg);
                return nullptr;
            }
            break;
          }
          case 's': {
            if (!ParseSensorArg(args->sensors, optarg, argv[0])) {
                return nullptr;
            }
            break;
          }
          case 'c': {
            args->count = atoi(optarg);
            if (args->count < 0) {
                fprintf(stderr, "%s: Invalid sample count %d\n",
                        argv[0], args->count);
                return nullptr;
            }
            break;
          }
          case 'v': {
            if (optarg && optarg[0] == 'v') {
                Log::SetLevel(Log::LogLevel::Debug);
            } else {
                Log::SetLevel(Log::LogLevel::Info);
            }
            break;
          }
          case 'l': {
            args->logging_enabled = true;
            break;
          }
          case 'f': {
            if (optarg) {
                args->filename = std::string(optarg);
            } else {
                fprintf(stderr, "File requires a filename\n");
                return nullptr;
            }
            break;
          }
          case 'i': {
            args->device_index = atoi(optarg);
            if (args->device_index < 0) {
                fprintf(stderr, "%s: Invalid device index %d\n", argv[0],
                        args->device_index);
                return nullptr;
            }
            break;
          }
          default:
            return nullptr;
        }
    }

    if (!ValidateArgs(args, argv[0])) {
        return nullptr;
    }
    return args;
}

static std::unique_ptr<ContextHub> GetContextHub(std::unique_ptr<ParsedArgs>& args) {
#ifdef __ANDROID__
    (void) args;
    return std::unique_ptr<AndroidContextHub>(new AndroidContextHub());
#else
    return std::unique_ptr<UsbContextHub>(new UsbContextHub(args->device_index));
#endif
}

#ifdef __ANDROID__
static void SignalHandler(int sig) {
    // Catches a signal and does nothing, to allow any pending syscalls to be
    // exited with SIGINT and normal cleanup to occur. If SIGINT is sent a
    // second time, the system will invoke the standard handler.
    (void) sig;
}

static void TerminateHandler() {
    AndroidContextHub::TerminateHandler();
    std::abort();
}

static void SetHandlers() {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = SignalHandler;
    sigaction(SIGINT, &sa, NULL);

    std::set_terminate(TerminateHandler);
}
#endif

int main(int argc, char **argv) {
    Log::Initialize(new PrintfLogger(), Log::LogLevel::Warn);

    // If no arguments given, print usage without any error messages
    if (argc == 1) {
        PrintUsage(argv[0]);
        return 1;
    }

    std::unique_ptr<ParsedArgs> args = ParseArgs(argc, argv);
    if (!args) {
        PrintUsage(argv[0]);
        return 1;
    }

#ifdef __ANDROID__
    SetHandlers();
#endif

    std::unique_ptr<ContextHub> hub = GetContextHub(args);
    if (!hub || !hub->Initialize()) {
        LOGE("Error initializing ContextHub");
        return -1;
    }

    hub->SetLoggingEnabled(args->logging_enabled);

    bool success = true;
    switch (args->command) {
      case NanotoolCommand::Disable:
        success = hub->DisableSensors(args->sensors);
        break;
      case NanotoolCommand::DisableAll:
        success = hub->DisableAllSensors();
        break;
      case NanotoolCommand::Read: {
        if (!args->sensors.size()) {
            hub->PrintAllEvents(args->count);
        } else {
            hub->PrintSensorEvents(args->sensors, args->count);
        }
        break;
      }
      case NanotoolCommand::Poll: {
        success = hub->EnableSensors(args->sensors);
        if (success) {
            hub->PrintSensorEvents(args->sensors, args->count);
        }
        break;
      }
      case NanotoolCommand::Calibrate: {
        hub->DisableSensors(args->sensors);
        success = hub->CalibrateSensors(args->sensors);
        break;
      }
      case NanotoolCommand::LoadCalibration: {
        success = hub->LoadCalibration();
        break;
      }
      case NanotoolCommand::Flash: {
        success = hub->Flash(args->filename);
        break;
      }
      default:
        LOGE("Command not implemented");
        return 1;
    }

    if (!success) {
        LOGE("Command failed");
        return -1;
    } else if (args->command != NanotoolCommand::Read
                   && args->command != NanotoolCommand::Poll) {
        printf("Operation completed successfully\n");
    }

    return 0;
}