{        QWriteLocker locker { &_entityScriptsLock };        _entityScripts[entityID] = details;    }    emit entityScriptDetailsUpdated();} void ScriptEngine::updateEntityScriptStatus(const EntityItemID& entityID, const EntityScriptStatus &status, const QString& errorInfo) {    {        QWriteLocker locker { &_entityScriptsLock };        EntityScriptDetails& details = _entityScripts[entityID];        details.status = status;        details.errorInfo = errorInfo;    }    emit entityScriptDetailsUpdated();} QVariant ScriptEngine::cloneEntityScriptDetails(const EntityItemID& entityID) {    static const QVariant NULL_VARIANT { qVariantFromValue((QObject*)nullptr) };    QVariantMap map;    if (entityID.isNull()) {        // TODO: find better way to report JS Error across thread/process boundaries        map["isError"] = true;        map["errorInfo"] = "Error: getEntityScriptDetails -- invalid entityID";    } else {#ifdef DEBUG_ENTITY_STATES        qDebug() << "cloneEntityScriptDetails" << entityID << QThread::currentThread();#endif        EntityScriptDetails scriptDetails;        if (getEntityScriptDetails(entityID, scriptDetails)) {#ifdef DEBUG_ENTITY_STATES            qDebug() << "gotEntityScriptDetails" << scriptDetails.status << QThread::currentThread();#endif            map["isRunning"] = isEntityScriptRunning(entityID);            map["status"] = EntityScriptStatus_::valueToKey(scriptDetails.status).toLower();            map["errorInfo"] = scriptDetails.errorInfo;            map["entityID"] = entityID.toString();#ifdef DEBUG_ENTITY_STATES            {                auto debug = QVariantMap();                debug["script"] = scriptDetails.scriptText;                debug["scriptObject"] = scriptDetails.scriptObject.toVariant();                debug["lastModified"] = (qlonglong)scriptDetails.lastModified;                debug["sandboxURL"] = scriptDetails.definingSandboxURL;                map["debug"] = debug;            }#endif        } else {#ifdef DEBUG_ENTITY_STATES            qDebug() << "!gotEntityScriptDetails" <<  QThread::currentThread();#endif            map["isError"] = true;            map["errorInfo"] = "Entity script details unavailable";            map["entityID"] = entityID.toString();        }    }    return map;} QFuture<QVariant> ScriptEngine::getLocalEntityScriptDetails(const EntityItemID& entityID) {    return QtConcurrent::run(this, &ScriptEngine::cloneEntityScriptDetails, entityID);} bool ScriptEngine::getEntityScriptDetails(const EntityItemID& entityID, EntityScriptDetails &details) const {    QReadLocker locker { &_entityScriptsLock };    auto it = _entityScripts.constFind(entityID);    if (it == _entityScripts.constEnd()) {        return false;    }    details = it.value();    return true;} bool ScriptEngine::hasEntityScriptDetails(const EntityItemID& entityID) const {    QReadLocker locker { &_entityScriptsLock };    return _entityScripts.contains(entityID);} void ScriptEngine::loadEntityScript(const EntityItemID& entityID, const QString& entityScript, bool forceRedownload) {    if (QThread::currentThread() != thread()) {        QMetaObject::invokeMethod(this, "loadEntityScript",            Q_ARG(const EntityItemID&, entityID),            Q_ARG(const QString&, entityScript),            Q_ARG(bool, forceRedownload)        );        return;    }    PROFILE_RANGE(script, __FUNCTION__);     QSharedPointer<ScriptEngines> scriptEngines(_scriptEngines);    if (isStopping() || !scriptEngines || scriptEngines->isStopped()) {        qCDebug(scriptengine) << "loadEntityScript.start " << entityID.toString()                                     << " but isStopping==" << isStopping()                                     << " || engines->isStopped==" << scriptEngines->isStopped();        return;    }     if (!hasEntityScriptDetails(entityID)) {        // make sure EntityScriptDetails has an entry for this UUID right away        // (which allows bailing from the loading/provisioning process early if the Entity gets deleted mid-flight)        updateEntityScriptStatus(entityID, EntityScriptStatus::PENDING, "...pending...");    } #ifdef DEBUG_ENTITY_STATES    {        EntityScriptDetails details;        bool hasEntityScript = getEntityScriptDetails(entityID, details);        qCDebug(scriptengine) << "loadEntityScript.LOADING: " << entityID.toString()            << "(previous: " << (hasEntityScript ? details.status : EntityScriptStatus::PENDING) << ")";    }#endif     EntityScriptDetails newDetails;    newDetails.scriptText = entityScript;    newDetails.status = EntityScriptStatus::LOADING;    newDetails.definingSandboxURL = currentSandboxURL;    setEntityScriptDetails(entityID, newDetails);     auto scriptCache = DependencyManager::get<ScriptCache>();    // note: see EntityTreeRenderer.cpp for shared pointer lifecycle management    QWeakPointer<BaseScriptEngine> weakRef(sharedFromThis());    scriptCache->getScriptContents(entityScript,        [this, weakRef, entityScript, entityID](const QString& url, const QString& contents, bool isURL, bool success, const QString& status) {            QSharedPointer<BaseScriptEngine> strongRef(weakRef);            if (!strongRef) {                qCWarning(scriptengine) << "loadEntityScript.contentAvailable -- ScriptEngine was deleted during getScriptContents!!";                return;            }            if (isStopping()) {#ifdef DEBUG_ENTITY_STATES                qCDebug(scriptengine) << "loadEntityScript.contentAvailable -- stopping";#endif                return;            }            executeOnScriptThread([=]{#ifdef DEBUG_ENTITY_STATES                qCDebug(scriptengine) << "loadEntityScript.contentAvailable" << status << entityID.toString();#endif                if (!isStopping() && hasEntityScriptDetails(entityID)) {                    _contentAvailableQueue[entityID] = { entityID, url, contents, isURL, success, status };                } else {#ifdef DEBUG_ENTITY_STATES                    qCDebug(scriptengine) << "loadEntityScript.contentAvailable -- aborting";#endif                }            });    }, forceRedownload);} /**jsdoc * Triggered when the script starts for a user. * <p>Note: Can only be connected to via <code>this.preload = function (...) { ... }</code> in the entity script.</p> * <table><tr><th>Available in:</th><td>Client Entity Scripts</td><td>Server Entity Scripts</td></tr></table> * @function Entities.preload * @param {Uuid} entityID - The ID of the entity that the script is running in. * @returns {Signal} * @example <caption>Get the ID of the entity that a client entity script is running in.</caption> * var entityScript = (function () { *     this.entityID = Uuid.NULL; * *     this.preload = function (entityID) { *         this.entityID = entityID; *         print("Entity ID: " + this.entityID); *     }; * ); * * var entityID = Entities.addEntity({ *     type: "Box", *     position: Vec3.sum(MyAvatar.position, Vec3.multiplyQbyV(MyAvatar.orientation, { x: 0, y: 0, z: -5 })), *     dimensions: { x: 0.5, y: 0.5, z: 0.5 }, *     color: { red: 255, green: 0, blue: 0 }, *     script: "(" + entityScript + ")",  // Could host the script on a Web server instead. *     lifetime: 300  // Delete after 5 minutes. * }); */// since all of these operations can be asynch we will always do the actual work in the response handler// for the downloadvoid ScriptEngine::entityScriptContentAvailable(const EntityItemID& entityID, const QString& scriptOrURL, const QString& contents, bool isURL, bool success , const QString& status) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::entityScriptContentAvailable() called on wrong thread ["            << QThread::currentThread() << "], invoking on correct thread [" << thread()            << "]  " "entityID:" << entityID << "scriptOrURL:" << scriptOrURL << "contents:"            << contents << "isURL:" << isURL << "success:" << success;#endif         QMetaObject::invokeMethod(this, "entityScriptContentAvailable",                                  Q_ARG(const EntityItemID&, entityID),                                  Q_ARG(const QString&, scriptOrURL),                                  Q_ARG(const QString&, contents),                                  Q_ARG(bool, isURL),                                  Q_ARG(bool, success),                                  Q_ARG(const QString&, status));        return;    } #ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::entityScriptContentAvailable() thread [" << QThread::currentThread() << "] expected thread [" << thread() << "]";#endif     auto scriptCache = DependencyManager::get<ScriptCache>();    bool isFileUrl = isURL && scriptOrURL.startsWith("file://");    auto fileName = isURL ? scriptOrURL : "about:EmbeddedEntityScript";     QString entityScript;    {        QWriteLocker locker { &_entityScriptsLock };        entityScript = _entityScripts[entityID].scriptText;    }     EntityScriptDetails newDetails;    newDetails.scriptText = scriptOrURL;     // If an error happens below, we want to update newDetails with the new status info    // and also abort any pending Entity loads that are waiting on the exact same script URL.    auto setError = [&](const QString &errorInfo, const EntityScriptStatus& status) {        newDetails.errorInfo = errorInfo;        newDetails.status = status;        setEntityScriptDetails(entityID, newDetails);    };     // NETWORK / FILESYSTEM ERRORS    if (!success) {        setError("Failed to load script (" + status + ")", EntityScriptStatus::ERROR_LOADING_SCRIPT);        return;    }     // SYNTAX ERRORS    auto syntaxError = lintScript(contents, fileName);    if (syntaxError.isError()) {        auto message = syntaxError.property("formatted").toString();        if (message.isEmpty()) {            message = syntaxError.toString();        }        setError(QString("Bad syntax (%1)").arg(message), EntityScriptStatus::ERROR_RUNNING_SCRIPT);        syntaxError.setProperty("detail", entityID.toString());        emit unhandledException(syntaxError);        return;    }    QScriptProgram program { contents, fileName };    if (program.isNull()) {        setError("Bad program (isNull)", EntityScriptStatus::ERROR_RUNNING_SCRIPT);        emit unhandledException(makeError("program.isNull"));        return; // done processing script    }     if (isURL) {        setParentURL(scriptOrURL);    }     // SANITY/PERFORMANCE CHECK USING SANDBOX    const int SANDBOX_TIMEOUT = 0.25 * MSECS_PER_SECOND;    BaseScriptEngine sandbox;    sandbox.setProcessEventsInterval(SANDBOX_TIMEOUT);    QScriptValue testConstructor, exception;    {        QTimer timeout;        timeout.setSingleShot(true);        timeout.start(SANDBOX_TIMEOUT);        connect(&timeout, &QTimer::timeout, [=, &sandbox]{                qCDebug(scriptengine) << "ScriptEngine::entityScriptContentAvailable timeout";                 // Guard against infinite loops and non-performant code                sandbox.raiseException(                    sandbox.makeError(QString("Timed out (entity constructors are limited to %1ms)").arg(SANDBOX_TIMEOUT))                );        });         testConstructor = sandbox.evaluate(program);         if (sandbox.hasUncaughtException()) {            exception = sandbox.cloneUncaughtException(QString("(preflight %1)").arg(entityID.toString()));            sandbox.clearExceptions();        } else if (testConstructor.isError()) {            exception = testConstructor;        }    }     if (exception.isError()) {        // create a local copy using makeError to decouple from the sandbox engine        exception = makeError(exception);        setError(formatException(exception, _enableExtendedJSExceptions.get()), EntityScriptStatus::ERROR_RUNNING_SCRIPT);        emit unhandledException(exception);        return;    }     // CONSTRUCTOR VIABILITY    if (!testConstructor.isFunction()) {        QString testConstructorType = QString(testConstructor.toVariant().typeName());        if (testConstructorType == "") {            testConstructorType = "empty";        }        QString testConstructorValue = testConstructor.toString();        if (testConstructorValue.size() > MAX_DEBUG_VALUE_LENGTH) {            testConstructorValue = testConstructorValue.mid(0, MAX_DEBUG_VALUE_LENGTH) + "...";        }        auto message = QString("failed to load entity script -- expected a function, got %1, %2")            .arg(testConstructorType).arg(testConstructorValue);         auto err = makeError(message);        err.setProperty("fileName", scriptOrURL);        err.setProperty("detail", "(constructor " + entityID.toString() + ")");         setError("Could not find constructor (" + testConstructorType + ")", EntityScriptStatus::ERROR_RUNNING_SCRIPT);        emit unhandledException(err);        return; // done processing script    }     // (this feeds into refreshFileScript)    int64_t lastModified = 0;    if (isFileUrl) {        QString file = QUrl(scriptOrURL).toLocalFile();        lastModified = (quint64)QFileInfo(file).lastModified().toMSecsSinceEpoch();    }     // THE ACTUAL EVALUATION AND CONSTRUCTION    QScriptValue entityScriptConstructor, entityScriptObject;    QUrl sandboxURL = currentSandboxURL.isEmpty() ? scriptOrURL : currentSandboxURL;    auto initialization = [&]{        entityScriptConstructor = evaluate(contents, fileName);        entityScriptObject = entityScriptConstructor.construct();         if (hasUncaughtException()) {            entityScriptObject = cloneUncaughtException("(construct " + entityID.toString() + ")");            clearExceptions();        }    };     doWithEnvironment(entityID, sandboxURL, initialization);     if (entityScriptObject.isError()) {        auto exception = entityScriptObject;        setError(formatException(exception, _enableExtendedJSExceptions.get()), EntityScriptStatus::ERROR_RUNNING_SCRIPT);        emit unhandledException(exception);        return;    }     // ... AND WE HAVE LIFTOFF    newDetails.status = EntityScriptStatus::RUNNING;    newDetails.scriptObject = entityScriptObject;    newDetails.lastModified = lastModified;    newDetails.definingSandboxURL = sandboxURL;    setEntityScriptDetails(entityID, newDetails);     if (isURL) {        setParentURL("");    }     // if we got this far, then call the preload method    callEntityScriptMethod(entityID, "preload");     emit entityScriptPreloadFinished(entityID);} /**jsdoc * Triggered when the script terminates for a user. * <p>Note: Can only be connected to via <code>this.unoad = function () { ... }</code> in the entity script.</p> * <table><tr><th>Available in:</th><td>Client Entity Scripts</td><td>Server Entity Scripts</td></tr></table> * @function Entities.unload * @returns {Signal} */void ScriptEngine::unloadEntityScript(const EntityItemID& entityID, bool shouldRemoveFromMap) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::unloadEntityScript() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]  "            "entityID:" << entityID;#endif         QMetaObject::invokeMethod(this, "unloadEntityScript",                                  Q_ARG(const EntityItemID&, entityID),                                  Q_ARG(bool, shouldRemoveFromMap));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::unloadEntityScript() called on correct thread [" << thread() << "]  "        "entityID:" << entityID;#endif     EntityScriptDetails oldDetails;    if (getEntityScriptDetails(entityID, oldDetails)) {        auto scriptText = oldDetails.scriptText;         if (isEntityScriptRunning(entityID)) {            callEntityScriptMethod(entityID, "unload");        }#ifdef DEBUG_ENTITY_STATES        else {            qCDebug(scriptengine) << "unload called while !running" << entityID << oldDetails.status;        }#endif        if (shouldRemoveFromMap) {            // this was a deleted entity, we've been asked to remove it from the map            {                QWriteLocker locker { &_entityScriptsLock };                _entityScripts.remove(entityID);            }            emit entityScriptDetailsUpdated();        } else if (oldDetails.status != EntityScriptStatus::UNLOADED) {            EntityScriptDetails newDetails;            newDetails.status = EntityScriptStatus::UNLOADED;            newDetails.lastModified = QDateTime::currentMSecsSinceEpoch();            // keep scriptText populated for the current need to "debouce" duplicate calls to unloadEntityScript            newDetails.scriptText = scriptText;            setEntityScriptDetails(entityID, newDetails);        }         stopAllTimersForEntityScript(entityID);    }} QList<EntityItemID> ScriptEngine::getListOfEntityScriptIDs() {    QReadLocker locker{ &_entityScriptsLock };    return _entityScripts.keys();} void ScriptEngine::unloadAllEntityScripts() {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::unloadAllEntityScripts() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]";#endif         QMetaObject::invokeMethod(this, "unloadAllEntityScripts");        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::unloadAllEntityScripts() called on correct thread [" << thread() << "]";#endif     QList<EntityItemID> keys;    {        QReadLocker locker{ &_entityScriptsLock };        keys = _entityScripts.keys();    }    foreach(const EntityItemID& entityID, keys) {        unloadEntityScript(entityID);    }    {        QWriteLocker locker{ &_entityScriptsLock };        _entityScripts.clear();    }    emit entityScriptDetailsUpdated(); #ifdef DEBUG_ENGINE_STATE    _debugDump(        "---- CURRENT STATE OF ENGINE: --------------------------",        globalObject(),        "--------------------------------------------------------"    );#endif // DEBUG_ENGINE_STATE} void ScriptEngine::refreshFileScript(const EntityItemID& entityID) {    if (!HIFI_AUTOREFRESH_FILE_SCRIPTS || !hasEntityScriptDetails(entityID)) {        return;    }     static bool recurseGuard = false;    if (recurseGuard) {        return;    }    recurseGuard = true;     EntityScriptDetails details;    {        QWriteLocker locker { &_entityScriptsLock };        details = _entityScripts[entityID];    }    // Check to see if a file based script needs to be reloaded (easier debugging)    if (details.lastModified > 0) {        QString filePath = QUrl(details.scriptText).toLocalFile();        auto lastModified = QFileInfo(filePath).lastModified().toMSecsSinceEpoch();        if (lastModified > details.lastModified) {            scriptInfoMessage("Reloading modified script " + details.scriptText);            loadEntityScript(entityID, details.scriptText, true);        }    }    recurseGuard = false;} // Execute operation in the appropriate context for (the possibly empty) entityID.// Even if entityID is supplied as currentEntityIdentifier, this still documents the source// of the code being executed (e.g., if we ever sandbox different entity scripts, or provide different// global values for different entity scripts).void ScriptEngine::doWithEnvironment(const EntityItemID& entityID, const QUrl& sandboxURL, std::function<void()> operation) {    EntityItemID oldIdentifier = currentEntityIdentifier;    QUrl oldSandboxURL = currentSandboxURL;    currentEntityIdentifier = entityID;    currentSandboxURL = sandboxURL; #if DEBUG_CURRENT_ENTITY    QScriptValue oldData = this->globalObject().property("debugEntityID");    this->globalObject().setProperty("debugEntityID", entityID.toScriptValue(this)); // Make the entityID available to javascript as a global.    operation();    this->globalObject().setProperty("debugEntityID", oldData);#else    operation();#endif    maybeEmitUncaughtException(!entityID.isNull() ? entityID.toString() : __FUNCTION__);    currentEntityIdentifier = oldIdentifier;    currentSandboxURL = oldSandboxURL;

Lines 2001–2500 of 2652. Previous lines Load more