android/skin/qt/extended-pages/location-page.cpp

// Copyright (C) 2015 The Android Open Source Project
//
// This software is licensed under the terms of the GNU General Public
// License version 2, as published by the Free Software Foundation, and
// may be copied, distributed, and modified under those terms.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

#include "android/skin/qt/extended-pages/location-page.h"

#include "android/emulation/control/location_agent.h"
#include "android/gps/GpxParser.h"
#include "android/gps/KmlParser.h"
#include "android/metrics/MetricsReporter.h"
#include "android/metrics/proto/studio_stats.pb.h"
#include "android/settings-agent.h"
#include "android/skin/qt/error-dialog.h"
#include "android/skin/qt/extended-pages/common.h"
#include "android/skin/qt/qt-settings.h"

#include <QFileDialog>
#include <QSettings>
#include <unistd.h>

static const double kGplexLon = -122.084;
static const double kGplexLat =   37.422;

LocationPage::LocationPage(QWidget *parent) :
    QWidget(parent),
    mUi(new Ui::LocationPage),
    mNowLoadingGeoData(false),
    mGeoDataLoadingStopRequested(false)
{
    mUi->setupUi(this);
    mNowPlaying = false;
    mTimer.setSingleShot(true);

    // We can only send 1 decimal of altitude (in meters).
    mAltitudeValidator.setNotation(QDoubleValidator::StandardNotation);
    mAltitudeValidator.setRange(-1000, 10000, 1);
    mAltitudeValidator.setLocale(QLocale::C);
    mUi->loc_altitudeInput->setValidator(&mAltitudeValidator);

    mUi->loc_latitudeInput->setMinValue(-90.0);
    mUi->loc_latitudeInput->setMaxValue(90.0);
    QObject::connect(&mTimer, &QTimer::timeout, this, &LocationPage::timeout);
    QObject::connect(this, &LocationPage::locationUpdateRequired,
                     this, &LocationPage::updateDisplayedLocation);
    setButtonEnabled(mUi->loc_playStopButton, getSelectedTheme(), false);

    // Restore previous values. If there are no previous values, use the
    // Googleplex's longitude and latitude.
    QSettings settings;
    double altValue = settings.value(Ui::Settings::LOCATION_ENTERED_ALTITUDE, 0.0).toDouble();
    mUi->loc_altitudeInput->setText( QString::number(altValue, 'f', 1) );
    mUi->loc_longitudeInput->setValue(
            settings.value(Ui::Settings::LOCATION_ENTERED_LONGITUDE, kGplexLon).toDouble());
    mUi->loc_latitudeInput->setValue(
            settings.value(Ui::Settings::LOCATION_ENTERED_LATITUDE, kGplexLat).toDouble());
    mUi->loc_playbackSpeed->setCurrentIndex(
            settings.value(Ui::Settings::LOCATION_PLAYBACK_SPEED, 0).toInt());
    QString location_data_file =
        settings.value(Ui::Settings::LOCATION_PLAYBACK_FILE, "").toString();
    mUi->loc_pathTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    mGeoDataLoader = GeoDataLoaderThread::newInstance(
            this,
            SLOT(geoDataThreadStarted()),
            SLOT(startupGeoDataThreadFinished(QString, bool, QString)));
    mGeoDataLoader->loadGeoDataFromFile(location_data_file, &mGpsFixesArray);

    using android::metrics::PeriodicReporter;
    mMetricsReportingToken = PeriodicReporter::get().addCancelableTask(
            60 * 10 * 1000,  // reporting period
            [this](android_studio::AndroidStudioEvent* event) {
                if (mLocationUsed) {
                    event->mutable_emulator_details()
                            ->mutable_used_features()
                            ->set_gps(true);
                    mMetricsReportingToken.reset();  // Report it only once.
                    return true;
                }
                return false;
    });
}

