Merge branch 'master' of github.com:highfidelity/hifi

cmake/macros/SetPackagingParameters.cmake

@@ -131,8 +131,11 @@ macro(SET_PACKAGING_PARAMETERS)
   endif ()
 
   if (DEPLOY_PACKAGE)
-    # for deployed packages always grab the serverless content
+    # For deployed packages we do not grab the serverless content any longer.
-    set(DOWNLOAD_SERVERLESS_CONTENT ON)
+    # Instead, we deploy just the serverless content that is in the interface/resources/serverless
+    # directory. If we ever move back to delivering serverless via a hosted .zip file,
+    # we can re-enable this.
+    set(DOWNLOAD_SERVERLESS_CONTENT OFF)
   endif ()
 
   if (APPLE)

interface/resources/html/createGlobalEventBridge.js

@@ -33,33 +33,6 @@ var EventBridge;
         // replace the TempEventBridge with the real one.
         var tempEventBridge = EventBridge;
         EventBridge = channel.objects.eventBridge;
-        EventBridge.audioOutputDeviceChanged.connect(function(deviceName) {      
-            navigator.mediaDevices.getUserMedia({ audio: true, video: false }).then(function(mediaStream) {
-                navigator.mediaDevices.enumerateDevices().then(function(devices) {
-                    devices.forEach(function(device) {
-                        if (device.kind == "audiooutput") {
-                            if (device.label == deviceName){
-                                console.log("Changing HTML audio output to device " + device.label);
-                                var deviceId = device.deviceId;
-                                var videos = document.getElementsByTagName("video");
-                                for (var i = 0; i < videos.length; i++){
-                                    videos[i].setSinkId(deviceId);
-                                }
-                                var audios = document.getElementsByTagName("audio");
-                                for (var i = 0; i < audios.length; i++){
-                                    audios[i].setSinkId(deviceId);
-                                }
-                            }
-                        }
-                    });
-
-                }).catch(function(err) {
-                    console.log("Error getting media devices"+ err.name + ": " + err.message);
-                });
-            }).catch(function(err) {
-                console.log("Error getting user media"+ err.name + ": " + err.message);
-            });
-        });
         
         // To be able to update the state of the output device selection for every element added to the DOM
         // we need to listen to events that might precede the addition of this elements.

interface/src/Application.cpp

