summaryrefslogtreecommitdiffstats
path: root/devtools/shared/apps/app-actor-front.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /devtools/shared/apps/app-actor-front.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'devtools/shared/apps/app-actor-front.js')
-rw-r--r--devtools/shared/apps/app-actor-front.js840
1 files changed, 840 insertions, 0 deletions
diff --git a/devtools/shared/apps/app-actor-front.js b/devtools/shared/apps/app-actor-front.js
new file mode 100644
index 000000000..6cd793679
--- /dev/null
+++ b/devtools/shared/apps/app-actor-front.js
@@ -0,0 +1,840 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const {Ci, Cc, Cr} = require("chrome");
+const {OS} = require("resource://gre/modules/osfile.jsm");
+const {FileUtils} = require("resource://gre/modules/FileUtils.jsm");
+const {NetUtil} = require("resource://gre/modules/NetUtil.jsm");
+const promise = require("promise");
+const defer = require("devtools/shared/defer");
+const DevToolsUtils = require("devtools/shared/DevToolsUtils");
+const EventEmitter = require("devtools/shared/event-emitter");
+
+// Bug 1188401: When loaded from xpcshell tests, we do not have browser/ files
+// and can't load target.js. Should be fixed by bug 912121.
+loader.lazyRequireGetter(this, "TargetFactory", "devtools/client/framework/target", true);
+
+// XXX: bug 912476 make this module a real protocol.js front
+// by converting webapps actor to protocol.js
+
+const PR_USEC_PER_MSEC = 1000;
+const PR_RDWR = 0x04;
+const PR_CREATE_FILE = 0x08;
+const PR_TRUNCATE = 0x20;
+
+const CHUNK_SIZE = 10000;
+
+const appTargets = new Map();
+
+function addDirToZip(writer, dir, basePath) {
+ let files = dir.directoryEntries;
+
+ while (files.hasMoreElements()) {
+ let file = files.getNext().QueryInterface(Ci.nsIFile);
+
+ if (file.isHidden() ||
+ file.isSpecial() ||
+ file.equals(writer.file))
+ {
+ continue;
+ }
+
+ if (file.isDirectory()) {
+ writer.addEntryDirectory(basePath + file.leafName + "/",
+ file.lastModifiedTime * PR_USEC_PER_MSEC,
+ true);
+ addDirToZip(writer, file, basePath + file.leafName + "/");
+ } else {
+ writer.addEntryFile(basePath + file.leafName,
+ Ci.nsIZipWriter.COMPRESSION_DEFAULT,
+ file,
+ true);
+ }
+ }
+}
+
+/**
+ * Convert an XPConnect result code to its name and message.
+ * We have to extract them from an exception per bug 637307 comment 5.
+ */
+function getResultText(code) {
+ let regexp =
+ /^\[Exception... "(.*)" nsresult: "0x[0-9a-fA-F]* \((.*)\)" location: ".*" data: .*\]$/;
+ let ex = Cc["@mozilla.org/js/xpc/Exception;1"].
+ createInstance(Ci.nsIXPCException);
+ ex.initialize(null, code, null, null, null, null);
+ let [, message, name] = regexp.exec(ex.toString());
+ return { name: name, message: message };
+}
+
+function zipDirectory(zipFile, dirToArchive) {
+ let deferred = defer();
+ let writer = Cc["@mozilla.org/zipwriter;1"].createInstance(Ci.nsIZipWriter);
+ writer.open(zipFile, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE);
+
+ this.addDirToZip(writer, dirToArchive, "");
+
+ writer.processQueue({
+ onStartRequest: function onStartRequest(request, context) {},
+ onStopRequest: (request, context, status) => {
+ if (status == Cr.NS_OK) {
+ writer.close();
+ deferred.resolve(zipFile);
+ }
+ else {
+ let { name, message } = getResultText(status);
+ deferred.reject(name + ": " + message);
+ }
+ }
+ }, null);
+
+ return deferred.promise;
+}
+
+function uploadPackage(client, webappsActor, packageFile, progressCallback) {
+ if (client.traits.bulk) {
+ return uploadPackageBulk(client, webappsActor, packageFile, progressCallback);
+ } else {
+ return uploadPackageJSON(client, webappsActor, packageFile, progressCallback);
+ }
+}
+
+function uploadPackageJSON(client, webappsActor, packageFile, progressCallback) {
+ let deferred = defer();
+
+ let request = {
+ to: webappsActor,
+ type: "uploadPackage"
+ };
+ client.request(request, (res) => {
+ openFile(res.actor);
+ });
+
+ let fileSize;
+ let bytesRead = 0;
+
+ function emitProgress() {
+ progressCallback({
+ bytesSent: bytesRead,
+ totalBytes: fileSize
+ });
+ }
+
+ function openFile(actor) {
+ let openedFile;
+ OS.File.open(packageFile.path)
+ .then(file => {
+ openedFile = file;
+ return openedFile.stat();
+ })
+ .then(fileInfo => {
+ fileSize = fileInfo.size;
+ emitProgress();
+ uploadChunk(actor, openedFile);
+ });
+ }
+ function uploadChunk(actor, file) {
+ file.read(CHUNK_SIZE)
+ .then(function (bytes) {
+ bytesRead += bytes.length;
+ emitProgress();
+ // To work around the fact that JSON.stringify translates the typed
+ // array to object, we are encoding the typed array here into a string
+ let chunk = String.fromCharCode.apply(null, bytes);
+
+ let request = {
+ to: actor,
+ type: "chunk",
+ chunk: chunk
+ };
+ client.request(request, (res) => {
+ if (bytes.length == CHUNK_SIZE) {
+ uploadChunk(actor, file);
+ } else {
+ file.close().then(function () {
+ endsUpload(actor);
+ });
+ }
+ });
+ });
+ }
+ function endsUpload(actor) {
+ let request = {
+ to: actor,
+ type: "done"
+ };
+ client.request(request, (res) => {
+ deferred.resolve(actor);
+ });
+ }
+ return deferred.promise;
+}
+
+function uploadPackageBulk(client, webappsActor, packageFile, progressCallback) {
+ let deferred = defer();
+
+ let request = {
+ to: webappsActor,
+ type: "uploadPackage",
+ bulk: true
+ };
+ client.request(request, (res) => {
+ startBulkUpload(res.actor);
+ });
+
+ function startBulkUpload(actor) {
+ console.log("Starting bulk upload");
+ let fileSize = packageFile.fileSize;
+ console.log("File size: " + fileSize);
+
+ let request = client.startBulkRequest({
+ actor: actor,
+ type: "stream",
+ length: fileSize
+ });
+
+ request.on("bulk-send-ready", ({copyFrom}) => {
+ NetUtil.asyncFetch({
+ uri: NetUtil.newURI(packageFile),
+ loadUsingSystemPrincipal: true
+ }, function (inputStream) {
+ let copying = copyFrom(inputStream);
+ copying.on("progress", (e, progress) => {
+ progressCallback(progress);
+ });
+ copying.then(() => {
+ console.log("Bulk upload done");
+ inputStream.close();
+ deferred.resolve(actor);
+ });
+ });
+ });
+ }
+
+ return deferred.promise;
+}
+
+function removeServerTemporaryFile(client, fileActor) {
+ let request = {
+ to: fileActor,
+ type: "remove"
+ };
+ client.request(request);
+}
+
+/**
+ * progressCallback argument:
+ * Function called as packaged app installation proceeds.
+ * The progress object passed to this function contains:
+ * * bytesSent: The number of bytes sent so far
+ * * totalBytes: The total number of bytes to send
+ */
+function installPackaged(client, webappsActor, packagePath, appId, progressCallback) {
+ let deferred = defer();
+ let file = FileUtils.File(packagePath);
+ let packagePromise;
+ if (file.isDirectory()) {
+ let tmpZipFile = FileUtils.getDir("TmpD", [], true);
+ tmpZipFile.append("application.zip");
+ tmpZipFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, parseInt("666", 8));
+ packagePromise = zipDirectory(tmpZipFile, file);
+ } else {
+ packagePromise = promise.resolve(file);
+ }
+ packagePromise.then((zipFile) => {
+ uploadPackage(client, webappsActor, zipFile, progressCallback)
+ .then((fileActor) => {
+ let request = {
+ to: webappsActor,
+ type: "install",
+ appId: appId,
+ upload: fileActor
+ };
+ client.request(request, (res) => {
+ // If the install method immediatly fails,
+ // reject immediatly the installPackaged promise.
+ // Otherwise, wait for webappsEvent for completion
+ if (res.error) {
+ deferred.reject(res);
+ }
+ if ("error" in res)
+ deferred.reject({error: res.error, message: res.message});
+ else
+ deferred.resolve({appId: res.appId});
+ });
+ // Ensure deleting the temporary package file, but only if that a temporary
+ // package created when we pass a directory as `packagePath`
+ if (zipFile != file)
+ zipFile.remove(false);
+ // In case of success or error, ensure deleting the temporary package file
+ // also created on the device, but only once install request is done
+ deferred.promise.then(
+ () => removeServerTemporaryFile(client, fileActor),
+ () => removeServerTemporaryFile(client, fileActor));
+ });
+ });
+ return deferred.promise;
+}
+exports.installPackaged = installPackaged;
+
+function installHosted(client, webappsActor, appId, metadata, manifest) {
+ let deferred = defer();
+ let request = {
+ to: webappsActor,
+ type: "install",
+ appId: appId,
+ metadata: metadata,
+ manifest: manifest
+ };
+ client.request(request, (res) => {
+ if (res.error) {
+ deferred.reject(res);
+ }
+ if ("error" in res)
+ deferred.reject({error: res.error, message: res.message});
+ else
+ deferred.resolve({appId: res.appId});
+ });
+ return deferred.promise;
+}
+exports.installHosted = installHosted;
+
+function getTargetForApp(client, webappsActor, manifestURL) {
+ // Ensure always returning the exact same JS object for a target
+ // of the same app in order to show only one toolbox per app and
+ // avoid re-creating lot of objects twice.
+ let existingTarget = appTargets.get(manifestURL);
+ if (existingTarget)
+ return promise.resolve(existingTarget);
+
+ let deferred = defer();
+ let request = {
+ to: webappsActor,
+ type: "getAppActor",
+ manifestURL: manifestURL,
+ };
+ client.request(request, (res) => {
+ if (res.error) {
+ deferred.reject(res.error);
+ } else {
+ let options = {
+ form: res.actor,
+ client: client,
+ chrome: false
+ };
+
+ TargetFactory.forRemoteTab(options).then((target) => {
+ target.isApp = true;
+ appTargets.set(manifestURL, target);
+ target.on("close", () => {
+ appTargets.delete(manifestURL);
+ });
+ deferred.resolve(target);
+ }, (error) => {
+ deferred.reject(error);
+ });
+ }
+ });
+ return deferred.promise;
+}
+exports.getTargetForApp = getTargetForApp;
+
+function reloadApp(client, webappsActor, manifestURL) {
+ return getTargetForApp(client,
+ webappsActor,
+ manifestURL).
+ then((target) => {
+ // Request the ContentActor to reload the app
+ let request = {
+ to: target.form.actor,
+ type: "reload",
+ options: {
+ force: true
+ },
+ manifestURL: manifestURL
+ };
+ return client.request(request);
+ }, () => {
+ throw new Error("Not running");
+ });
+}
+exports.reloadApp = reloadApp;
+
+function launchApp(client, webappsActor, manifestURL) {
+ return client.request({
+ to: webappsActor,
+ type: "launch",
+ manifestURL: manifestURL
+ });
+}
+exports.launchApp = launchApp;
+
+function closeApp(client, webappsActor, manifestURL) {
+ return client.request({
+ to: webappsActor,
+ type: "close",
+ manifestURL: manifestURL
+ });
+}
+exports.closeApp = closeApp;
+
+function getTarget(client, form) {
+ let deferred = defer();
+ let options = {
+ form: form,
+ client: client,
+ chrome: false
+ };
+
+ TargetFactory.forRemoteTab(options).then((target) => {
+ target.isApp = true;
+ deferred.resolve(target);
+ }, (error) => {
+ deferred.reject(error);
+ });
+ return deferred.promise;
+}
+
+/**
+ * `App` instances are client helpers to manage a given app
+ * and its the tab actors
+ */
+function App(client, webappsActor, manifest) {
+ this.client = client;
+ this.webappsActor = webappsActor;
+ this.manifest = manifest;
+
+ // This attribute is managed by the AppActorFront
+ this.running = false;
+
+ this.iconURL = null;
+}
+
+App.prototype = {
+ getForm: function () {
+ if (this._form) {
+ return promise.resolve(this._form);
+ }
+ let request = {
+ to: this.webappsActor,
+ type: "getAppActor",
+ manifestURL: this.manifest.manifestURL
+ };
+ return this.client.request(request)
+ .then(res => {
+ return this._form = res.actor;
+ });
+ },
+
+ getTarget: function () {
+ if (this._target) {
+ return promise.resolve(this._target);
+ }
+ return this.getForm().
+ then((form) => getTarget(this.client, form)).
+ then((target) => {
+ target.on("close", () => {
+ delete this._form;
+ delete this._target;
+ });
+ return this._target = target;
+ });
+ },
+
+ launch: function () {
+ return launchApp(this.client, this.webappsActor,
+ this.manifest.manifestURL);
+ },
+
+ reload: function () {
+ return reloadApp(this.client, this.webappsActor,
+ this.manifest.manifestURL);
+ },
+
+ close: function () {
+ return closeApp(this.client, this.webappsActor,
+ this.manifest.manifestURL);
+ },
+
+ getIcon: function () {
+ if (this.iconURL) {
+ return promise.resolve(this.iconURL);
+ }
+
+ let deferred = defer();
+
+ let request = {
+ to: this.webappsActor,
+ type: "getIconAsDataURL",
+ manifestURL: this.manifest.manifestURL
+ };
+
+ this.client.request(request, res => {
+ if (res.error) {
+ deferred.reject(res.message || res.error);
+ } else if (res.url) {
+ this.iconURL = res.url;
+ deferred.resolve(res.url);
+ } else {
+ deferred.reject("Unable to fetch app icon");
+ }
+ });
+
+ return deferred.promise;
+ }
+};
+
+
+/**
+ * `AppActorFront` is a client for the webapps actor.
+ */
+function AppActorFront(client, form) {
+ this.client = client;
+ this.actor = form.webappsActor;
+
+ this._clientListener = this._clientListener.bind(this);
+ this._onInstallProgress = this._onInstallProgress.bind(this);
+
+ this._listeners = [];
+ EventEmitter.decorate(this);
+}
+
+AppActorFront.prototype = {
+ /**
+ * List `App` instances for all currently running apps.
+ */
+ get runningApps() {
+ if (!this._apps) {
+ throw new Error("Can't get running apps before calling watchApps.");
+ }
+ let r = new Map();
+ for (let [manifestURL, app] of this._apps) {
+ if (app.running) {
+ r.set(manifestURL, app);
+ }
+ }
+ return r;
+ },
+
+ /**
+ * List `App` instances for all installed apps.
+ */
+ get apps() {
+ if (!this._apps) {
+ throw new Error("Can't get apps before calling watchApps.");
+ }
+ return this._apps;
+ },
+
+ /**
+ * Returns a `App` object instance for the given manifest URL
+ * (and cache it per AppActorFront object)
+ */
+ _getApp: function (manifestURL) {
+ let app = this._apps ? this._apps.get(manifestURL) : null;
+ if (app) {
+ return promise.resolve(app);
+ } else {
+ let request = {
+ to: this.actor,
+ type: "getApp",
+ manifestURL: manifestURL
+ };
+ return this.client.request(request)
+ .then(res => {
+ let app = new App(this.client, this.actor, res.app);
+ if (this._apps) {
+ this._apps.set(manifestURL, app);
+ }
+ return app;
+ }, e => {
+ console.error("Unable to retrieve app", manifestURL, e);
+ });
+ }
+ },
+
+ /**
+ * Starts watching for app opening/closing installing/uninstalling.
+ * Needs to be called before using `apps` or `runningApps` attributes.
+ */
+ watchApps: function (listener) {
+ // Fixes race between two references to the same front
+ // calling watchApps at the same time
+ if (this._loadingPromise) {
+ return this._loadingPromise;
+ }
+
+ // Only call watchApps for the first listener being register,
+ // for all next ones, just send fake appOpen events for already
+ // opened apps
+ if (this._apps) {
+ this.runningApps.forEach((app, manifestURL) => {
+ listener("appOpen", app);
+ });
+ return promise.resolve();
+ }
+
+ // First retrieve all installed apps and create
+ // related `App` object for each
+ let request = {
+ to: this.actor,
+ type: "getAll"
+ };
+ return this._loadingPromise = this.client.request(request)
+ .then(res => {
+ delete this._loadingPromise;
+ this._apps = new Map();
+ for (let a of res.apps) {
+ let app = new App(this.client, this.actor, a);
+ this._apps.set(a.manifestURL, app);
+ }
+ })
+ .then(() => {
+ // Then retrieve all running apps in order to flag them as running
+ let request = {
+ to: this.actor,
+ type: "listRunningApps"
+ };
+ return this.client.request(request)
+ .then(res => res.apps);
+ })
+ .then(apps => {
+ let promises = apps.map(manifestURL => {
+ // _getApp creates `App` instance and register it to AppActorFront
+ return this._getApp(manifestURL)
+ .then(app => {
+ app.running = true;
+ // Fake appOpen event for all already opened
+ this._notifyListeners("appOpen", app);
+ });
+ });
+ return promise.all(promises);
+ })
+ .then(() => {
+ // Finally ask to receive all app events
+ return this._listenAppEvents(listener);
+ });
+ },
+
+ fetchIcons: function () {
+ // On demand, retrieve apps icons in order to be able
+ // to synchronously retrieve it on `App` objects
+ let promises = [];
+ for (let [manifestURL, app] of this._apps) {
+ promises.push(app.getIcon());
+ }
+
+ return DevToolsUtils.settleAll(promises)
+ .then(null, () => {});
+ },
+
+ _listenAppEvents: function (listener) {
+ this._listeners.push(listener);
+
+ if (this._listeners.length > 1) {
+ return promise.resolve();
+ }
+
+ let client = this.client;
+ let f = this._clientListener;
+ client.addListener("appOpen", f);
+ client.addListener("appClose", f);
+ client.addListener("appInstall", f);
+ client.addListener("appUninstall", f);
+
+ let request = {
+ to: this.actor,
+ type: "watchApps"
+ };
+ return this.client.request(request);
+ },
+
+ _unlistenAppEvents: function (listener) {
+ let idx = this._listeners.indexOf(listener);
+ if (idx != -1) {
+ this._listeners.splice(idx, 1);
+ }
+
+ // Until we released all listener, we don't ask to stop sending events
+ if (this._listeners.length != 0) {
+ return promise.resolve();
+ }
+
+ let client = this.client;
+ let f = this._clientListener;
+ client.removeListener("appOpen", f);
+ client.removeListener("appClose", f);
+ client.removeListener("appInstall", f);
+ client.removeListener("appUninstall", f);
+
+ // Remove `_apps` in order to allow calling watchApps again
+ // and repopulate the apps Map.
+ delete this._apps;
+
+ let request = {
+ to: this.actor,
+ type: "unwatchApps"
+ };
+ return this.client.request(request);
+ },
+
+ _clientListener: function (type, message) {
+ let { manifestURL } = message;
+
+ // Reset the app object to get a fresh copy when we (re)install the app.
+ if (type == "appInstall" && this._apps && this._apps.has(manifestURL)) {
+ this._apps.delete(manifestURL);
+ }
+
+ this._getApp(manifestURL).then((app) => {
+ switch (type) {
+ case "appOpen":
+ app.running = true;
+ this._notifyListeners("appOpen", app);
+ break;
+ case "appClose":
+ app.running = false;
+ this._notifyListeners("appClose", app);
+ break;
+ case "appInstall":
+ // The call to _getApp is going to create App object
+
+ // This app may have been running while being installed, so check the list
+ // of running apps again to get the right answer.
+ let request = {
+ to: this.actor,
+ type: "listRunningApps"
+ };
+ this.client.request(request)
+ .then(res => {
+ if (res.apps.indexOf(manifestURL) !== -1) {
+ app.running = true;
+ this._notifyListeners("appInstall", app);
+ this._notifyListeners("appOpen", app);
+ } else {
+ this._notifyListeners("appInstall", app);
+ }
+ });
+ break;
+ case "appUninstall":
+ // Fake a appClose event if we didn't got one before uninstall
+ if (app.running) {
+ app.running = false;
+ this._notifyListeners("appClose", app);
+ }
+ this._apps.delete(manifestURL);
+ this._notifyListeners("appUninstall", app);
+ break;
+ default:
+ return;
+ }
+ });
+ },
+
+ _notifyListeners: function (type, app) {
+ this._listeners.forEach(f => {
+ f(type, app);
+ });
+ },
+
+ unwatchApps: function (listener) {
+ return this._unlistenAppEvents(listener);
+ },
+
+ /*
+ * Install a packaged app.
+ *
+ * Events are going to be emitted on the front
+ * as install progresses. Events will have the following fields:
+ * * bytesSent: The number of bytes sent so far
+ * * totalBytes: The total number of bytes to send
+ */
+ installPackaged: function (packagePath, appId) {
+ let request = () => {
+ return installPackaged(this.client, this.actor, packagePath, appId,
+ this._onInstallProgress)
+ .then(response => ({
+ appId: response.appId,
+ manifestURL: "app://" + response.appId + "/manifest.webapp"
+ }));
+ };
+ return this._install(request);
+ },
+
+ _onInstallProgress: function (progress) {
+ this.emit("install-progress", progress);
+ },
+
+ _install: function (request) {
+ let deferred = defer();
+ let finalAppId = null, manifestURL = null;
+ let installs = {};
+
+ // We need to resolve only once the request is done *AND*
+ // once we receive the related appInstall message for
+ // the same manifestURL
+ let resolve = app => {
+ this._unlistenAppEvents(listener);
+ installs = null;
+ deferred.resolve({ app: app, appId: finalAppId });
+ };
+
+ // Listen for appInstall event, in order to resolve with
+ // the matching app object.
+ let listener = (type, app) => {
+ if (type == "appInstall") {
+ // Resolves immediately if the request has already resolved
+ // or just flag the installed app to eventually resolve
+ // when the request gets its response.
+ if (app.manifest.manifestURL === manifestURL) {
+ resolve(app);
+ } else {
+ installs[app.manifest.manifestURL] = app;
+ }
+ }
+ };
+ this._listenAppEvents(listener)
+ // Execute the request
+ .then(request)
+ .then(response => {
+ finalAppId = response.appId;
+ manifestURL = response.manifestURL;
+
+ // Resolves immediately if the appInstall event
+ // was dispatched during the request.
+ if (manifestURL in installs) {
+ resolve(installs[manifestURL]);
+ }
+ }, deferred.reject);
+
+ return deferred.promise;
+
+ },
+
+ /*
+ * Install a hosted app.
+ *
+ * Events are going to be emitted on the front
+ * as install progresses. Events will have the following fields:
+ * * bytesSent: The number of bytes sent so far
+ * * totalBytes: The total number of bytes to send
+ */
+ installHosted: function (appId, metadata, manifest) {
+ let manifestURL = metadata.manifestURL ||
+ metadata.origin + "/manifest.webapp";
+ let request = () => {
+ return installHosted(this.client, this.actor, appId, metadata,
+ manifest)
+ .then(response => ({
+ appId: response.appId,
+ manifestURL: manifestURL
+ }));
+ };
+ return this._install(request);
+ }
+};
+
+exports.AppActorFront = AppActorFront;