android/android-emu/android/update-check/UpdateChecker.cpp - qemu-android - Git at Google

 // Copyright 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/update-check/UpdateChecker.h"

 #include "android/base/files/IniFile.h"
 #include "android/base/files/PathUtils.h"
 #include "android/base/memory/ScopedPtr.h"
 #include "android/base/StringView.h"
 #include "android/base/system/System.h"
 #include "android/base/threads/Async.h"
 #include "android/base/Uri.h"
 #include "android/curl-support.h"
 #include "android/emulation/ConfigDirs.h"
 #include "android/metrics/StudioConfig.h"
 #include "android/update-check/update_check.h"
 #include "android/update-check/VersionExtractor.h"
 #include "android/utils/debug.h"
 #include "android/utils/filelock.h"
 #include "android/utils/misc.h"
 #include "android/version.h"

 #include <fstream>
 #include <iterator>
 #include <new>
 #include <string>

 #include <errno.h>
 #include <string.h>
 #include <time.h>

 using android::base::async;
 using android::base::Optional;
 using android::base::PathUtils;
 using android::base::ScopedCPtr;
 using android::base::StringView;
 using android::base::System;
 using android::base::Uri;
 using android::base::Version;
 using android::update_check::UpdateChecker;

 static const char kDataFileName[] = "emu-update-last-check.ini";
 // TODO: kVersionUrl should not be fixed; XY in repository-XY.xml
 //       might change with studio updates irrelevant to the emulator
 static constexpr StringView kVersionUrl =
         "https://dl.google.com/android/repository/repository2-1.xml";

 static const char kNewerVersionMessage[] =
         R"(Your emulator is out of date, please update by launching Android Studio:
  - Start Android Studio
  - Select menu "Tools > Android > SDK Manager"
  - Click "SDK Tools" tab
  - Check "Android SDK Tools" checkbox
  - Click "OK"
 )";

 void android_checkForUpdates(const char* coreVersion) {
     std::unique_ptr<UpdateChecker> checker(new UpdateChecker(coreVersion));

     if (checker->init() && checker->needsCheck() && checker->runAsyncCheck()) {
         // checker will delete itself after the check in the worker thread
         checker.release();
     } else {
         VERBOSE_PRINT(updater, "UpdateChecker: skipped version check");
     }
 }

 namespace android {
 namespace update_check {

 static size_t curlWriteCallback(char* contents,
                                 size_t size,
                                 size_t nmemb,
                                 void* userp) {
     auto& xml = *static_cast<std::string*>(userp);
     const size_t total = size * nmemb;

     xml.insert(xml.end(), contents, contents + total);

     return total;
 }

 class DataLoader final : public IDataLoader {
 public:
     DataLoader(StringView coreVersion) : mCoreVersion(coreVersion) {}

     virtual std::string load() override {
         std::string xml;
         std::string url = kVersionUrl;
         if (!mCoreVersion.empty()) {
             const auto& id = android::studio::getInstallationId();
             url += Uri::FormatEncodeArguments(
                     "?tool=emulator&uid=%s&os=%s", id,
                     toString(System::get()->getOsType()));
             // append the fields which may change from run to run: version and
             // core version
             url += getVersionUriFields();
         }
         char* error = nullptr;
         if (!curl_download(url.c_str(), nullptr, &curlWriteCallback, &xml,
                            &error)) {
             dwarning("UpdateCheck: Failure: %s", error);
             ::free(error);
         }
         return xml;
     }

     virtual std::string getUniqueDataKey() override {
         return getVersionUriFields();
     }

 private:
     std::string getVersionUriFields() const {
         return Uri::FormatEncodeArguments("version=" EMULATOR_VERSION_STRING
                                           "&coreVersion=%s",
                                           mCoreVersion);
     }

 private:
     std::string mCoreVersion;
 };

 class TimeStorage final : public ITimeStorage {
     using IniFile = android::base::IniFile;

 public:
     TimeStorage() {
         const std::string configPath = android::ConfigDirs::getUserDirectory();
         mDataFileName = PathUtils::join(configPath, kDataFileName);
     }

     ~TimeStorage() {
         if (mFileLock) {
             filelock_release(mFileLock);
         }
     }

     bool lock() override {
         if (mFileLock) {
             dwarning("UpdateCheck: lock() called twice by the same process");
             return true;
         }

         mFileLock = filelock_create(mDataFileName.c_str());
         // if someone's already checking it - don't do it twice
         return mFileLock != nullptr;
     }

     time_t getTime(const std::string& key) {
         IniFile file(mDataFileName);
         if (!file.read()) {
             // no file at all, return the lowest possible timestamp
             return 0;
         }

         return file.getInt64(IniFile::makeValidKey(key), 0);
     }

     void setTime(const std::string& key, time_t time) {
         IniFile file(mDataFileName);
         file.read();  // who cares if it didn't exist - we'll create it anyway
         file.setInt64(IniFile::makeValidKey(key), time);
         if (!file.write()) {
             dwarning("UpdateCheck: couldn't save the data file");
         }
     }

 private:
     std::string mDataFileName;
     FileLock* mFileLock = nullptr;
 };

 class NewerVersionReporter final : public INewerVersionReporter {
 public:
     virtual void reportNewerVersion(
             const android::base::Version& /*existing*/,
             const android::base::Version& /*newer*/) override {
         printf("%s\n", kNewerVersionMessage);
     }
 };

 UpdateChecker::UpdateChecker(const char* coreVersion)
     : mVersionExtractor(new VersionExtractor()),
       mDataLoader(new DataLoader(coreVersion)),
       mTimeStorage(new TimeStorage()),
       mReporter(new NewerVersionReporter()) {}

 UpdateChecker::UpdateChecker(IVersionExtractor* extractor,
                              IDataLoader* loader,
                              ITimeStorage* storage,
                              INewerVersionReporter* reporter)
     : mVersionExtractor(extractor),
       mDataLoader(loader),
       mTimeStorage(storage),
       mReporter(reporter) {}

 bool UpdateChecker::init() {
     if (!mTimeStorage->lock()) {
         return false;
     }

     return true;
 }

 bool UpdateChecker::needsCheck() const {
     const time_t now = System::get()->getUnixTime();
     // Check only if the previous check was 4+ hours ago
     return now - mTimeStorage->getTime(mDataLoader->getUniqueDataKey()) >=
            4 * 60 * 60;
 }

 bool UpdateChecker::runAsyncCheck() {
     return async([this] {
         asyncWorker();
         delete this;
     });
 }

 void UpdateChecker::asyncWorker() {
     Version current = mVersionExtractor->getCurrentVersion();
     const auto last = getLatestVersion();

     if (!last) {
         // don't record the last check time if we were not able to retrieve
         // the last version - next time we may be more lucky
         dwarning(
                 "UpdateCheck: failed to get the latest version, skipping "
                 "check (current version '%s')",
                 current.toString().c_str());
         return;
     }

     VERBOSE_PRINT(updater,
                   "UpdateCheck: current version '%s', last version '%s'",
                   current.toString().c_str(), last->first.toString().c_str());

     if (current < last->first) {
         mReporter->reportNewerVersion(current, last->first);
     }

     // Update the last version check time
     mTimeStorage->setTime(mDataLoader->getUniqueDataKey(),
                           System::get()->getUnixTime());
 }

 Optional<UpdateChecker::VersionInfo> UpdateChecker::getLatestVersion() {
     const auto repositoryXml = mDataLoader->load();
     const auto versions = mVersionExtractor->extractVersions(repositoryXml);
     if (versions.empty()) {
         return {};
     }

     const auto updateChannel = android::studio::updateChannel();

     // now find the first channel which is equal to or lower than the selected
     // update channel
     const auto greaterIt = versions.upper_bound(updateChannel);
     if (greaterIt == versions.begin()) {
         // even the first update channel in the list is greater than the
         // one from Android Studio settings
         return {};
     }

     return std::make_pair(std::prev(greaterIt)->second,
                           std::prev(greaterIt)->first);
 }

 }  // namespace update_check
 }  // namespace android
	// Copyright 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/update-check/UpdateChecker.h"

	#include "android/base/files/IniFile.h"
	#include "android/base/files/PathUtils.h"
	#include "android/base/memory/ScopedPtr.h"
	#include "android/base/StringView.h"
	#include "android/base/system/System.h"
	#include "android/base/threads/Async.h"
	#include "android/base/Uri.h"
	#include "android/curl-support.h"
	#include "android/emulation/ConfigDirs.h"
	#include "android/metrics/StudioConfig.h"
	#include "android/update-check/update_check.h"
	#include "android/update-check/VersionExtractor.h"
	#include "android/utils/debug.h"
	#include "android/utils/filelock.h"
	#include "android/utils/misc.h"
	#include "android/version.h"

	#include <fstream>
	#include <iterator>
	#include <new>
	#include <string>

	#include <errno.h>
	#include <string.h>
	#include <time.h>

	using android::base::async;
	using android::base::Optional;
	using android::base::PathUtils;
	using android::base::ScopedCPtr;
	using android::base::StringView;
	using android::base::System;
	using android::base::Uri;
	using android::base::Version;
	using android::update_check::UpdateChecker;

	static const char kDataFileName[] = "emu-update-last-check.ini";
	// TODO: kVersionUrl should not be fixed; XY in repository-XY.xml
	// might change with studio updates irrelevant to the emulator
	static constexpr StringView kVersionUrl =
	"https://dl.google.com/android/repository/repository2-1.xml";

	static const char kNewerVersionMessage[] =
	R"(Your emulator is out of date, please update by launching Android Studio:
	- Start Android Studio
	- Select menu "Tools > Android > SDK Manager"
	- Click "SDK Tools" tab
	- Check "Android SDK Tools" checkbox
	- Click "OK"
	)";

	void android_checkForUpdates(const char* coreVersion) {
	std::unique_ptr<UpdateChecker> checker(new UpdateChecker(coreVersion));

	if (checker->init() && checker->needsCheck() && checker->runAsyncCheck()) {
	// checker will delete itself after the check in the worker thread
	checker.release();
	} else {
	VERBOSE_PRINT(updater, "UpdateChecker: skipped version check");
	}
	}

	namespace android {
	namespace update_check {

	static size_t curlWriteCallback(char* contents,
	size_t size,
	size_t nmemb,
	void* userp) {
	auto& xml = static_cast<std::string>(userp);
	const size_t total = size * nmemb;

	xml.insert(xml.end(), contents, contents + total);

	return total;
	}

	class DataLoader final : public IDataLoader {
	public:
	DataLoader(StringView coreVersion) : mCoreVersion(coreVersion) {}

	virtual std::string load() override {
	std::string xml;
	std::string url = kVersionUrl;
	if (!mCoreVersion.empty()) {
	const auto& id = android::studio::getInstallationId();
	url += Uri::FormatEncodeArguments(
	"?tool=emulator&uid=%s&os=%s", id,
	toString(System::get()->getOsType()));
	// append the fields which may change from run to run: version and
	// core version
	url += getVersionUriFields();
	}
	char* error = nullptr;
	if (!curl_download(url.c_str(), nullptr, &curlWriteCallback, &xml,
	&error)) {
	dwarning("UpdateCheck: Failure: %s", error);
	::free(error);
	}
	return xml;
	}

	virtual std::string getUniqueDataKey() override {
	return getVersionUriFields();
	}

	private:
	std::string getVersionUriFields() const {
	return Uri::FormatEncodeArguments("version=" EMULATOR_VERSION_STRING
	"&coreVersion=%s",
	mCoreVersion);
	}

	private:
	std::string mCoreVersion;
	};

	class TimeStorage final : public ITimeStorage {
	using IniFile = android::base::IniFile;

	public:
	TimeStorage() {
	const std::string configPath = android::ConfigDirs::getUserDirectory();
	mDataFileName = PathUtils::join(configPath, kDataFileName);
	}

	~TimeStorage() {
	if (mFileLock) {
	filelock_release(mFileLock);
	}
	}

	bool lock() override {
	if (mFileLock) {
	dwarning("UpdateCheck: lock() called twice by the same process");
	return true;
	}

	mFileLock = filelock_create(mDataFileName.c_str());
	// if someone's already checking it - don't do it twice
	return mFileLock != nullptr;
	}

	time_t getTime(const std::string& key) {
	IniFile file(mDataFileName);
	if (!file.read()) {
	// no file at all, return the lowest possible timestamp
	return 0;
	}

	return file.getInt64(IniFile::makeValidKey(key), 0);
	}

	void setTime(const std::string& key, time_t time) {
	IniFile file(mDataFileName);
	file.read(); // who cares if it didn't exist - we'll create it anyway
	file.setInt64(IniFile::makeValidKey(key), time);
	if (!file.write()) {
	dwarning("UpdateCheck: couldn't save the data file");
	}
	}

	private:
	std::string mDataFileName;
	FileLock* mFileLock = nullptr;
	};

	class NewerVersionReporter final : public INewerVersionReporter {
	public:
	virtual void reportNewerVersion(
	const android::base::Version& /existing/,
	const android::base::Version& /newer/) override {
	printf("%s\n", kNewerVersionMessage);
	}
	};

	UpdateChecker::UpdateChecker(const char* coreVersion)
	: mVersionExtractor(new VersionExtractor()),
	mDataLoader(new DataLoader(coreVersion)),
	mTimeStorage(new TimeStorage()),
	mReporter(new NewerVersionReporter()) {}

	UpdateChecker::UpdateChecker(IVersionExtractor* extractor,
	IDataLoader* loader,
	ITimeStorage* storage,
	INewerVersionReporter* reporter)
	: mVersionExtractor(extractor),
	mDataLoader(loader),
	mTimeStorage(storage),
	mReporter(reporter) {}

	bool UpdateChecker::init() {
	if (!mTimeStorage->lock()) {
	return false;
	}

	return true;
	}

	bool UpdateChecker::needsCheck() const {
	const time_t now = System::get()->getUnixTime();
	// Check only if the previous check was 4+ hours ago
	return now - mTimeStorage->getTime(mDataLoader->getUniqueDataKey()) >=
	4 * 60 * 60;
	}

	bool UpdateChecker::runAsyncCheck() {
	return async([this] {
	asyncWorker();
	delete this;
	});
	}

	void UpdateChecker::asyncWorker() {
	Version current = mVersionExtractor->getCurrentVersion();
	const auto last = getLatestVersion();

	if (!last) {
	// don't record the last check time if we were not able to retrieve
	// the last version - next time we may be more lucky
	dwarning(
	"UpdateCheck: failed to get the latest version, skipping "
	"check (current version '%s')",
	current.toString().c_str());
	return;
	}

	VERBOSE_PRINT(updater,
	"UpdateCheck: current version '%s', last version '%s'",
	current.toString().c_str(), last->first.toString().c_str());

	if (current < last->first) {
	mReporter->reportNewerVersion(current, last->first);
	}

	// Update the last version check time
	mTimeStorage->setTime(mDataLoader->getUniqueDataKey(),
	System::get()->getUnixTime());
	}

	Optional<UpdateChecker::VersionInfo> UpdateChecker::getLatestVersion() {
	const auto repositoryXml = mDataLoader->load();
	const auto versions = mVersionExtractor->extractVersions(repositoryXml);
	if (versions.empty()) {
	return {};
	}

	const auto updateChannel = android::studio::updateChannel();

	// now find the first channel which is equal to or lower than the selected
	// update channel
	const auto greaterIt = versions.upper_bound(updateChannel);
	if (greaterIt == versions.begin()) {
	// even the first update channel in the list is greater than the
	// one from Android Studio settings
	return {};
	}

	return std::make_pair(std::prev(greaterIt)->second,
	std::prev(greaterIt)->first);
	}

	} // namespace update_check
	} // namespace android