LocationPage::~LocationPage() {
    if (mGeoDataLoader != nullptr) {
        // If there's a loader thread running in the background,
        // ignore all signals from it and wait for it to finish.
        mGeoDataLoader->blockSignals(true);
        mGeoDataLoader->wait();
    }
}

void LocationPage::setLocationAgent(const QAndroidLocationAgent* agent) {
    mLocationAgent = agent;

    // Show the user the device's current location.
    double curLat, curLon, curAlt;
    getDeviceLocation(mLocationAgent, &curLat, &curLon, &curAlt);

    sendLocationToDevice(mLocationAgent, curLat, curLon, curAlt);

    // We cannot update the UI here because we are not called from
    // the Qt thread. Emit a signal to do that update.
    emit locationUpdateRequired(curLat, curLon, curAlt);
}

void LocationPage::on_loc_GpxKmlButton_clicked()
{
    // Use dialog to get file name
    QString fileName = QFileDialog::getOpenFileName(this, tr("Open GPX or KML File"), ".",
                                                    tr("GPX and KML files (*.gpx *.kml)"));

    if (fileName.isNull()) return;

    // Asynchronously parse the file with geo data.
    // If the file is big enough, parsing it synchronously will cause a noticeable
    // hiccup in the UI.
    mGeoDataLoader = GeoDataLoaderThread::newInstance(this,
                                                      SLOT(geoDataThreadStarted()),
                                                      SLOT(geoDataThreadFinished(QString, bool, QString)));
    mGeoDataLoader->loadGeoDataFromFile(fileName, &mGpsFixesArray);
}

void LocationPage::on_loc_pathTable_cellChanged(int row, int col)
{
    // If the cell's contents are bad, turn the cell red
    QString outErrorMessage;
    bool cellOK = validateCell(mUi->loc_pathTable, row, col, &outErrorMessage);
    QColor normalColor =
        getSelectedTheme() == SETTINGS_THEME_LIGHT ? Qt::black : Qt::white;
    QColor newColor = (cellOK ? normalColor : Qt::red);
    mUi->loc_pathTable->item(row, col)->setForeground(QBrush(newColor));
}

void LocationPage::on_loc_playStopButton_clicked() {
    mLocationUsed = true;
    if (mNowPlaying) {
        locationPlaybackStop();
    } else {
        locationPlaybackStart();
    }
}

void LocationPage::on_loc_modeSwitch_currentIndexChanged(int index) {
    if (index == 1) {
        mUi->loc_latitudeInput->setInputMode(AngleInputWidget::InputMode::Sexagesimal);
        mUi->loc_longitudeInput->setInputMode(AngleInputWidget::InputMode::Sexagesimal);
    } else {
        mUi->loc_latitudeInput->setInputMode(AngleInputWidget::InputMode::Decimal);
        mUi->loc_longitudeInput->setInputMode(AngleInputWidget::InputMode::Decimal);
    }
}

void LocationPage::on_loc_sendPointButton_clicked() {
    mLocationUsed = true;
    mUi->loc_latitudeInput->forceUpdate();
    mUi->loc_longitudeInput->forceUpdate();

    double altitude = mUi->loc_altitudeInput->text().toDouble();
    if (altitude < -1000.0 || altitude > 10000.0) {
        QSettings settings;
        mUi->loc_altitudeInput->setText(QString::number(
                settings.value(Ui::Settings::LOCATION_ENTERED_ALTITUDE, 0.0)
                        .toDouble()));
    }

    updateDisplayedLocation(mUi->loc_latitudeInput->value(),
                            mUi->loc_longitudeInput->value(),
                            mUi->loc_altitudeInput->text().toDouble());

    sendLocationToDevice(mLocationAgent,
                         mUi->loc_latitudeInput->value(),
                         mUi->loc_longitudeInput->value(),
                         mUi->loc_altitudeInput->text().toDouble());
}

