Merge remote-tracking branch 'hifi/master' into android_places_goto

Cristian Luis Duarte committed 8 years ago

Commit 401bf2f2 parents e47173a 1e25d48168 files · +5803 −1664Browse files

Showing the changes to interface/src/Application.cpp (1 of 168 files). Show all

Unified · Split

 #include <avatars-renderer/ScriptAvatar.h>
 #include <RenderableEntityItem.h>
+#include <AnimationLogging.h>
+#include <AvatarLogging.h>
+#include <ScriptEngineLogging.h>
+#include <ModelFormatLogging.h>
+#include <controllers/Logging.h>
+#include <NetworkLogging.h>
+#include <shared/StorageLogging.h>
+#include <ScriptEngineLogging.h>
+#include <ui/Logging.h>
 #include "AudioClient.h"
 #include "audio/AudioScope.h"
 #include "avatar/AvatarManager.h"
     // Needs to happen AFTER the render engine initialization to access its configuration
     initializeUi();
+    updateVerboseLogging();
     init();
     qCDebug(interfaceapp, "init() complete.");
     // Make sure we don't time out during slow operations at startup
     updateHeartbeat();
-    // sessionRunTime will be reset soon by loadSettings. Grab it now to get previous session value.
+    constexpr auto INSTALLER_INI_NAME = "installer.ini";
-    // The value will be 0 if the user blew away settings this session, which is both a feature and a bug.
+    auto iniPath = QDir(applicationDirPath()).filePath(INSTALLER_INI_NAME);
-    static const QString TESTER = "HIFI_TESTER";
+    QFile installerFile { iniPath };
-    auto gpuIdent = GPUIdent::getInstance();
+    std::unordered_map<QString, QString> installerKeyValues;
-    auto glContextData = getGLContextData();
+    if (installerFile.open(QIODevice::ReadOnly)) {
-    QJsonObject properties = {
+        while (!installerFile.atEnd()) {
-        { "version", applicationVersion() },
+            auto line = installerFile.readLine();
-        { "tester", QProcessEnvironment::systemEnvironment().contains(TESTER) },
+            if (!line.isEmpty()) {
-        { "previousSessionCrashed", _previousSessionCrashed },
+                auto index = line.indexOf("=");
-        { "previousSessionRuntime", sessionRunTime.get() },
+                if (index >= 0) {
-        { "cpu_architecture", QSysInfo::currentCpuArchitecture() },
+                    installerKeyValues[line.mid(0, index).trimmed()] = line.mid(index + 1).trimmed();
-        { "kernel_type", QSysInfo::kernelType() },
+                }
-        { "kernel_version", QSysInfo::kernelVersion() },
+            }
-        { "os_type", QSysInfo::productType() },
+        }
-        { "os_version", QSysInfo::productVersion() },
-        { "gpu_name", gpuIdent->getName() },
-        { "gpu_driver", gpuIdent->getDriver() },
-        { "gpu_memory", static_cast<qint64>(gpuIdent->getMemory()) },
-        { "gl_version_int", glVersionToInteger(glContextData.value("version").toString()) },
-        { "gl_version", glContextData["version"] },
-        { "gl_vender", glContextData["vendor"] },
-        { "gl_sl_version", glContextData["sl_version"] },
-        { "gl_renderer", glContextData["renderer"] },
-        { "ideal_thread_count", QThread::idealThreadCount() }
-    };
-    auto macVersion = QSysInfo::macVersion();
-    if (macVersion != QSysInfo::MV_None) {
-        properties["os_osx_version"] = QSysInfo::macVersion();
-    }
-    auto windowsVersion = QSysInfo::windowsVersion();
-    if (windowsVersion != QSysInfo::WV_None) {
-        properties["os_win_version"] = QSysInfo::windowsVersion();
     }
-    ProcessorInfo procInfo;
+    // In practice we shouldn't run across installs that don't have a known installer type.
-    if (getProcessorInfo(procInfo)) {
+    // Client or Client+Server installs should always have the installer.ini next to their
-        properties["processor_core_count"] = procInfo.numProcessorCores;
+    // respective interface.exe, and Steam installs will be detected as such. If a user were
-        properties["logical_processor_count"] = procInfo.numLogicalProcessors;
+    // to delete the installer.ini, though, and as an example, we won't know the context of the
-        properties["processor_l1_cache_count"] = procInfo.numProcessorCachesL1;
+    // original install.
-        properties["processor_l2_cache_count"] = procInfo.numProcessorCachesL2;
+    constexpr auto INSTALLER_KEY_TYPE = "type";
-        properties["processor_l3_cache_count"] = procInfo.numProcessorCachesL3;
+    constexpr auto INSTALLER_KEY_CAMPAIGN = "campaign";
+    constexpr auto INSTALLER_TYPE_UNKNOWN = "unknown";
+    constexpr auto INSTALLER_TYPE_STEAM = "steam";
+    auto typeIt = installerKeyValues.find(INSTALLER_KEY_TYPE);
+    QString installerType = INSTALLER_TYPE_UNKNOWN;
+    if (typeIt == installerKeyValues.end()) {
+        if (property(hifi::properties::STEAM).toBool()) {
+            installerType = INSTALLER_TYPE_STEAM;
+        }
+    } else {
+        installerType = typeIt->second;
     }
+    auto campaignIt = installerKeyValues.find(INSTALLER_KEY_CAMPAIGN);
+    QString installerCampaign = campaignIt != installerKeyValues.end() ? campaignIt->second : "";
+    qDebug() << "Detected installer type:" << installerType;
+    qDebug() << "Detected installer campaign:" << installerCampaign;
     // add firstRun flag from settings to launch event
     Setting::Handle<bool> firstRun { Settings::firstRun, true };
         QJsonObject properties = {
             { "version", applicationVersion() },
             { "tester", QProcessEnvironment::systemEnvironment().contains(TESTER) },
+            { "installer_campaign", installerCampaign },
+            { "installer_type", installerType },
             { "previousSessionCrashed", _previousSessionCrashed },
             { "previousSessionRuntime", sessionRunTime.get() },
             { "cpu_architecture", QSysInfo::currentCpuArchitecture() },
     const QString HIFI_NO_UPDATER_COMMAND_LINE_KEY = "--no-updater";
     bool noUpdater = arguments().indexOf(HIFI_NO_UPDATER_COMMAND_LINE_KEY) != -1;
     if (!noUpdater) {
+        constexpr auto INSTALLER_TYPE_CLIENT_ONLY = "client_only";
         auto applicationUpdater = DependencyManager::get<AutoUpdater>();
+        AutoUpdater::InstallerType type = installerType == INSTALLER_TYPE_CLIENT_ONLY
+            ? AutoUpdater::InstallerType::CLIENT_ONLY : AutoUpdater::InstallerType::FULL;
+        applicationUpdater->setInstallerType(type);
+        applicationUpdater->setInstallerCampaign(installerCampaign);
         connect(applicationUpdater.data(), &AutoUpdater::newVersionIsAvailable, dialogsManager.data(), &DialogsManager::showUpdateDialog);
         applicationUpdater->checkForUpdate();
     }
 #endif
 }
+void Application::updateVerboseLogging() {
+    bool enable = Menu::getInstance()->isOptionChecked(MenuOption::VerboseLogging);
+    const_cast<QLoggingCategory*>(&animation())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&animation())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&avatars())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&avatars())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&scriptengine())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&scriptengine())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&modelformat())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&modelformat())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&controllers())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&controllers())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&resourceLog())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&resourceLog())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&networking())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&networking())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&asset_client())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&asset_client())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&messages_client())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&messages_client())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&storagelogging())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&storagelogging())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&uiLogging())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&uiLogging())->setEnabled(QtInfoMsg, enable);
+    const_cast<QLoggingCategory*>(&glLogging())->setEnabled(QtDebugMsg, enable);
+    const_cast<QLoggingCategory*>(&glLogging())->setEnabled(QtInfoMsg, enable);
+}
 void Application::domainConnectionRefused(const QString& reasonMessage, int reasonCodeInt, const QString& extraInfo) {
     DomainHandler::ConnectionRefusedReason reasonCode = static_cast<DomainHandler::ConnectionRefusedReason>(reasonCodeInt);
     PROFILE_RANGE(render, __FUNCTION__);
     bool sandboxIsRunning = SandboxUtils::readStatus(reply->readAll());
-    qDebug() << "HandleSandboxStatus" << sandboxIsRunning;
     enum HandControllerType {
         Vive,
     }
 }
-void Application::pushPostUpdateLambda(void* key, std::function<void()> func) {
+void Application::pushPostUpdateLambda(void* key, const std::function<void()>& func) {
     std::unique_lock<std::mutex> guard(_postUpdateLambdasLock);
     _postUpdateLambdas[key] = func;
 }
     }
 }
-void Application::postLambdaEvent(std::function<void()> f) {
+void Application::postLambdaEvent(const std::function<void()>& f) {
     if (this->thread() == QThread::currentThread()) {
         f();
     } else {
     }
 }
+void Application::sendLambdaEvent(const std::function<void()>& f) {
+    if (this->thread() == QThread::currentThread()) {
+        f();
+    } else {
+        LambdaEvent event(f);
+        QCoreApplication::sendEvent(this, &event);
+    }
+}
 void Application::initPlugins(const QStringList& arguments) {
     QCommandLineOption display("display", "Preferred displays", "displays");
     QCommandLineOption disableDisplays("disable-displays", "Displays to disable", "displays");