mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-06-02 03:51:35 +02:00
422 lines
16 KiB
C++
422 lines
16 KiB
C++
//
|
|
// LauncherManager.cpp
|
|
//
|
|
// Created by Luis Cuenca on 6/5/2019.
|
|
// Copyright 2019 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include <fstream>
|
|
|
|
#include "LauncherManager.h"
|
|
|
|
|
|
LauncherManager::LauncherManager()
|
|
{
|
|
}
|
|
|
|
|
|
LauncherManager::~LauncherManager()
|
|
{
|
|
}
|
|
|
|
void LauncherManager::init() {
|
|
getMostRecentBuild(_latestApplicationURL, _latestVersion);
|
|
CString currentVersion;
|
|
if (isApplicationInstalled(currentVersion, _domainURL, _contentURL, _loggedIn) && _loggedIn) {
|
|
if (_latestVersion.Compare(currentVersion) == 0) {
|
|
launchApplication();
|
|
_shouldShutdown = TRUE;
|
|
} else {
|
|
_shouldUpdate = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL LauncherManager::installLauncher() {
|
|
CString appPath;
|
|
BOOL result = getAndCreatePaths(PathType::Running_Path, appPath);
|
|
if (!result) {
|
|
MessageBox(NULL, L"Error getting app directory", L"Path Error", MB_OK | MB_ICONERROR);
|
|
}
|
|
CString installDirectory;
|
|
CString appDirectory = appPath.Left(appPath.ReverseFind('\\') + 1);
|
|
result = getAndCreatePaths(PathType::Launcher_Directory, installDirectory);
|
|
if (!result) {
|
|
MessageBox(NULL, L"Error getting app desired directory", L"Path Error", MB_OK | MB_ICONERROR);
|
|
}
|
|
|
|
CString instalationPath = installDirectory + LAUNCHER_EXE_FILENAME;
|
|
if (!installDirectory.Compare(appDirectory) == 0) {
|
|
if (!_shouldUninstall) {
|
|
// The installer is not running on the desired location and has to be installed
|
|
// Kill of running before self-copy
|
|
if (LauncherUtils::IsProcessRunning(LAUNCHER_EXE_FILENAME)) {
|
|
::ShellExecute(NULL, NULL, L"taskkill", L"/F /T /IM " + LAUNCHER_EXE_FILENAME, NULL, SW_HIDE);
|
|
}
|
|
CopyFile(appPath, instalationPath, FALSE);
|
|
}
|
|
} else if (_shouldUninstall) {
|
|
CString tempPath;
|
|
if (getAndCreatePaths(PathType::Temp_Directory, tempPath)) {
|
|
tempPath += _T("\\HQ_uninstaller_tmp.exe");
|
|
CopyFile(instalationPath, tempPath, false);
|
|
LauncherUtils::launchApplication(tempPath, _T(" --uninstall"));
|
|
exit(0);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL LauncherManager::createShortcuts() {
|
|
CString desktopLnkPath;
|
|
getAndCreatePaths(PathType::Desktop_Directory, desktopLnkPath);
|
|
desktopLnkPath += _T("\\HQ Launcher.lnk");
|
|
CString installDir;
|
|
getAndCreatePaths(PathType::Launcher_Directory, installDir);
|
|
CString installPath = installDir + LAUNCHER_EXE_FILENAME;
|
|
if (!LauncherUtils::CreateLink(installPath, (LPCSTR)CStringA(desktopLnkPath), _T("CLick to Setup and Launch HQ."))) {
|
|
return FALSE;
|
|
}
|
|
CString startLinkPath;
|
|
getAndCreatePaths(PathType::StartMenu_Directory, startLinkPath);
|
|
CString appStartLinkPath = startLinkPath + _T("HQ Launcher.lnk");
|
|
CString uniStartLinkPath = startLinkPath + _T("Uninstall HQ.lnk");
|
|
CString uniLinkPath = installDir + _T("Uninstall HQ.lnk");
|
|
if (!LauncherUtils::CreateLink(installPath, (LPCSTR)CStringA(appStartLinkPath), _T("CLick to Setup and Launch HQ."))) {
|
|
return FALSE;
|
|
}
|
|
if (!LauncherUtils::CreateLink(installPath, (LPCSTR)CStringA(uniStartLinkPath), _T("CLick to Uninstall HQ."), _T("--uninstall"))) {
|
|
return FALSE;
|
|
}
|
|
if (!LauncherUtils::CreateLink(installPath, (LPCSTR)CStringA(uniLinkPath), _T("CLick to Uninstall HQ."), _T("--uninstall"))) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL LauncherManager::deleteShortcuts() {
|
|
CString desktopLnkPath;
|
|
getAndCreatePaths(PathType::Desktop_Directory, desktopLnkPath);
|
|
desktopLnkPath += _T("\\HQ Launcher.lnk");
|
|
BOOL success = LauncherUtils::deleteFileOrDirectory(desktopLnkPath);
|
|
CString startLinkPath;
|
|
getAndCreatePaths(PathType::StartMenu_Directory, startLinkPath);
|
|
return success && LauncherUtils::deleteFileOrDirectory(startLinkPath);
|
|
}
|
|
|
|
BOOL LauncherManager::isApplicationInstalled(CString& version, CString& domain,
|
|
CString& content, bool& loggedIn) {
|
|
CString applicationDir;
|
|
getAndCreatePaths(PathType::Launcher_Directory, applicationDir);
|
|
CString applicationPath = applicationDir + "interface\\interface.exe";
|
|
BOOL isApplicationInstalled = PathFileExistsW(applicationPath);
|
|
BOOL configFileExist = PathFileExistsW(applicationDir + _T("interface\\config.json"));
|
|
if (isApplicationInstalled && configFileExist) {
|
|
LauncherUtils::ResponseError status = readConfigJSON(version, domain, content, loggedIn);
|
|
return status == LauncherUtils::ResponseError::NoError;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL LauncherManager::getAndCreatePaths(PathType type, CString& outPath) {
|
|
|
|
if (type == PathType::Running_Path) {
|
|
char appPath[MAX_PATH];
|
|
DWORD size = GetModuleFileNameA(NULL, appPath, MAX_PATH);
|
|
if (size) {
|
|
outPath = CString(appPath);
|
|
return TRUE;
|
|
}
|
|
} else if (type == PathType::Desktop_Directory) {
|
|
TCHAR desktopPath[MAX_PATH];
|
|
auto success = SUCCEEDED(SHGetFolderPath(NULL, CSIDL_DESKTOP, NULL, 0, desktopPath));
|
|
outPath = CString(desktopPath);
|
|
return success;
|
|
} else if (type == PathType::Temp_Directory) {
|
|
TCHAR tempPath[MAX_PATH];
|
|
auto success = GetTempPath(MAX_PATH, tempPath);
|
|
outPath = CString(tempPath);
|
|
return success;
|
|
} else {
|
|
TCHAR localDataPath[MAX_PATH];
|
|
if (type == PathType::StartMenu_Directory) {
|
|
TCHAR startMenuPath[MAX_PATH];
|
|
auto success = SUCCEEDED(SHGetFolderPath(NULL, CSIDL_STARTMENU, NULL, 0, startMenuPath));
|
|
outPath = CString(startMenuPath) + _T("\\Programs\\HQ\\");
|
|
success = SHCreateDirectoryEx(NULL, outPath, NULL) || ERROR_ALREADY_EXISTS == GetLastError();
|
|
return success;
|
|
} else if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, localDataPath))) {
|
|
_tcscat_s(localDataPath, _T("\\") + DIRECTORY_NAME_APP + _T("\\"));
|
|
outPath = CString(localDataPath);
|
|
if (type == PathType::Download_Directory) {
|
|
outPath += DIRECTORY_NAME_DOWNLOADS + _T("\\");
|
|
} else if (type == PathType::Interface_Directory) {
|
|
outPath += DIRECTORY_NAME_INTERFACE;
|
|
} else if (type == PathType::Content_Directory) {
|
|
outPath += DIRECTORY_NAME_CONTENT;
|
|
}
|
|
return (CreateDirectory(outPath, NULL) || ERROR_ALREADY_EXISTS == GetLastError());
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL LauncherManager::getInstalledVersion(const CString& path, CString& version) {
|
|
CStdioFile cfile;
|
|
BOOL success = cfile.Open(path, CFile::modeRead);
|
|
if (success) {
|
|
cfile.ReadString(version);
|
|
cfile.Close();
|
|
}
|
|
return success;
|
|
}
|
|
|
|
|
|
BOOL LauncherManager::launchApplication(const CString& tokensJSON) {
|
|
CString installDir;
|
|
LauncherManager::getAndCreatePaths(PathType::Interface_Directory, installDir);
|
|
CString interfaceExe = installDir + _T("\\interface.exe");
|
|
CString params1 = _T("--url \"") + _domainURL + ("\" ");
|
|
CString cacheDir;
|
|
LauncherManager::getAndCreatePaths(PathType::Content_Directory, cacheDir);
|
|
CString params3 = _T("--cache \"") + cacheDir + ("\" ");
|
|
CString params4 = !_displayName.IsEmpty() ? _T("--displayName \"") + _displayName + ("\" ") : _T("");
|
|
CString parsedTokens = tokensJSON;
|
|
parsedTokens.Replace(_T("\""), _T("\\\""));
|
|
CString params5 = !tokensJSON.IsEmpty() ? _T("--tokens \"") + parsedTokens + ("\"") : _T("");
|
|
CString params = params1 + params3 + params4 + params5 + EXTRA_PARAMETERS;
|
|
auto rs = ShellExecute(NULL, L"open", interfaceExe, params, NULL, SW_SHOW);
|
|
return (rs != NULL);
|
|
}
|
|
|
|
BOOL LauncherManager::createConfigJSON() {
|
|
CString configPath;
|
|
LauncherManager::getAndCreatePaths(PathType::Interface_Directory, configPath);
|
|
configPath += "\\config.json";
|
|
std::ofstream configFile(configPath, std::ofstream::binary);
|
|
if (configFile.fail()) {
|
|
return FALSE;
|
|
}
|
|
Json::Value config;
|
|
CString applicationPath;
|
|
LauncherManager::getAndCreatePaths(PathType::Launcher_Directory, applicationPath);
|
|
applicationPath += LAUNCHER_EXE_FILENAME;
|
|
config["loggedIn"] = _loggedIn;
|
|
config["launcherPath"] = LauncherUtils::cStringToStd(applicationPath);
|
|
config["version"] = LauncherUtils::cStringToStd(_latestVersion);
|
|
config["domain"] = LauncherUtils::cStringToStd(_domainURL);
|
|
CString content;
|
|
getAndCreatePaths(PathType::Content_Directory, content);
|
|
config["content"] = LauncherUtils::cStringToStd(content);
|
|
configFile << config;
|
|
configFile.close();
|
|
return TRUE;
|
|
}
|
|
|
|
LauncherUtils::ResponseError LauncherManager::readConfigJSON(CString& version, CString& domain, CString& content, bool& loggedIn) {
|
|
CString configPath;
|
|
getAndCreatePaths(PathType::Interface_Directory, configPath);
|
|
configPath += "\\config.json";
|
|
std::ifstream configFile(configPath, std::ifstream::binary);
|
|
if (configFile.fail()) {
|
|
return LauncherUtils::ResponseError::Open;
|
|
}
|
|
Json::Value config;
|
|
configFile >> config;
|
|
if (config["version"].isString() && config["domain"].isString() &&
|
|
config["content"].isString()) {
|
|
loggedIn = config["loggedIn"].asBool();
|
|
version = config["version"].asCString();
|
|
domain = config["domain"].asCString();
|
|
content = config["content"].asCString();
|
|
configFile.close();
|
|
return LauncherUtils::ResponseError::NoError;
|
|
}
|
|
configFile.close();
|
|
return LauncherUtils::ResponseError::ParsingJSON;
|
|
}
|
|
|
|
LauncherUtils::ResponseError LauncherManager::readOrganizationJSON(const CString& hash) {
|
|
CString contentTypeJson = L"content-type:application/json";
|
|
CString response;
|
|
CString url = _T("/hifi-public/huffman/organizations/") + hash + _T(".json");
|
|
LauncherUtils::ResponseError error = LauncherUtils::makeHTTPCall(L"HQ Launcher", L"s3.amazonaws.com", url,
|
|
contentTypeJson, CStringA(), response, false);
|
|
if (error != LauncherUtils::ResponseError::NoError) {
|
|
return error;
|
|
}
|
|
Json::Value json;
|
|
if (LauncherUtils::parseJSON(response, json)) {
|
|
if (json["content_set_url"].isString() && json["domain"].isString()) {
|
|
_contentURL = json["content_set_url"].asCString();
|
|
_domainURL = json["domain"].asCString();
|
|
return LauncherUtils::ResponseError::NoError;
|
|
}
|
|
}
|
|
return LauncherUtils::ResponseError::ParsingJSON;
|
|
}
|
|
|
|
LauncherUtils::ResponseError LauncherManager::getMostRecentBuild(CString& urlOut, CString& versionOut) {
|
|
CString contentTypeJson = L"content-type:application/json";
|
|
CString response;
|
|
LauncherUtils::ResponseError error = LauncherUtils::makeHTTPCall(L"HQ Launcher", L"thunder.highfidelity.com", L"/builds/api/tags/latest?format=json",
|
|
contentTypeJson, CStringA(), response, false);
|
|
if (error != LauncherUtils::ResponseError::NoError) {
|
|
return error;
|
|
}
|
|
Json::Value json;
|
|
if (LauncherUtils::parseJSON(response, json)) {
|
|
int count = json["count"].isInt() ? json["count"].asInt() : 0;
|
|
if (count > 0 && json["results"].isArray()) {
|
|
for (int i = 0; i < count; i++) {
|
|
if (json["results"][i].isObject()) {
|
|
Json::Value result = json["results"][i];
|
|
if (result["latest_version"].isInt()) {
|
|
std::string version = std::to_string(result["latest_version"].asInt());
|
|
versionOut = CString(version.c_str());
|
|
}
|
|
if (result["installers"].isObject() &&
|
|
result["installers"]["windows"].isObject() &&
|
|
result["installers"]["windows"]["zip_url"].isString()) {
|
|
urlOut = result["installers"]["windows"]["zip_url"].asCString();
|
|
return LauncherUtils::ResponseError::NoError;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return LauncherUtils::ResponseError::ParsingJSON;
|
|
}
|
|
|
|
LauncherUtils::ResponseError LauncherManager::getAccessTokenForCredentials(const CString& username, const CString& password) {
|
|
CStringA post = "grant_type=password&username=";
|
|
post += username;
|
|
post += "&password=";
|
|
post += password;
|
|
post += "&scope=owner";
|
|
|
|
CString contentTypeText = L"content-type:application/x-www-form-urlencoded";
|
|
CString response;
|
|
LauncherUtils::ResponseError error = LauncherUtils::makeHTTPCall(L"HQ Launcher", L"metaverse.highfidelity.com", L"/oauth/token",
|
|
contentTypeText, post, response, true);
|
|
if (error != LauncherUtils::ResponseError::NoError) {
|
|
return error;
|
|
}
|
|
Json::Value json;
|
|
if (LauncherUtils::parseJSON(response, json)) {
|
|
if (json["error"].isString()) {
|
|
return LauncherUtils::ResponseError::BadCredentials;
|
|
} else if (json["access_token"].isString()) {
|
|
_tokensJSON = response;
|
|
return LauncherUtils::ResponseError::NoError;
|
|
}
|
|
}
|
|
return LauncherUtils::ResponseError::ParsingJSON;
|
|
}
|
|
|
|
BOOL LauncherManager::createApplicationRegistryKeys(int size) {
|
|
const std::string REGISTRY_PATH = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\HQ";
|
|
BOOL success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "DisplayName", "HQ");
|
|
CString installDir;
|
|
getAndCreatePaths(PathType::Launcher_Directory, installDir);
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "InstallLocation", LauncherUtils::cStringToStd(installDir));
|
|
std::string applicationExe = LauncherUtils::cStringToStd(installDir + LAUNCHER_EXE_FILENAME);
|
|
std::string uninstallPath = '"' + applicationExe + '"' + " --uninstall";
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "UninstallString", uninstallPath);
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "DisplayVersion", LauncherUtils::cStringToStd(_latestVersion));
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "DisplayIcon", applicationExe);
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "Publisher", "High Fidelity");
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "InstallDate", LauncherUtils::cStringToStd(CTime::GetCurrentTime().Format("%Y%m%d")));
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "EstimatedSize", (DWORD)size);
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "NoModify", (DWORD)1);
|
|
success = LauncherUtils::insertRegistryKey(REGISTRY_PATH, "NoRepair", (DWORD)1);
|
|
return success;
|
|
}
|
|
|
|
BOOL LauncherManager::deleteApplicationRegistryKeys() {
|
|
const CString REGISTRY_PATH = _T("Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\HQ");
|
|
return LauncherUtils::deleteRegistryKey(REGISTRY_PATH);
|
|
}
|
|
|
|
BOOL LauncherManager::uninstallApplication() {
|
|
CString installDir;
|
|
getAndCreatePaths(PathType::Launcher_Directory, installDir);
|
|
BOOL success = LauncherUtils::deleteFileOrDirectory(installDir);
|
|
success = success && (deleteShortcuts());
|
|
success = success && (deleteApplicationRegistryKeys());
|
|
return success;
|
|
}
|
|
|
|
void LauncherManager::onZipExtracted(ZipType type, int size) {
|
|
if (type == ZipType::ZipContent) {
|
|
downloadApplication();
|
|
} else if (type == ZipType::ZipApplication) {
|
|
createShortcuts();
|
|
CString versionPath;
|
|
getAndCreatePaths(LauncherManager::PathType::Launcher_Directory, versionPath);
|
|
createConfigJSON();
|
|
launchApplication(_tokensJSON);
|
|
createApplicationRegistryKeys(size);
|
|
_shouldShutdown = TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL LauncherManager::extractApplication() {
|
|
CString installPath;
|
|
getAndCreatePaths(LauncherManager::PathType::Interface_Directory, installPath);
|
|
BOOL success = LauncherUtils::unzipFileOnThread(ZipType::ZipApplication, LauncherUtils::cStringToStd(_applicationZipPath),
|
|
LauncherUtils::cStringToStd(installPath), [&](int type, int size) {
|
|
onZipExtracted((ZipType)type, size);
|
|
});
|
|
return success;
|
|
}
|
|
|
|
void LauncherManager::onFileDownloaded(DownloadType type) {
|
|
if (type == DownloadType::DownloadContent) {
|
|
installContent();
|
|
} else if (type == DownloadType::DownloadApplication) {
|
|
extractApplication();
|
|
}
|
|
}
|
|
|
|
|
|
BOOL LauncherManager::installContent() {
|
|
std::string contentZipFile = LauncherUtils::cStringToStd(_contentZipPath);
|
|
CString contentPath;
|
|
getAndCreatePaths(LauncherManager::PathType::Content_Directory, contentPath);
|
|
BOOL success = LauncherUtils::unzipFileOnThread(ZipType::ZipContent, contentZipFile,
|
|
LauncherUtils::cStringToStd(contentPath), [&](int type, int size) {
|
|
onZipExtracted((ZipType)type, size);
|
|
});
|
|
return success;
|
|
}
|
|
|
|
|
|
BOOL LauncherManager::downloadFile(DownloadType type, const CString& url, CString& outPath) {
|
|
CString fileName = url.Mid(url.ReverseFind('/') + 1);
|
|
CString downloadDirectory;
|
|
BOOL success = getAndCreatePaths(LauncherManager::PathType::Download_Directory, downloadDirectory);
|
|
outPath = downloadDirectory + fileName;
|
|
if (success) {
|
|
if (!LauncherUtils::downloadFileOnThread(type, url, outPath, [&](int type) {
|
|
onFileDownloaded((DownloadType)type);
|
|
})) {
|
|
success = FALSE;
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
BOOL LauncherManager::downloadContent() {
|
|
CString contentURL = getContentURL();
|
|
return downloadFile(DownloadType::DownloadContent, contentURL, _contentZipPath);
|
|
}
|
|
|
|
BOOL LauncherManager::downloadApplication() {
|
|
CString applicationURL = getLatestInterfaceURL();
|
|
return downloadFile(DownloadType::DownloadApplication, applicationURL, _applicationZipPath);
|
|
}
|