void LocationPage::updateDisplayedLocation(double lat, double lon, double alt) {
    QString curLoc = tr("Longitude: %1\nLatitude: %2\nAltitude: %3")
                     .arg(lon, 0, 'f', 4).arg(lat, 0, 'f', 4).arg(alt, 0, 'f', 1);
    mUi->loc_currentLoc->setPlainText(curLoc);
}

void LocationPage::on_loc_longitudeInput_valueChanged(double value) {
    QSettings settings;
    settings.setValue(Ui::Settings::LOCATION_ENTERED_LONGITUDE, value);
}

void LocationPage::on_loc_latitudeInput_valueChanged(double value) {
    QSettings settings;
    settings.setValue(Ui::Settings::LOCATION_ENTERED_LATITUDE, value);
}

void LocationPage::on_loc_altitudeInput_editingFinished() {
    QSettings settings;
    settings.setValue(Ui::Settings::LOCATION_ENTERED_ALTITUDE,
                      mUi->loc_altitudeInput->text().toDouble());
}

void LocationPage::on_loc_playbackSpeed_currentIndexChanged(int index) {
    QSettings settings;
    settings.setValue(Ui::Settings::LOCATION_PLAYBACK_SPEED, index);
}

bool LocationPage::validateCell(QTableWidget* table,
                                int row,
                                int col,
                                QString* outErrorMessage) {
    QTableWidgetItem *theItem;
    double cellValue;
    bool cellOK = true;

    // The entry is a number. Check its range.
    switch (col) {
        case 0: // Delay
            theItem = table->item(row, col);
            cellValue = theItem->text().toDouble(&cellOK); // Sets 'cellOK'
            if (!cellOK) {
                *outErrorMessage = tr("Delay must be a number.");
                return false;
            }
            // Except for the first entry, the delay must be >= 1 millisecond
            if (row != 0 && cellValue < 0.001) {
                *outErrorMessage =
                        tr("Delay must be >= 1 millisecond with the exception "
                           "of the first entry.");
                cellOK = false;
            }
            break;
        case 1: // Latitude
            theItem = table->item(row, col);
            cellValue = theItem->text().toDouble(&cellOK); // Sets 'cellOK'
            if (!cellOK) {
                *outErrorMessage = tr("Latitude must be a number.");
                return false;
            }
            if (cellValue < -90.0 || cellValue > 90.0) {
                *outErrorMessage =
                        tr("Latitude must be between -90 and 90, inclusive.");
                cellOK = false;
            }
            break;
        case 2: // Longitude
            theItem = table->item(row, col);
            cellValue = theItem->text().toDouble(&cellOK); // Sets 'cellOK'
            if (!cellOK) {
                *outErrorMessage = tr("Longitude must be a number.");
                return false;
            }
            if (cellValue < -180.0 || cellValue > 180.0) {
                *outErrorMessage = tr(
                        "Longitude must be between -180 and 180, inclusive.");
                cellOK = false;
            }
            break;
        case 3: // Elevation
            theItem = table->item(row, col);
            cellValue = theItem->text().toDouble(&cellOK); // Sets 'cellOK'
            if (!cellOK) {
                *outErrorMessage = tr("Elevation must be a number.");
                return false;
            }
            if (cellValue < -1000.0 || cellValue > 10000.0) {
                *outErrorMessage = tr(
                        "Altitude must be between -1000 and 10000, inclusive.");
                cellOK = false;
            }
            break;
        default:
            // Name, description: Anything is OK
            cellOK = true;
            break;
    }
    return cellOK;
}


static QTableWidgetItem* itemForTable(const QString& text) {
    QTableWidgetItem* item = new QTableWidgetItem(text);
    item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
    return item;
}