@@ -2824,6 +2824,7 @@ void Application::cleanupBeforeQuit() {
 
     // destroy Audio so it and its threads have a chance to go down safely
     // this must happen after QML, as there are unexplained audio crashes originating in qtwebengine
+    AudioInjector::setLocalAudioInterface(nullptr);
     DependencyManager::destroy<AudioClient>();
     DependencyManager::destroy<AudioScriptingInterface>();
 

interface/src/ui/InteractiveWindow.cpp

@@ -69,6 +69,14 @@ void QmlWindowProxy::parentNativeWindowToMainWindow() {
 #endif
 }
 
+void InteractiveWindowProxy::emitScriptEvent(const QVariant& scriptMessage){
+    emit scriptEventReceived(scriptMessage);
+}
+
+void InteractiveWindowProxy::emitWebEvent(const QVariant& webMessage) {
+    emit webEventReceived(webMessage);
+}
+
 static void qmlWindowProxyDeleter(QmlWindowProxy* qmlWindowProxy) {
     qmlWindowProxy->deleteLater();
 }
@@ -129,6 +137,12 @@ InteractiveWindow::InteractiveWindow(const QString& sourceUrl, const QVariantMap
         presentationMode = (InteractiveWindowPresentationMode) properties[PRESENTATION_MODE_PROPERTY].toInt();
     }
 
+    if (!_interactiveWindowProxy) {
+        _interactiveWindowProxy = new InteractiveWindowProxy();
+        QObject::connect(_interactiveWindowProxy, &InteractiveWindowProxy::webEventReceived, this, &InteractiveWindow::emitWebEvent, Qt::QueuedConnection);
+        QObject::connect(this, &InteractiveWindow::scriptEventReceived, _interactiveWindowProxy, &InteractiveWindowProxy::emitScriptEvent, Qt::QueuedConnection);
+    }
+
     if (properties.contains(DOCKED_PROPERTY) && presentationMode == InteractiveWindowPresentationMode::Native) {
         QVariantMap nativeWindowInfo = properties[DOCKED_PROPERTY].toMap();
         Qt::DockWidgetArea dockArea = Qt::TopDockWidgetArea;
@@ -182,13 +196,17 @@ InteractiveWindow::InteractiveWindow(const QString& sourceUrl, const QVariantMap
                     break;
             }
         }
-
+      
+        
         QObject::connect(quickView.get(), &QQuickView::statusChanged, [&, this] (QQuickView::Status status) {
             if (status == QQuickView::Ready) {
                 QQuickItem* rootItem = _dockWidget->getRootItem();
-                _dockWidget->getQuickView()->rootContext()->setContextProperty(EVENT_BRIDGE_PROPERTY, this);
+                _dockWidget->getQuickView()->rootContext()->setContextProperty(EVENT_BRIDGE_PROPERTY, _interactiveWindowProxy);
+                // The qmlToScript method handles the thread-safety of this call. Because the QVariant argument
+                // passed to the sendToScript signal may wrap an externally managed and thread-unsafe QJSValue,
+                // qmlToScript needs to be called directly, so the QJSValue can be immediately converted to a plain QVariant.
                 QObject::connect(rootItem, SIGNAL(sendToScript(QVariant)), this, SLOT(qmlToScript(const QVariant&)),
-                                 Qt::QueuedConnection);
+                                 Qt::DirectConnection);
                 QObject::connect(rootItem, SIGNAL(keyPressEvent(int, int)), this, SLOT(forwardKeyPressEvent(int, int)),
                                  Qt::QueuedConnection);
                 QObject::connect(rootItem, SIGNAL(keyReleaseEvent(int, int)), this, SLOT(forwardKeyReleaseEvent(int, int)),
@@ -204,7 +222,7 @@ InteractiveWindow::InteractiveWindow(const QString& sourceUrl, const QVariantMap
         // Build the event bridge and wrapper on the main thread
         offscreenUi->loadInNewContext(CONTENT_WINDOW_QML, [&](QQmlContext* context, QObject* object) {
             _qmlWindowProxy = std::shared_ptr<QmlWindowProxy>(new QmlWindowProxy(object, nullptr), qmlWindowProxyDeleter);
-            context->setContextProperty(EVENT_BRIDGE_PROPERTY, this);
+            context->setContextProperty(EVENT_BRIDGE_PROPERTY, _interactiveWindowProxy);
             if (properties.contains(ADDITIONAL_FLAGS_PROPERTY)) {
                 object->setProperty(ADDITIONAL_FLAGS_PROPERTY, properties[ADDITIONAL_FLAGS_PROPERTY].toUInt());
             }
@@ -229,7 +247,10 @@ InteractiveWindow::InteractiveWindow(const QString& sourceUrl, const QVariantMap
                 object->setProperty(VISIBLE_PROPERTY, properties[INTERACTIVE_WINDOW_VISIBLE_PROPERTY].toBool());
             }
 
-            connect(object, SIGNAL(sendToScript(QVariant)), this, SLOT(qmlToScript(const QVariant&)), Qt::QueuedConnection);
+            // The qmlToScript method handles the thread-safety of this call. Because the QVariant argument
+            // passed to the sendToScript signal may wrap an externally managed and thread-unsafe QJSValue,
+            // qmlToScript needs to be called directly, so the QJSValue can be immediately converted to a plain QVariant.
+            connect(object, SIGNAL(sendToScript(QVariant)), this, SLOT(qmlToScript(const QVariant&)), Qt::DirectConnection);
             QObject::connect(object, SIGNAL(keyPressEvent(int, int)), this, SLOT(forwardKeyPressEvent(int, int)),
                              Qt::QueuedConnection);
             QObject::connect(object, SIGNAL(keyReleaseEvent(int, int)), this, SLOT(forwardKeyReleaseEvent(int, int)),
@@ -263,6 +284,7 @@ InteractiveWindow::~InteractiveWindow() {
 }
 
 void InteractiveWindow::sendToQml(const QVariant& message) {
+
     // Forward messages received from the script on to QML
     if (_dockWidget) {
         QQuickItem* rootItem = _dockWidget->getRootItem();
@@ -291,6 +313,10 @@ void InteractiveWindow::close() {
         _qmlWindowProxy->deleteLater();
     }
 
+    if (_interactiveWindowProxy) {
+        _interactiveWindowProxy->deleteLater();
+    }
+
     if (_dockWidget) {
         auto window = qApp->getWindow();
         if (QThread::currentThread() != window->thread()) {
@@ -301,6 +327,7 @@ void InteractiveWindow::close() {
     }
     _dockWidget = nullptr;
     _qmlWindowProxy = nullptr;
+    _interactiveWindowProxy = nullptr;
 }
 
 void InteractiveWindow::show() {
@@ -315,13 +342,21 @@ void InteractiveWindow::raise() {
     }
 }
 
-void InteractiveWindow::qmlToScript(const QVariant& message) {
+void InteractiveWindow::qmlToScript(const QVariant& originalMessage) {
+    QVariant message = originalMessage;
     if (message.canConvert<QJSValue>()) {
-        emit fromQml(qvariant_cast<QJSValue>(message).toVariant());
+        message = qvariant_cast<QJSValue>(message).toVariant();
     } else if (message.canConvert<QString>()) {
-        emit fromQml(message.toString());
+        message = message.toString();
     } else {
         qWarning() << "Unsupported message type " << message;
+        return;
+    }
+
+    if (thread() != QThread::currentThread()) {
+        QMetaObject::invokeMethod(this, "fromQml", Q_ARG(const QVariant&, message));
+    } else {
+        emit fromQml(message);
     }
 }
 

interface/src/ui/InteractiveWindow.h

@@ -34,7 +34,23 @@ public:
     QObject* getQmlWindow() const { return _qmlWindow; }
 private:
     QObject* _qmlWindow;
+};
 
+
+class InteractiveWindowProxy : public QObject {
+    Q_OBJECT
+public:
+    InteractiveWindowProxy(){}
+
+public slots:
+
+    void emitScriptEvent(const QVariant& scriptMessage);
+    void emitWebEvent(const QVariant& webMessage);
+
+signals:
+
+    void scriptEventReceived(const QVariant& message);
+    void webEventReceived(const QVariant& message);
 };
 
 
@@ -309,6 +325,7 @@ protected slots:
 private:
     std::shared_ptr<QmlWindowProxy> _qmlWindowProxy;
     std::shared_ptr<DockWidget> _dockWidget { nullptr };
+    InteractiveWindowProxy *_interactiveWindowProxy{ nullptr };
 };
 
 typedef InteractiveWindow* InteractiveWindowPointer;

launchers/win32/CMakeLists.txt

@@ -10,6 +10,7 @@ set(CMAKE_MFC_FLAG 1)
 
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+include("cmake/macros/SetPackagingParameters.cmake")
 
 add_executable(HQLauncher
   WIN32
@@ -49,6 +50,8 @@ function(set_from_env _RESULT_NAME _ENV_VAR_NAME _DEFAULT_VALUE)
     endif()
 endfunction()
 
+set_packaging_parameters()
+
 set_from_env(LAUNCHER_HMAC_SECRET LAUNCHER_HMAC_SECRET "")
 
 if (LAUNCHER_HMAC_SECRET STREQUAL "")
@@ -56,7 +59,7 @@ if (LAUNCHER_HMAC_SECRET STREQUAL "")
 endif()
 
 target_compile_definitions(${PROJECT_NAME} PRIVATE LAUNCHER_HMAC_SECRET="${LAUNCHER_HMAC_SECRET}")
-
+target_compile_definitions(${PROJECT_NAME} PRIVATE LAUNCHER_BUILD_VERSION="${BUILD_VERSION}")
 
 # Preprocessor definitions
 target_compile_definitions(HQLauncher PRIVATE

launchers/win32/Launcher.rc

@@ -92,8 +92,8 @@ STYLE DS_SETFONT | DS_FIXEDSYS | WS_POPUP | WS_VISIBLE | WS_CAPTION
 EXSTYLE WS_EX_APPWINDOW
 FONT 10, "MS Shell Dlg", 400, 0, 0x0
 BEGIN
-    CONTROL         "",IDC_VOXEL,"Static",SS_BLACKRECT,65,3,174,123, NOT WS_VISIBLE
+    CONTROL         "",IDC_VOXEL,"Static",SS_BLACKRECT,65,3,174,123
-    CONTROL         "", IDC_PROGRESS, "Static", SS_BLACKRECT, 35, 170, 239, 4, NOT WS_VISIBLE
+    CONTROL         "",IDC_PROGRESS,"Static",SS_BLACKRECT,35,170,239,4
     EDITTEXT        IDC_ORGNAME,44,68,219,12,ES_AUTOHSCROLL | NOT WS_VISIBLE | NOT WS_BORDER
     EDITTEXT        IDC_USERNAME,44,95,219,12,ES_AUTOHSCROLL | NOT WS_VISIBLE | NOT WS_BORDER
     EDITTEXT        IDC_PASSWORD,44,122,219,12,ES_PASSWORD | ES_AUTOHSCROLL | NOT WS_VISIBLE | NOT WS_BORDER
@@ -107,6 +107,7 @@ BEGIN
     RTEXT           "",IDC_TERMS,15,172,180,15,NOT WS_VISIBLE
     CONTROL         "",IDC_TERMS_LINK,"Button",BS_OWNERDRAW | BS_FLAT | NOT WS_VISIBLE | WS_TABSTOP,197,172,80,15
     CTEXT           "",IDC_TROUBLE,65,203,174,15,NOT WS_VISIBLE
+    RTEXT           "",IDC_VERSION,100,205,205,10
     CONTROL         "NEXT",IDC_BUTTON_NEXT,"Button",BS_OWNERDRAW | BS_FLAT | NOT WS_VISIBLE | WS_TABSTOP,107,158,94,16
     CONTROL         "Having Trouble?",IDC_TROUBLE_LINK,"Button",BS_OWNERDRAW | BS_FLAT | NOT WS_VISIBLE | WS_TABSTOP,126,203,56,11
 END

launchers/win32/LauncherApp.cpp

@@ -39,16 +39,28 @@ BOOL CLauncherApp::InitInstance() {
     }
     int iNumOfArgs;
     LPWSTR* pArgs = CommandLineToArgvW(GetCommandLine(), &iNumOfArgs);
-    bool isUninstalling = false;
+    bool uninstalling = false;
-    bool isRestarting = false;
+    bool restarting = false;
+    bool noUpdate = false;
+    bool continueUpdating = false;
+    bool skipSplash = false;
     if (iNumOfArgs > 1) {
-        if (CString(pArgs[1]).Compare(_T("--uninstall")) == 0) {
+        for (int i = 1; i < iNumOfArgs; i++) {
-            isUninstalling = true;
+            CString curArg = CString(pArgs[i]);
-        } else if (CString(pArgs[1]).Compare(_T("--restart")) == 0) {
+            if (curArg.Compare(_T("--uninstall")) == 0) {
-            isRestarting = true;
+                uninstalling = true;
+            } else if (curArg.Compare(_T("--restart")) == 0) {
+                restarting = true;
+            } else if (curArg.Compare(_T("--noUpdate")) == 0) {
+                noUpdate = true;
+            } else if (curArg.Compare(_T("--continueUpdating")) == 0) {
+                continueUpdating = true;
+            } else if (curArg.Compare(_T("--skipSplash")) == 0) {
+                skipSplash = true;
+            }
         }
     }
-    if (!isRestarting) {
+    if (!restarting) {
         // don't launch if already running
         CreateMutex(NULL, TRUE, _T("HQ_Launcher_Mutex"));
         if (GetLastError() == ERROR_ALREADY_EXISTS) {
@@ -56,10 +68,10 @@ BOOL CLauncherApp::InitInstance() {
         }
     }
 
-    if (isUninstalling) {
+    if (uninstalling) {
         _manager.uninstall();
     } else {
-        _manager.init();
+        _manager.init(!noUpdate, continueUpdating, skipSplash);
     }   
     if (!_manager.hasFailed() && !_manager.installLauncher()) {
         return FALSE;

launchers/win32/LauncherDlg.cpp

@@ -40,6 +40,8 @@ static CString GRAPHIK_SEMIBOLD = _T("Graphik-Semibold");
 static CString TROUBLE_URL = _T("https://www.highfidelity.com/hq-support");
 static CString TERMS_URL = _T("https://www.highfidelity.com/termsofservice");
 
+static int SPLASH_DURATION = 100;
+
 
 CLauncherDlg::CLauncherDlg(CWnd* pParent)
     : CDialog(IDD_LAUNCHER_DIALOG, pParent)
@@ -112,6 +114,11 @@ BOOL CLauncherDlg::OnInitDialog() {
     m_voxel = (CStatic *)GetDlgItem(IDC_VOXEL);
     m_progress = (CStatic *)GetDlgItem(IDC_PROGRESS);
 
+    m_version = (CStatic *)GetDlgItem(IDC_VERSION);
+    CString version;
+    version.Format(_T("V.%s"), theApp._manager.getLauncherVersion());
+    m_version->SetWindowTextW(version);
+
     m_voxel->EnableD2DSupport();
     m_progress->EnableD2DSupport();
 
@@ -230,7 +237,6 @@ void CLauncherDlg::startProcess() {
             theApp._manager.setFailed(true);
         }
     });
-
 }
 
 BOOL CLauncherDlg::getHQInfo(const CString& orgname) {
@@ -322,11 +328,12 @@ void CLauncherDlg::drawLogo(CHwndRenderTarget* pRenderTarget) {
 void CLauncherDlg::drawSmallLogo(CHwndRenderTarget* pRenderTarget) {
     CD2DBitmap m_pBitmamLogo(pRenderTarget, IDB_PNG5, _T("PNG"));
     auto size = pRenderTarget->GetSize();
-    int padding = 6;
+    int xPadding = 6;
+    int yPadding = 22;
     int logoWidth = 100;
     int logoHeight = 18;
-    float logoPosX = size.width - logoWidth - padding;
+    float logoPosX = size.width - logoWidth - xPadding;
-    float logoPosY = size.height - logoHeight - padding;
+    float logoPosY = size.height - logoHeight - yPadding;
     CD2DRectF logoRec(logoPosX, logoPosY, logoPosX + logoWidth, logoPosY + logoHeight);
     pRenderTarget->DrawBitmap(&m_pBitmamLogo, logoRec);
 }
@@ -521,6 +528,7 @@ BOOL CLauncherDlg::getTextFormat(int resID, TextFormat& formatOut) {
         formatOut.size = FIELDS_FONT_SIZE;
         formatOut.color = COLOR_GREY;
         break;
+    case IDC_VERSION:
     case IDC_TERMS:
         formatOut.size = TERMS_FONT_SIZE;
         break;
@@ -663,16 +671,46 @@ void CLauncherDlg::OnTimer(UINT_PTR nIDEvent) {
             // Refresh
             setDrawDialog(_drawStep, true);
         }
+
+        if (theApp._manager.needsSelfUpdate()) {
+            if (theApp._manager.needsSelfDownload()) {
+                theApp._manager.downloadNewLauncher();
+            } else {
+                if (_splashStep > SPLASH_DURATION && _splashStep < 2 * SPLASH_DURATION) {
+                    float progress = (float)(_splashStep - SPLASH_DURATION) / SPLASH_DURATION;
+                    if (theApp._manager.willContinueUpdating()) {
+                        progress = CONTINUE_UPDATING_GLOBAL_OFFSET * progress;
+                        progress = min(progress, CONTINUE_UPDATING_GLOBAL_OFFSET);
+                    }                    
+                    theApp._manager.updateProgress(LauncherManager::ProcessType::Uninstall, progress);
+                    _splashStep++;
+                }
+                if (theApp._manager.needsRestartNewLauncher()) {
+                    if (_splashStep >= 2 * SPLASH_DURATION) {
+                        theApp._manager.restartNewLauncher();
+                        exit(0);
+                    }
+                }
+            }
+        }
         if (_showSplash) {
             if (_splashStep == 0) {
                 if (theApp._manager.needsUninstall()) {
                     theApp._manager.addToLog(_T("Waiting to uninstall"));
                     setDrawDialog(DrawStep::DrawProcessUninstall);
+                } else if (theApp._manager.shouldContinueUpdating()) {
+                    _splashStep = SPLASH_DURATION;
+                    setDrawDialog(DrawStep::DrawProcessUpdate);
+                    theApp._manager.updateProgress(LauncherManager::ProcessType::Uninstall, 0.0f);
                 } else {
-                    theApp._manager.addToLog(_T("Start splash screen"));
+                    if (theApp._manager.shouldSkipSplashScreen()) {
-                    setDrawDialog(DrawStep::DrawLogo);
+                        _splashStep = SPLASH_DURATION;
+                    } else {
+                        theApp._manager.addToLog(_T("Start splash screen"));
+                        setDrawDialog(DrawStep::DrawLogo);
+                    }
                 }
-            } else if (_splashStep > 100 && !theApp._manager.needsToWait()) {
+            } else if (_splashStep > SPLASH_DURATION && !theApp._manager.needsToWait()) {
                 _showSplash = false;
                 if (theApp._manager.shouldShutDown()) {
                     if (_applicationWND != NULL) {
@@ -692,12 +730,14 @@ void CLauncherDlg::OnTimer(UINT_PTR nIDEvent) {
                         theApp._manager.addToLog(_T("HQ failed to uninstall."));
                         theApp._manager.setFailed(true);
                     }
+                } else if (theApp._manager.needsSelfUpdate()) {
+                    setDrawDialog(DrawStep::DrawProcessUpdate);
                 } else {
                     theApp._manager.addToLog(_T("Starting login"));
                     setDrawDialog(DrawStep::DrawLoginLogin);
                 }
             } else if (theApp._manager.needsUninstall()) {
-                theApp._manager.updateProgress(LauncherManager::ProcessType::Uninstall, (float)_splashStep/100);
+                theApp._manager.updateProgress(LauncherManager::ProcessType::Uninstall, (float)_splashStep / SPLASH_DURATION);
             }
             _splashStep++;
         } else if (theApp._manager.shouldShutDown()) {
@@ -741,12 +781,17 @@ void CLauncherDlg::setDrawDialog(DrawStep step, BOOL isUpdate) {
     auto m_voxelRenderTarget = m_voxel->GetRenderTarget();
     auto m_progressRenderTarget = m_progress->GetRenderTarget();
     switch (_drawStep) {
-    case DrawStep::DrawLogo:
+    case DrawStep::DrawLogo: {
         m_pRenderTarget->BeginDraw();
         drawBackground(m_pRenderTarget);
         drawLogo(m_pRenderTarget);
         m_pRenderTarget->EndDraw();
+        CRect redrawRec;
+        GetClientRect(redrawRec);
+        redrawRec.top = redrawRec.bottom - 30;
+        RedrawWindow(redrawRec);
         break;
+    }
     case DrawStep::DrawLoginLogin:
     case DrawStep::DrawLoginErrorOrg:
     case DrawStep::DrawLoginErrorCred:

launchers/win32/LauncherDlg.h

@@ -94,6 +94,8 @@ protected:
     CStatic* m_username_banner;
     CStatic* m_password_banner;
 
+    CStatic* m_version;
+
     HWND _applicationWND { 0 };
 
     void drawBackground(CHwndRenderTarget* pRenderTarget);

launchers/win32/LauncherManager.cpp

@@ -21,10 +21,20 @@ LauncherManager::LauncherManager() {
 LauncherManager::~LauncherManager() {
 }
 
-void LauncherManager::init() {
+void LauncherManager::init(BOOL allowUpdate, BOOL continueUpdating, BOOL skipSplashScreen) {
     initLog();
-    addToLog(_T("Getting most recent build"));
+    int tokenPos = 0;
-    getMostRecentBuild(_latestApplicationURL, _latestVersion);
+    _updateLauncherAllowed = allowUpdate;
+    _continueUpdating = continueUpdating;
+    _skipSplashScreen = skipSplashScreen;
+    _shouldWait = !skipSplashScreen;
+    if (_continueUpdating) {
+        _progressOffset = CONTINUE_UPDATING_GLOBAL_OFFSET;
+    }
+    _launcherVersion = CString(LAUNCHER_BUILD_VERSION).Tokenize(_T("-"), tokenPos);
+    addToLog(_T("Launcher is running version: " + _launcherVersion));
+    addToLog(_T("Getting most recent builds"));
+    getMostRecentBuilds(_latestLauncherURL, _latestLauncherVersion, _latestApplicationURL, _latestVersion);
 }
 
 BOOL LauncherManager::initLog() {
@@ -124,6 +134,8 @@ BOOL LauncherManager::restartLauncher() {
 
 void LauncherManager::updateProgress(ProcessType processType, float progress) {
     switch (processType) {
+    case ProcessType::DownloadLauncher:
+        break;
     case ProcessType::Uninstall:
         _progress = progress;
         break;
@@ -153,6 +165,7 @@ void LauncherManager::updateProgress(ProcessType processType, float progress) {
     default:
         break;
     }
+    _progress = _progressOffset + (1.0f - _progressOffset) * _progress;
     TRACE("progress = %f\n", _progress);
 }
 
@@ -200,11 +213,11 @@ BOOL LauncherManager::isApplicationInstalled(CString& version, CString& domain,
     CString applicationDir;
     getAndCreatePaths(PathType::Launcher_Directory, applicationDir);
     CString applicationPath = applicationDir + "interface\\interface.exe";
-    BOOL isApplicationInstalled = PathFileExistsW(applicationPath);
+    BOOL isInstalled = PathFileExistsW(applicationPath);
     BOOL configFileExist = PathFileExistsW(applicationDir + _T("interface\\config.json"));
     if (configFileExist) {
         LauncherUtils::ResponseError status = readConfigJSON(version, domain, content, loggedIn);
-        return isApplicationInstalled && status == LauncherUtils::ResponseError::NoError;
+        return isInstalled && status == LauncherUtils::ResponseError::NoError;
     }
     return FALSE;
 }
@@ -359,14 +372,23 @@ LauncherUtils::ResponseError LauncherManager::readOrganizationJSON(const CString
     return LauncherUtils::ResponseError::ParsingJSON;
 }
 
-void LauncherManager::getMostRecentBuild(CString& urlOut, CString& versionOut) {
+void LauncherManager::getMostRecentBuilds(CString& launcherUrlOut, CString& launcherVersionOut,
+                                          CString& interfaceUrlOut, CString& interfaceVersionOut) {
     CString contentTypeJson = L"content-type:application/json";
     std::function<void(CString, int)> httpCallback = [&](CString response, int err) {
         LauncherUtils::ResponseError error = LauncherUtils::ResponseError(err);
         if (error == LauncherUtils::ResponseError::NoError) {
             Json::Value json;
-            error = LauncherUtils::ResponseError::ParsingJSON;
             if (LauncherUtils::parseJSON(response, json)) {
+                if (json["launcher"].isObject()) {
+                    if (json["launcher"]["windows"].isObject() && json["launcher"]["windows"]["url"].isString()) {
+                        launcherUrlOut = json["launcher"]["windows"]["url"].asCString();
+                    }
+                    if (json["launcher"]["version"].isInt()) {
+                        std::string version = std::to_string(json["launcher"]["version"].asInt());
+                        launcherVersionOut = CString(version.c_str());
+                    }
+                }
                 int count = json["count"].isInt() ? json["count"].asInt() : 0;
                 if (count > 0 && json["results"].isArray()) {
                     for (int i = 0; i < count; i++) {
@@ -374,19 +396,21 @@ void LauncherManager::getMostRecentBuild(CString& urlOut, CString& versionOut) {
                             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());
+                                interfaceVersionOut = 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();
+                                interfaceUrlOut = result["installers"]["windows"]["zip_url"].asCString();
-                                error = LauncherUtils::ResponseError::NoError;
                             }
                         }
                     }
                 }
+                if (launcherUrlOut.IsEmpty() || launcherVersionOut.IsEmpty() || interfaceUrlOut.IsEmpty() || interfaceVersionOut.IsEmpty()) {
+                    error = LauncherUtils::ResponseError::ParsingJSON;
+                }
             }
-            onMostRecentBuildReceived(response, error);
+            onMostRecentBuildsReceived(response, error);
         }
     };
     LauncherUtils::httpCallOnThread(L"HQ Launcher",
@@ -395,31 +419,49 @@ void LauncherManager::getMostRecentBuild(CString& urlOut, CString& versionOut) {
                                     contentTypeJson, CStringA(), false, httpCallback);
 }
 
-void LauncherManager::onMostRecentBuildReceived(const CString& response, LauncherUtils::ResponseError error) {
+void LauncherManager::onMostRecentBuildsReceived(const CString& response, LauncherUtils::ResponseError error) {
     if (error == LauncherUtils::ResponseError::NoError) {
-        addToLog(_T("Latest version: ") + _latestVersion);
+        addToLog(_T("Latest launcher version: ") + _latestLauncherVersion);
         CString currentVersion;
-        if (isApplicationInstalled(currentVersion, _domainURL, _contentURL, _loggedIn) && _loggedIn) {
+        BOOL isInstalled = (isApplicationInstalled(currentVersion, _domainURL, _contentURL, _loggedIn) && _loggedIn);
-            addToLog(_T("Installed version: ") + currentVersion);
+        bool newInterfaceVersion = _latestVersion.Compare(currentVersion) != 0;
-            if (_latestVersion.Compare(currentVersion) == 0) {
+        bool newLauncherVersion = _latestLauncherVersion.Compare(_launcherVersion) != 0 && _updateLauncherAllowed;
-                addToLog(_T("Already running most recent build. Launching interface.exe"));
+        if (newLauncherVersion) {
-                _shouldLaunch = TRUE;
+            CString updatingMsg;
-                _shouldShutdown = TRUE;
+            updatingMsg.Format(_T("Updating Launcher from version: %s to version: %s"), _launcherVersion, _latestLauncherVersion);
-            } else {
+            addToLog(updatingMsg);
-                addToLog(_T("New build found. Updating"));
+            _shouldUpdateLauncher = TRUE;
-                _shouldUpdate = TRUE;
+            _shouldDownloadLauncher = TRUE;
-            }
+            _willContinueUpdating = isInstalled && newInterfaceVersion;
-        } else if (_loggedIn) {
-            addToLog(_T("Interface not found but logged in. Reinstalling"));
-            _shouldUpdate = TRUE;
         } else {
-            _shouldInstall = TRUE;
+            if (_updateLauncherAllowed) {
+                addToLog(_T("Already running most recent build. Launching interface.exe"));
+            } else {
+                addToLog(_T("Updating the launcher was not allowed --noUpdate"));
+            }            
+            if (isInstalled) {
+                addToLog(_T("Installed version: ") + currentVersion);
+                if (!newInterfaceVersion) {
+                    addToLog(_T("Already running most recent build. Launching interface.exe"));
+                    _shouldLaunch = TRUE;
+                    _shouldShutdown = TRUE;
+                } else {
+                    addToLog(_T("New build found. Updating"));
+                    _shouldUpdate = TRUE;
+                }
+            } else if (_loggedIn) {
+                addToLog(_T("Interface not found but logged in. Reinstalling"));
+                _shouldUpdate = TRUE;
+            } else {
+                _shouldInstall = TRUE;
+            }
         }
         _shouldWait = FALSE;
+        
     } else {
         _hasFailed = true;
         CString msg;
-        msg.Format(_T("Getting most recent build has failed with error: %d"), error);
+        msg.Format(_T("Getting most recent builds has failed with error: %d"), error);
         addToLog(msg);
         msg.Format(_T("Response: %s"), response);
         addToLog(msg);
@@ -521,7 +563,7 @@ BOOL LauncherManager::extractApplication() {
         }
     };
     std::function<void(float)> onProgress = [&](float progress) {
-        updateProgress(ProcessType::UnzipApplication, progress);
+        updateProgress(ProcessType::UnzipApplication, max(progress, 0.0f));
     };
     _currentProcess = ProcessType::UnzipApplication;
     BOOL success = LauncherUtils::unzipFileOnThread(ProcessType::UnzipApplication, 
@@ -563,9 +605,21 @@ void LauncherManager::onFileDownloaded(ProcessType type) {
                 setFailed(true);
             }
         });
+    } else if (type == ProcessType::DownloadLauncher) {
+        _shouldRestartNewLauncher = true;
     }
 }
 
+void LauncherManager::restartNewLauncher() {
+    closeLog();
+    if (_willContinueUpdating) {
+        LauncherUtils::launchApplication(_tempLauncherPath, _T(" --restart --noUpdate --continueUpdating"));
+    } else {
+        LauncherUtils::launchApplication(_tempLauncherPath, _T(" --restart --noUpdate --skipSplash"));
+    }    
+    Sleep(500);
+}
+
 
 BOOL LauncherManager::installContent() {
     std::string contentZipFile = LauncherUtils::cStringToStd(_contentZipPath);
@@ -582,7 +636,7 @@ BOOL LauncherManager::installContent() {
         }
     };
     std::function<void(float)> onProgress = [&](float progress) {
-        updateProgress(ProcessType::UnzipContent, progress);
+        updateProgress(ProcessType::UnzipContent, max(progress, 0.0f));
     };
     _currentProcess = ProcessType::UnzipContent;
     BOOL success = LauncherUtils::unzipFileOnThread(ProcessType::UnzipContent, contentZipFile,
@@ -597,10 +651,13 @@ BOOL LauncherManager::installContent() {
 
 
 BOOL LauncherManager::downloadFile(ProcessType type, const CString& url, CString& outPath) {
-    CString fileName = url.Mid(url.ReverseFind('/') + 1);
+    BOOL success = TRUE;
-    CString downloadDirectory;
+    if (outPath.IsEmpty()) {
-    BOOL success = getAndCreatePaths(LauncherManager::PathType::Download_Directory, downloadDirectory);
+        CString fileName = url.Mid(url.ReverseFind('/') + 1);
-    outPath = downloadDirectory + fileName;
+        CString downloadDirectory;
+        BOOL success = getAndCreatePaths(LauncherManager::PathType::Download_Directory, downloadDirectory);
+        outPath = downloadDirectory + fileName;
+    }
     _currentProcess = type;
     if (success) {
         addToLog(_T("Downloading: ") + url);
@@ -610,18 +667,18 @@ BOOL LauncherManager::downloadFile(ProcessType type, const CString& url, CString
             } else {
                 if (type == ProcessType::DownloadApplication) {
                     addToLog(_T("Error downloading content."));
+                } else if (type == ProcessType::DownloadLauncher) {
+                    addToLog(_T("Error downloading launcher."));
                 } else {
                     addToLog(_T("Error downloading application."));
                 }
                 _hasFailed = true;
             }
         };
-        std::function<void(float)> onProgress = [&](float progress) {
+        std::function<void(float)> onProgress = [&, type](float progress) {
-            updateProgress(_currentProcess, progress);
+            updateProgress(_currentProcess, max(progress, 0.0f));
         };
-        if (!LauncherUtils::downloadFileOnThread(type, url, outPath, onDownloadFinished, onProgress)) {
+        success = LauncherUtils::downloadFileOnThread(type, url, outPath, onDownloadFinished, onProgress);
-            success = FALSE;
-        }
     }
     return success;
 }
@@ -637,6 +694,14 @@ BOOL LauncherManager::downloadApplication() {
     return downloadFile(ProcessType::DownloadApplication, applicationURL, _applicationZipPath);
 }
 
+BOOL LauncherManager::downloadNewLauncher() {
+    _shouldDownloadLauncher = FALSE;
+    getAndCreatePaths(PathType::Temp_Directory, _tempLauncherPath);
+    CString tempName = _T("HQLauncher") + _launcherVersion + _T(".exe");
+    _tempLauncherPath += tempName;
+    return downloadFile(ProcessType::DownloadLauncher, _latestLauncherURL, _tempLauncherPath);
+}
+
 void LauncherManager::onCancel() {
     if (_currentProcess == ProcessType::UnzipApplication) {
         _latestVersion = _T("");

launchers/win32/LauncherManager.h

@@ -25,6 +25,7 @@ const float DOWNLOAD_APPLICATION_INSTALL_WEIGHT = 0.5f;
 const float EXTRACT_APPLICATION_INSTALL_WEIGHT = 0.2f;
 const float DOWNLOAD_APPLICATION_UPDATE_WEIGHT = 0.75f;
 const float EXTRACT_APPLICATION_UPDATE_WEIGHT = 0.25f;
+const float CONTINUE_UPDATING_GLOBAL_OFFSET = 0.2f;
 
 class LauncherManager
 {
@@ -49,6 +50,7 @@ public:
         ErrorIOFiles
     };
     enum ProcessType {
+        DownloadLauncher = 0,
         DownloadContent,
         DownloadApplication,
         UnzipContent,
@@ -57,7 +59,7 @@ public:
     };
     LauncherManager();
     ~LauncherManager();
-    void init();
+    void init(BOOL allowUpdate, BOOL continueUpdating, BOOL skipSplashScreen);
     BOOL initLog();
     BOOL addToLog(const CString& line);
     void closeLog();
@@ -67,7 +69,8 @@ public:
     BOOL isApplicationInstalled(CString& version, CString& domain,
                                 CString& content, bool& loggedIn);
     LauncherUtils::ResponseError getAccessTokenForCredentials(const CString& username, const CString& password);
-    void getMostRecentBuild(CString& urlOut, CString& versionOut);
+    void getMostRecentBuilds(CString& launcherUrlOut, CString& launcherVersionOut, 
+                             CString& interfaceUrlOut, CString& interfaceVersionOut);
     LauncherUtils::ResponseError readOrganizationJSON(const CString& hash);
     LauncherUtils::ResponseError readConfigJSON(CString& version, CString& domain,
                                                 CString& content, bool& loggedIn);
@@ -87,13 +90,19 @@ public:
     const CString& getVersion() const { return _version; }
     BOOL shouldShutDown() const { return _shouldShutdown; }
     BOOL shouldLaunch() const { return _shouldLaunch; }
-    BOOL needsUpdate() { return _shouldUpdate; }
+    BOOL shouldSkipSplashScreen() const { return _skipSplashScreen; }
-    BOOL needsUninstall() { return _shouldUninstall; }
+    BOOL needsUpdate() const { return _shouldUpdate; }
-    BOOL needsInstall() { return _shouldInstall; }
+    BOOL needsSelfUpdate() const { return _shouldUpdateLauncher; }
-    BOOL needsToWait() { return _shouldWait; }
+    BOOL needsSelfDownload() const { return _shouldDownloadLauncher; }
+    BOOL needsUninstall() const { return _shouldUninstall; }
+    BOOL needsInstall() const { return _shouldInstall; }
+    BOOL needsToWait() const { return _shouldWait; }
+    BOOL needsRestartNewLauncher() const { return _shouldRestartNewLauncher; }
+    BOOL shouldContinueUpdating() const { return _continueUpdating; }
+    BOOL willContinueUpdating() const { return _willContinueUpdating; }
     void setDisplayName(const CString& displayName) { _displayName = displayName; }
-    bool isLoggedIn() { return _loggedIn; }
+    bool isLoggedIn() const { return _loggedIn; }
-    bool hasFailed() { return _hasFailed; }
+    bool hasFailed() const { return _hasFailed; }
     void setFailed(bool hasFailed) { _hasFailed = hasFailed; }
     const CString& getLatestInterfaceURL() const { return _latestApplicationURL; }
     void uninstall() { _shouldUninstall = true; _shouldWait = false; };
@@ -101,19 +110,24 @@ public:
     BOOL downloadFile(ProcessType type, const CString& url, CString& localPath);
     BOOL downloadContent();
     BOOL downloadApplication();
+    BOOL downloadNewLauncher();
     BOOL installContent();
     BOOL extractApplication();
+    void restartNewLauncher();
     void onZipExtracted(ProcessType type, int size);
     void onFileDownloaded(ProcessType type);
-    float getProgress() { return _progress; }
+    float getProgress() const { return _progress; }
     void updateProgress(ProcessType processType, float progress);
     void onCancel();
+    const CString& getLauncherVersion() const { return _launcherVersion; }
 
 private:
     ProcessType _currentProcess { ProcessType::DownloadApplication };
-    void onMostRecentBuildReceived(const CString& response, LauncherUtils::ResponseError error);
+    void onMostRecentBuildsReceived(const CString& response, LauncherUtils::ResponseError error);
     CString _latestApplicationURL;
     CString _latestVersion;
+    CString _latestLauncherURL;
+    CString _latestLauncherVersion;
     CString _contentURL;
     CString _domainURL;
     CString _version;
@@ -121,6 +135,8 @@ private:
     CString _tokensJSON;
     CString _applicationZipPath;
     CString _contentZipPath;
+    CString _launcherVersion;
+    CString _tempLauncherPath;
     bool _loggedIn { false };
     bool _hasFailed { false };
     BOOL _shouldUpdate { FALSE };
@@ -129,6 +145,14 @@ private:
     BOOL _shouldShutdown { FALSE };
     BOOL _shouldLaunch { FALSE };
     BOOL _shouldWait { TRUE };
+    BOOL _shouldUpdateLauncher { FALSE };
+    BOOL _shouldDownloadLauncher { FALSE };
+    BOOL _updateLauncherAllowed { TRUE };
+    BOOL _shouldRestartNewLauncher { FALSE };
+    BOOL _continueUpdating { FALSE };
+    BOOL _willContinueUpdating { FALSE };
+    BOOL _skipSplashScreen { FALSE };
+    float _progressOffset { 0.0f };
     float _progress { 0.0f };
     CStdioFile _logFile;
 };

launchers/win32/cmake/macros/SetPackagingParameters.cmake

@@ -0,0 +1,45 @@
+#
+#  SetPackagingParameters.cmake
+#  cmake/macros
+#
+#  Created by Leonardo Murillo on 07/14/2015.
+#  Copyright 2015 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
+
+# This macro checks some Jenkins defined environment variables to determine the origin of this build
+# and decides how targets should be packaged.
+
+macro(SET_PACKAGING_PARAMETERS)
+  set(PR_BUILD 0)
+  set(PRODUCTION_BUILD 0)
+  set(DEV_BUILD 0)
+  set(BUILD_NUMBER 0)
+
+  set_from_env(RELEASE_TYPE RELEASE_TYPE "DEV")
+  set_from_env(RELEASE_NUMBER RELEASE_NUMBER "")
+  set_from_env(STABLE_BUILD STABLE_BUILD 0)
+
+  message(STATUS "The RELEASE_TYPE variable is: ${RELEASE_TYPE}")
+  set(BUILD_NUMBER ${RELEASE_NUMBER})
+
+  if (RELEASE_TYPE STREQUAL "PRODUCTION")
+    set(PRODUCTION_BUILD 1)
+    set(BUILD_VERSION ${RELEASE_NUMBER})
+
+    # add definition for this release type
+    add_definitions(-DPRODUCTION_BUILD)
+
+  elseif (RELEASE_TYPE STREQUAL "PR")
+    set(PR_BUILD 1)
+    set(BUILD_VERSION "PR${RELEASE_NUMBER}")
+
+    # add definition for this release type
+    add_definitions(-DPR_BUILD)
+  else ()
+    set(DEV_BUILD 1)
+    set(BUILD_VERSION "dev")
+  endif ()
+
+endmacro(SET_PACKAGING_PARAMETERS)

launchers/win32/resource.h

@@ -27,6 +27,7 @@
 #define IDC_TROUBLE                     1023
 #define IDC_VOXEL                       1024
 #define IDC_PROGRESS                    1025
+#define IDC_VERSION                     1026
 #define IDC_TROUBLE_LINK                1027
 
 // Next default values for new objects

libraries/networking/src/AddressManager.cpp

@@ -30,7 +30,7 @@
 #include "UserActivityLogger.h"
 #include "udt/PacketHeaders.h"
 
-const QString DEFAULT_HIFI_ADDRESS = "hifi://welcome";
+const QString DEFAULT_HIFI_ADDRESS = "file:///~/serverless/tutorial.json";
 const QString DEFAULT_HOME_ADDRESS = "file:///~/serverless/tutorial.json";
 const QString REDIRECT_HIFI_ADDRESS = "file:///~/serverless/redirect.json";
 const QString ADDRESS_MANAGER_SETTINGS_GROUP = "AddressManager";

libraries/script-engine/src/ScriptAudioInjector.cpp

@@ -33,5 +33,9 @@ ScriptAudioInjector::ScriptAudioInjector(const AudioInjectorPointer& injector) :
 }
 
 ScriptAudioInjector::~ScriptAudioInjector() {
-    DependencyManager::get<AudioInjectorManager>()->stop(_injector);
+    const auto audioInjectorManager = DependencyManager::get<AudioInjectorManager>();
-}
+    // AudioInjectorManager may have been destroyed on application shutdown.
+    if (audioInjectorManager) {
+        audioInjectorManager->stop(_injector);
+    }
+}

tools/ci-scripts/postbuild.py

@@ -148,9 +148,30 @@ def signBuild(executablePath):
         ])
 
 
+def zipDarwinLauncher():
+    launcherSourcePath = os.path.join(SOURCE_PATH, 'launchers', sys.platform)
+    launcherBuildPath = os.path.join(BUILD_PATH, 'launcher')
+
+    archiveName = computeArchiveName('HQ Launcher')
+
+    cpackCommand = [
+        'cpack',
+        '-G', 'ZIP',
+        '-D', "CPACK_PACKAGE_FILE_NAME={}".format(archiveName),
+        '-D', "CPACK_INCLUDE_TOPLEVEL_DIRECTORY=OFF"
+    ]
+    print("Create ZIP version of installer archive")
+    print(cpackCommand)
+    hifi_utils.executeSubprocess(cpackCommand, folder=launcherBuildPath)
+    launcherZipDestFile = os.path.join(BUILD_PATH, "{}.zip".format(archiveName))
+    launcherZipSourceFile = os.path.join(launcherBuildPath, "{}.zip".format(archiveName))
+    print("Moving {} to {}".format(launcherZipSourceFile, launcherZipDestFile))
+    shutil.move(launcherZipSourceFile, launcherZipDestFile)
+
+
 def buildLightLauncher():
     launcherSourcePath = os.path.join(SOURCE_PATH, 'launchers', sys.platform)
-    launcherBuildPath = os.path.join(BUILD_PATH, 'launcher') 
+    launcherBuildPath = os.path.join(BUILD_PATH, 'launcher')
     if not os.path.exists(launcherBuildPath):
         os.makedirs(launcherBuildPath)
     # configure launcher build
@@ -169,12 +190,13 @@ def buildLightLauncher():
     if sys.platform == 'win32':
         buildTarget = 'ALL_BUILD'
     hifi_utils.executeSubprocess([
-            'cmake', 
+            'cmake',
             '--build', launcherBuildPath,
-            '--config', 'Release', 
+            '--config', 'Release',
             '--target', buildTarget
         ], folder=launcherBuildPath)
     if sys.platform == 'darwin':
+        zipDarwinLauncher()
         launcherDestFile = os.path.join(BUILD_PATH, "{}.dmg".format(computeArchiveName('Launcher')))
         launcherSourceFile = os.path.join(launcherBuildPath, "HQ Launcher.dmg")
     elif sys.platform == 'win32':