void LocationPage::populateTable(GpsFixArray* fixes)
{
    // Delete all rows in table
    mUi->loc_pathTable->setRowCount(0);

    if (fixes->size() > 0) {
        // Special case, the first row will have delay 0
        time_t previousTime = fixes->at(0).time;
        mUi->loc_pathTable->setRowCount(fixes->size());
        mUi->loc_pathTable->blockSignals(true);
        for (unsigned i = 0; !mGeoDataLoadingStopRequested && i < fixes->size(); i++) {
            GpsFix &fix = fixes->at(i);
            time_t delay = fix.time - previousTime; // In seconds

            // Ensure all other delays are > 0, even if multiple points have the same timestamp
            if (delay == 0 && i != 0) {
                delay = 2;
            }

            mUi->loc_pathTable->setItem(i, 0, itemForTable(QString::number(delay)));
            mUi->loc_pathTable->setItem(i, 1, itemForTable(QString::number(fix.latitude)));
            mUi->loc_pathTable->setItem(i, 2, itemForTable(QString::number(fix.longitude)));
            mUi->loc_pathTable->setItem(i, 3, itemForTable(QString::number(fix.elevation)));
            mUi->loc_pathTable->setItem(i, 4, itemForTable(QString::fromStdString(fix.name)));
            mUi->loc_pathTable->setItem(i, 5, itemForTable(QString::fromStdString(fix.description)));

            // If the fixes array contains a lot of elements, this loop can cause
            // a lag in the UI. Just make sure we let the application handle UI
            // events for every few rows we add.
            if (i % 100 == 0) {
                qApp->processEvents();
            }
            previousTime = fix.time;
        }
        mUi->loc_pathTable->blockSignals(false);
        setButtonEnabled(mUi->loc_playStopButton, getSelectedTheme(), true);
    } else {
        setButtonEnabled(mUi->loc_playStopButton, getSelectedTheme(), false);
    }
}

void LocationPage::locationPlaybackStart()
{
    if (mUi->loc_pathTable->rowCount() <= 0) {
        return;
    }

    // Validate all the values in the table.
    QString outErrorMessage;
    for (int row = 0; row < mUi->loc_pathTable->rowCount(); row++) {
        for (int col = 0; col < mUi->loc_pathTable->columnCount(); col++) {
            if (!validateCell(mUi->loc_pathTable, row, col, &outErrorMessage)) {
                mUi->loc_pathTable->setCurrentCell(row, col);
                showErrorDialog(tr("The table contains errors.No locations "
                                   "were sent.<br/>Error: %1")
                                        .arg(outErrorMessage),
                                tr("GPS Playback"));
                return;
            }
        }
    }

    mRowToSend = std::max(0, mUi->loc_pathTable->currentRow());

    SettingsTheme theme = getSelectedTheme();

    // Disable editing the data in the table while playback is in progress.
    mUi->loc_pathTable->setEditTriggers(QAbstractItemView::NoEditTriggers);

    // Disable loading a new dataset while playback is in progress.
    setButtonEnabled(mUi->loc_GpxKmlButton,  theme, false);

    // Change the icon on the play/stop button.
    mUi->loc_playStopButton->setIcon(getIconForCurrentTheme("stop"));
    mUi->loc_playStopButton->setProperty("themeIconName", "stop");


    // The timer will be triggered for the first row after this
    // function returns.
    mTimer.setInterval(0);
    mTimer.start();
    mNowPlaying = true;
}

void LocationPage::locationPlaybackStop()
{
    mTimer.stop();
    if (mRowToSend > 0 &&
        mRowToSend <= mUi->loc_pathTable->rowCount()) {
        if (mRowToSend == mUi->loc_pathTable->rowCount()) {
            mUi->loc_pathTable->setCurrentItem(nullptr);
        }
        mUi->loc_pathTable->item(mRowToSend - 1, 0)->setIcon(QIcon());
    }
    mRowToSend = -1;
    SettingsTheme theme = getSelectedTheme();
    setButtonEnabled(mUi->loc_GpxKmlButton,  theme, true);
    mUi->loc_playStopButton->setIcon(getIconForCurrentTheme("play_arrow"));
    mUi->loc_playStopButton->setProperty("themeIconName", "play_arrow");
    mUi->loc_pathTable->setEditTriggers(QAbstractItemView::DoubleClicked |
                                                QAbstractItemView::EditKeyPressed |
                                                QAbstractItemView::AnyKeyPressed);
    mNowPlaying = false;
}


void LocationPage::timeout() {
    bool cellOK;
    QTableWidgetItem *theItem;

    // Check if we've reached the end of the dataset.
    if (mRowToSend < 0  ||
        mRowToSend >= mUi->loc_pathTable->rowCount()) {
        // No more to send. Same as clicking Stop.
        locationPlaybackStop();
        return;
    }

    // Get the data for the point we're about to send.
    theItem = mUi->loc_pathTable->item(mRowToSend, 1);
    double lat = theItem->text().toDouble(&cellOK);
    theItem = mUi->loc_pathTable->item(mRowToSend, 2);
    double lon = theItem->text().toDouble(&cellOK);
    theItem = mUi->loc_pathTable->item(mRowToSend, 3);
    double alt = theItem->text().toDouble(&cellOK);

    // Update the appearance of the table:
    // 1. Clear the "play arrow" icon from the previous point, if necessary.
    // 2. Set the "play arrow" icon near the point we're about to send.
    // 3. Scroll to the point that is being sent.
    // 4. Make it selected.
    if (mRowToSend > 0) {
        mUi->loc_pathTable->item(mRowToSend - 1, 0)->setIcon(QIcon());
    }
    QTableWidgetItem* currentItem = mUi->loc_pathTable->item(mRowToSend, 0);
    currentItem->setIcon(getIconForCurrentTheme("play_arrow"));
    mUi->loc_pathTable->scrollToItem(currentItem);
    mUi->loc_pathTable->setCurrentItem(currentItem);

    updateDisplayedLocation(lat, lon, alt);

    // Send the command.
    sendLocationToDevice(mLocationAgent, lat, lon, alt);

    // Go on to the next row
    mRowToSend++;
    if (mRowToSend >= mUi->loc_pathTable->rowCount()) {
        // No more to send. Same as clicking Stop.
        locationPlaybackStop();
    } else {
        // Set a timer for when this row should be sent
        theItem = mUi->loc_pathTable->item(mRowToSend, 0);
        double dTime = theItem->text().toDouble();
        int mSec = dTime * 1000.0;
        if (mSec < 0) mSec = 0;
        mTimer.setInterval(
                mSec / static_cast<double>(mUi->loc_playbackSpeed->currentIndex() + 1));
        mTimer.start();
    }
}

void LocationPage::geoDataThreadStarted() {
    mUi->loc_pathTable->setRowCount(0);
    SettingsTheme theme = getSelectedTheme();

    // Prevent the user from initiating a load gpx/kml while another load is already
    // in progress
    setButtonEnabled(mUi->loc_GpxKmlButton, theme, false);
    setButtonEnabled(mUi->loc_playStopButton, theme, false);
    mNowLoadingGeoData = true;
}

void LocationPage::finishGeoDataLoading(
        const QString& file_name,
        bool ok,
        const QString& error_message,
        bool ignore_error) {
    mGeoDataLoader = nullptr;
    if (ok) {
        QSettings settings;
        settings.setValue(Ui::Settings::LOCATION_PLAYBACK_FILE, file_name);
        populateTable(&mGpsFixesArray);
    } else if (!ignore_error) {
        showErrorDialog(error_message, tr("Geo Data Parser"));
    }
    SettingsTheme theme = getSelectedTheme();
    setButtonEnabled(mUi->loc_GpxKmlButton, theme, true);
    setButtonEnabled(mUi->loc_playStopButton, theme, true);
    mNowLoadingGeoData = false;
    emit(geoDataLoadingFinished());
}

void LocationPage::startupGeoDataThreadFinished(QString file_name, bool ok, QString error_message) {
    // on startup, we silently ignore the previously remebered geo data file being
    // missing or malformed.
    finishGeoDataLoading(file_name, ok, error_message, true);
}

void LocationPage::geoDataThreadFinished(QString file_name, bool ok, QString error_message) {
    finishGeoDataLoading(file_name, ok, error_message, false);
}

// Get the current location from the device. If that fails, use
// the saved location from this UI.
// (static function)
void LocationPage::getDeviceLocation(const QAndroidLocationAgent* locAgent,
                                     double* pLatitude,
                                     double* pLongitude,
                                     double* pAltitude)
{
    bool gotDeviceLoc = false;

    if (locAgent && locAgent->gpsGetLoc) {
        // Query the device
        gotDeviceLoc = locAgent->gpsGetLoc(pLatitude, pLongitude, pAltitude, nullptr);
    }

    if (!gotDeviceLoc) {
        // Use the saved settings
        QSettings settings;
        *pLatitude  = settings.value(Ui::Settings::LOCATION_RECENT_LATITUDE,
                                     kGplexLat).toDouble();
        *pLongitude = settings.value(Ui::Settings::LOCATION_RECENT_LONGITUDE,
                                     kGplexLon).toDouble();
        *pAltitude  = settings.value(Ui::Settings::LOCATION_RECENT_ALTITUDE,
                                     0.0).toDouble();
    }
}

// Send a GPS location to the device
// (static function)
void LocationPage::sendLocationToDevice(const QAndroidLocationAgent* locAgent,
                                        double latitude,
                                        double longitude,
                                        double altitude)
{
    QSettings settings;
    settings.setValue(Ui::Settings::LOCATION_RECENT_LATITUDE, latitude);
    settings.setValue(Ui::Settings::LOCATION_RECENT_LONGITUDE, longitude);
    settings.setValue(Ui::Settings::LOCATION_RECENT_ALTITUDE, altitude);

    if (locAgent && locAgent->gpsSendLoc) {
        // Send these to the device
        timeval timeVal = {};
        gettimeofday(&timeVal, nullptr);
        locAgent->gpsSendLoc(latitude, longitude, altitude, 4, &timeVal);
    }
}

void GeoDataLoaderThread::loadGeoDataFromFile(const QString& file_name, GpsFixArray* fixes) {
    mFileName = file_name;
    mFixes = fixes;
    start();
}

void GeoDataLoaderThread::run() {
    if (mFileName.isEmpty() || mFixes == nullptr) {
        emit(loadingFinished(mFileName, false, tr("No file to load")));
        return;
    }

    bool ok = false;
    std::string err_str;

    {
        QFileInfo file_info(mFileName);
        mFixes->clear();
        auto suffix = file_info.suffix().toLower();
        if (suffix == "gpx") {
            ok = GpxParser::parseFile(mFileName.toStdString().c_str(),
                                      mFixes, &err_str);
        } else if (suffix == "kml") {
            ok = KmlParser::parseFile(mFileName.toStdString().c_str(),
                                      mFixes, &err_str);
        } else {
            err_str = tr("Unknown file type").toStdString();
        }
    }

    auto err_qstring = QString::fromStdString(err_str);
    emit(loadingFinished(mFileName, ok, err_qstring));
}

GeoDataLoaderThread* GeoDataLoaderThread::newInstance(const QObject* handler,
                                                      const char* started_slot,
                                                      const char* finished_slot) {
    GeoDataLoaderThread* new_instance = new GeoDataLoaderThread();
    connect(new_instance, SIGNAL(started()), handler, started_slot);
    connect(new_instance, SIGNAL(loadingFinished(QString, bool, QString)), handler, finished_slot);

    // Make sure new_instance gets cleaned up after the thread exits.
    connect(new_instance, &QThread::finished, new_instance, &QObject::deleteLater);

    return new_instance;
}