join.js

chrome.commands.onCommand.addListener(async function (command) {
	console.log('Command:', command);
	if (command == "popup") {
		createPushClipboardWindowAndCloseAfterCommand();
	} else if (command == "repeat-last-command") {
		repeatLastCommand();
	} else if (command == "favorite-command") {
		var favoriteCommand = getFavoriteCommand();
		favoriteCommand = getDeviceCommands().first(function (command) { return command.label == favoriteCommand; });
		if (!favoriteCommand) {
			favoriteCommand = deviceCommands[0];
		}
		var favoriteCommandDevice = getFavoriteCommandDevice();
		if (favoriteCommand && favoriteCommandDevice) {
			favoriteCommand.func(favoriteCommandDevice, true, getFavoriteCommandText());
		}
	} else if (command == "notifications-popup") {
		showNotificationsPopup();
	} else if (command == "voice-command") {
		if (!getVoiceEnabled()) {
			return;
		}
		if (back.UtilsVoice.voiceRecognizer != null && back.UtilsVoice.voiceRecognizer.getAlwaysListeningEnabled()) {
			back.console.log("Not starting because it's on continuous");
			return;
		}
		try {
			const prompt = await UtilsVoice.doVoiceCommand(devices);
			showNotification("Join", prompt)
		} catch (error) {
			showNotification("Join Voice Command", `Error recognizing: ${error}`);
			console.log("Error recognizing!")
			console.log(error);
		}
	}
});
async function registerInEventBus(callback) {
	eventBus.register(callback);
}
var eventBus = new EventBusCrossContext();
var repeatLastCommand = function () {
	if (localStorage["lastpush"]) {
		var deviceId = localStorage["lastpush"];
		var lastPushFunc = localStorage["lastpushtype"];
		if (lastPushFunc.indexOf(LAST_PUSH_CUSTOM_COMMAND) == 0) {
			new TaskerCommands().performCommand(deviceId, lastPushFunc.split("=:=")[1], true);
		} else {
			window[lastPushFunc](deviceId, true);
		}
	} else {
		createPushClipboardWindowAndCloseAfterCommand();
	}
}
var getNotificationPopupHeight = function () {
	var height = Math.min(Math.round((203 * notifications.length) + 80), screen.height * 0.75);
	if (notifications.length == 0) {
		height = 150;
	}
	return height;
}
var getNotificationPopupWidth = function () {
	return 375;
}
var notificationsWindow = null;
var showNotificationsPopup = function (tab) {
	if (!tab) {
		tab = "notifications";
	}
	if (notificationsWindow != null) {
		return;
	}
	var height = getNotificationPopupHeight();
	var width = getNotificationPopupWidth();
	chrome.windows.create({ "focused": false, url: 'devices.html?tab=' + tab + '&closeOnEmpty=true', type: 'popup', left: screen.width - width, top: Math.round((screen.height / 2) - (height / 2)), width: width, height: height }, function (win) {
		notificationsWindow = win;
	});
}
var createPushClipboardWindowAndCloseAfterCommand = function () {
	createPushClipboardWindow(null, null, null, true);
}
var createPushClipboardWindow = function (tab, params, paramsIfClosed, closeAfterCommand) {
	if (!tab) {
		tab = "devices";
	}
	var url = 'devices.html?tab=' + tab + '&popup=1' + (closeAfterCommand ? '&closeAfterCommand=1' : '');
	if (params) {
		var addParams = function (params) {
			if (!params) {
				return;
			}
			for (var prop in params) {
				var value = params[prop];
				if (value) {
					url += "&" + prop + "=" + encodeURIComponent(value);
				}
			}
		}
		addParams(params);
		if (!popupWindowClipboard) {
			addParams(paramsIfClosed);
		}
	}
	if (!devices || devices.length == 0) {
		alert("Join doesn't have any other devices available to send stuff to. Please log in on the same account on other devices to make them appear here.");
		return;
	}
	if (popupWindowClipboard) {
		var tab = popupWindowClipboard.tabs[0];
		chrome.tabs.update(tab.id, { "url": url });
		chrome.windows.update(popupWindowClipboardId, { "focused": true });
	} else {
		/*var height = Math.min(Math.round((88 * devices.length) + 100), screen.height * 0.75);
		height = Math.max(height, (deviceCommands.length * 25) + 100);*/
		var width = parseInt(localStorage.popoutWidth);
		if (!width) {
			width = 456;
		}
		var height = parseInt(localStorage.popoutHeight);
		if (!height) {
			height = 606;
		}
		chrome.windows.create({ url: url, type: 'popup', left: screen.width - 230, top: Math.round((screen.height / 2) - (height / 2)), width: width, height: height }, function (clipboardWindow) {
			popupWindowClipboard = clipboardWindow;
			popupWindowClipboardId = clipboardWindow.id;
		});
	}
}
var popupWindowClipboard = null;
var popupWindowClipboardId = null;
chrome.windows.onRemoved.addListener(function (windowId) {
	// If the window getting closed is the popup we created
	if (windowId === popupWindowClipboardId) {
		// Set popupId to undefined so we know the popups not open
		popupWindowClipboard = null;
	}
});

var clipboardWindows = [];
var clearClipboardWindows = function () {
	for (var i = 0; i < clipboardWindows.length; i++) {
		var win = clipboardWindows[i];
		chrome.windows.remove(win.id);
	};
	clipboardWindows = [];
}
var getToken = async function (callback, token) {
	const tokenAwaited = token ? token : await getAuthTokenPromise(false, token);
	if (callback) {
		callback(tokenAwaited);
	}
	return tokenAwaited;
	/*chrome.identity.getAuthToken({ 'interactive': true }, function(token) {
		callback(token);
	});*/
}
var isDoingAuth = false;
var waitingForAuthCallbacks = [];
/*var getAuthToken = function(callback, selectAccount){
	if(selectAccount){
		removeAuthToken();
	}
	//removeAuthToken();
	if(localStorage.accessToken && localStorage.authExpires && new Date(new Number(localStorage.authExpires)) > new Date()){
		if(callback){
			callback(localStorage.accessToken);
		}
	}else{
		if(!isDoingAuth){
			isDoingAuth = true;
			var url = getAuthUrl(selectAccount);
			chrome.identity.launchWebAuthFlow({'url': url, 'interactive': true},function(redirect_url) {
				var token = null;
				if(redirect_url){
					token = getAuthTokenFromUrl(redirect_url);
					var expiresIn = new Number(getURLParameter(redirect_url,"expires_in"));
					localStorage.authExpires = new Date().getTime() + ((expiresIn - 120) * 1000);
					localStorage.accessToken = token;
					console.log(getSensitiveLogPreview(token) + ":" + expiresIn);
				}
				if(callback){
					callback(token);
				}
				waitingForAuthCallbacks.doForAll(function(waitingCallback){
					waitingCallback(token)
				});
				waitingForAuthCallbacks = [];
				isDoingAuth = false;
			});
		}else{
			if(callback){
				waitingForAuthCallbacks.push(callback);
			}
		}
	}
}*/
var getAuthTokenBackground = async function (callback, selectAccount) {
	if (isLocalAccessTokenValid()) {
		if (callback) {
			callback(localStorage.accessToken)
		}
		return;
	}
	var authUrl = await getAuthUrl(selectAccount, true);
	if (localStorage.userinfo) {
		var userinfo = JSON.parse(localStorage.userinfo);
		if (userinfo.email) {
			authUrl += "&login_hint=" + userinfo.email;
		}
	}
	fetch(authUrl, { "redirect": 'manual', "credentials": 'include' }).then(function (response) {
		return response.text();
	}).then(function (response) {
		var tokenIndex = response.indexOf("access_token=");
		if (tokenIndex > 0) {
			var token = response.substring(tokenIndex + 13)
			token = token.substring(0, token.indexOf("&"))
			var expiresIn = response.substring(response.indexOf("expires_in=") + 11);
			expiresIn = expiresIn.substring(0, expiresIn.indexOf("\""));
			expiresIn = parseInt(expiresIn.match(/\d+/)[0]);
			setLocalAccessToken(token, expiresIn);
			console.log(getSensitiveLogPreview(token));
			console.log(expiresIn);
			if (callback) {
				callback(token);
			}
		} else {
			getAuthTokenFromTab(callback, selectAccount);
		}
	}).catch(function (error) {
		console.log('There has been a problem with your fetch operation: ' + error.message);

		if (callback) {
			callback(null);
		}
	});
}
var authTabId = null;
var lastAuthFailTime = 0;
var AUTH_COOLDOWN_MS = 5000;
var isLocalAccessTokenValid = function () {
	return localStorage.accessToken && localStorage.authExpires && new Date(new Number(localStorage.authExpires)) > new Date();
}
var setLocalAccessToken = function (token, expiresIn) {
	localStorage.authExpires = new Date().getTime() + ((expiresIn - 120) * 1000);
	localStorage.accessToken = token;
}
var getUrlParamKeys = function (paramsString) {
	if (!paramsString) {
		return [];
	}
	try {
		var params = new URLSearchParams(paramsString);
		var keys = [];
		params.forEach(function (value, key) {
			if (keys.indexOf(key) >= 0) {
				return;
			}
			keys.push(key);
		});
		keys.sort();
		return keys;
	} catch (error) {
		return [];
	}
}
var getAuthUrlDebugInfo = function (url, changeInfo) {
	var info = {
		status: changeInfo ? changeInfo.status : null,
		hasUrl: !!url
	};
	if (!url) {
		return info;
	}
	info.urlStartsAuthCallback = url.indexOf(AUTH_CALLBACK_URL) == 0;
	info.hasAccessTokenText = url.indexOf("access_token=") >= 0;
	info.hasErrorText = url.indexOf("error=") >= 0;
	info.hasCodeText = url.indexOf("code=") >= 0;
	try {
		var parsedUrl = new URL(url);
		info.origin = parsedUrl.origin;
		info.pathname = parsedUrl.pathname;
		info.searchKeys = getUrlParamKeys(parsedUrl.search ? parsedUrl.search.replace(/^\?/, "") : "");
		var hash = parsedUrl.hash ? parsedUrl.hash.replace(/^#/, "") : "";
		info.hashKeys = getUrlParamKeys(hash);
		info.hashLength = hash.length;
	} catch (error) {
		info.parseError = error.toString();
	}
	return info;
}
var getAuthTokenFromTab = async function (callback, selectAccount) {

	if (getDontPromptUserLogin()) {
		callback(localStorage.accessToken);
		return;
	}
	if (!selectAccount && (Date.now() - lastAuthFailTime) < AUTH_COOLDOWN_MS) {
		if (callback) {
			callback(null);
		}
		return;
	}
	if (selectAccount) {
		removeAuthToken();
	}
	//removeAuthToken();
	if (isLocalAccessTokenValid()) {
		if (callback) {
			callback(localStorage.accessToken);
		}
	} else {
		var focusOnAuthTabId = async function () {
			if (authTabId) {
				await chrome.tabs.update(authTabId, { "active": true });
				if (!localStorage.warnedLogin) {
					localStorage.warnedLogin = true;
					alert("Please login to use Join");
				}
			} else {
				//alert("Something went wrong. Please reload the Join extension.");
			}
		}
			if (!isDoingAuth) {
				isDoingAuth = true;
				var url = await getAuthUrl(selectAccount);

			if (localStorage.userinfo) {
				var userinfo = JSON.parse(localStorage.userinfo);
				if (userinfo.email) {
					url += "&login_hint=" + userinfo.email;
				}
			}
				var closeListener = async function (tabId, removeInfo) {
					if (authTabId && tabId == authTabId) {
						await finisher(tabId, null, null, true, "tab_closed");
					}
				}
				var authListenerUpdateCount = 0;
				var authListener = async function (tabId, changeInfo, tab) {
						authListenerUpdateCount++;
						if (tab?.url && (tabId == authTabId || tab.url.indexOf(AUTH_CALLBACK_URL) == 0 || (changeInfo?.status == "complete" && tab.url.indexOf("accounts.google.com") >= 0))) {
						}
						if (tab?.url && tab.url.indexOf(await getCliendId()) > 0) {
							authTabId = tabId;
							await focusOnAuthTabId();
						}
						if (tab && tab.url && tab.url.indexOf(AUTH_CALLBACK_URL) == 0) {
							var redirect_url = tab.url;
							var token = getAuthTokenFromUrl(redirect_url);
							if (token) {
								await finisher(tabId, token, redirect_url, false, "token_found");
								return;
							}
							if (redirect_url.indexOf("error=") >= 0) {
								await finisher(tabId, null, redirect_url, false, "oauth_error");
								return;
							}
						}
				}
				var finisherCalled = false;
				var finisher = async function (tabId, token, redirect_url, tabAlreadyClosed, reason) {
					if (finisherCalled) return;
					finisherCalled = true;
					authTabId = null;
					chrome.tabs.onUpdated.removeListener(authListener);
					chrome.tabs.onRemoved.removeListener(closeListener);
					console.log("Auth token found from tab: " + getSensitiveLogPreview(token));
				if (!tabAlreadyClosed) {
					try {
						await chrome.tabs.remove(tabId);
					} catch (error) {
						console.log("Error closing auth tab");
						console.log(error);
					}
				}
				var finishCalled = false;
				var finshCallback = function (token) {
					if (finishCalled) return;
					finishCalled = true;
					if (callback) {
						callback(token);
					}
					waitingForAuthCallbacks.doForAll(function (waitingCallback) {
						waitingCallback(token)
					});
					waitingForAuthCallbacks = [];
					isDoingAuth = false;
				}
				if (token && redirect_url) {
					var expiresIn = new Number(getURLParameter(redirect_url, "expires_in"));
					setLocalAccessToken(token, expiresIn);
					console.log("Token expires in " + expiresIn + " seconds");
					getUserInfo(function (userInfoFromStorage) {
						console.log("Logged in with: " + getSensitiveLogPreview(userInfoFromStorage.email));
						finshCallback(token);
					}, true, token);
					setTimeout(function () {
						if (!finishCalled) {
							console.log("getUserInfo timed out, proceeding with token");
							finshCallback(token);
						}
					}, 10000);
				} else {
					lastAuthFailTime = Date.now();
					finshCallback(null);
				}

			}
			chrome.tabs.onUpdated.addListener(authListener);
			chrome.tabs.onRemoved.addListener(closeListener)
			openTab(url, { selected: false, active: false }, function (tab) {
				console.log("Tab auth created");
				console.log(tab);
			});
		} else {
			if (callback) {
				waitingForAuthCallbacks.push(callback);
				await focusOnAuthTabId();
			}
		}
	}
}
var getAuthTokenFromChrome = function (callback) {

}
var getAuthTokenPromise = function (selectAccount, token) {
	return new Promise(function (resolve) {
		getAuthToken(resolve, selectAccount, token);
	});
}
var getAuthToken = function (callback, selectAccount, token) {
	if (token) {
		if (callback) {
			callback(token);
		}
		return;
	}
	if (selectAccount) {
		getAuthTokenFromTab(callback, selectAccount);
		return;
	}
	chrome.identity.getProfileUserInfo(function (userInfoFromChrome) {
		if (localStorage.userinfo) {
			var userInfoFromStorage = JSON.parse(localStorage.userinfo);
			if (userInfoFromStorage.email && userInfoFromStorage.email != userInfoFromChrome.email) {
				getAuthTokenBackground(callback, selectAccount);
				return;
			}
		}
		if (!userInfoFromChrome.email) {
			getAuthTokenFromTab(callback, selectAccount);
			return;
		}
		chrome.identity.getAuthToken({ 'interactive': true }, function (tokenResult) {
			if (chrome.runtime.lastError || !tokenResult?.token) {
				console.log("chrome.identity.getAuthToken failed: " + chrome.runtime.lastError?.message);
				getAuthTokenFromTab(callback, selectAccount);
				return;
			}
			setLocalAccessToken(tokenResult.token, 3600);
			if (callback) {
				callback(tokenResult.token);
			}
		});

	});

}
var getAuthTokenFromUrl = function (url) {
	if (!url) {
		return null;
	}
	var tokenSource = null;
	try {
		var parsedUrl = new URL(url);
		var hash = parsedUrl.hash ? parsedUrl.hash.replace(/^#/, "") : "";
		var hashParams = new URLSearchParams(hash);
		var tokenFromHash = hashParams.get("access_token");
		if (tokenFromHash) {
			tokenSource = "hash";
			return tokenFromHash;
		}
		var tokenFromQuery = parsedUrl.searchParams.get("access_token");
		if (tokenFromQuery) {
			tokenSource = "query";
			return tokenFromQuery;
		}
	} catch (error) {
	}
	var tokenMatch = url.match(/(?:[#?&])access_token=([^&]+)/);
	if (tokenMatch && tokenMatch[1]) {
		tokenSource = "regex";
		return decodeURIComponent(tokenMatch[1]);
	}
	return null;
}
var removeAuthToken = function (callback) {
	delete localStorage.accessToken;
	delete localStorage.authExpires;
	delete localStorage.userinfo;
}

var doGetWithAuthAsyncRequest = function (endpointRequest, endpointGet, deviceId, callback, callbackError) {
	doRequestWithAuth("GET", joinserver + "messaging/v1/" + endpointRequest + "?deviceId=" + deviceId, null, function (response) {
		var requestId = response.requestId;
		if (requestId) {
			doGetWithAuthAsyncRequestGetResponse(joinserver + "messaging/v1/" + endpointGet + "?requestId=" + requestId, callback, callbackError);
		} else {
			callbackError({ "error": "didn't get request id" });
		}
	}, callbackError);
}
var doGetWithAuthAsyncRequestGetResponse = function (urlGet, callback, callbackError, count) {
	if (count > 5) {
		callbackError({ "error": "couldn't contact device" });
		return;
	}
	setTimeout(function () {
		if (!count) {
			count = 0;
		}
		doRequestWithAuth("GET", urlGet, null, function (responseGet) {
			if (responseGet.responseAvailable) {
				callback(responseGet);
			} else {
				doGetWithAuthAsyncRequestGetResponse(urlGet, callback, callbackError, ++count);
			}
		}, callbackError);
	}, 2000);

}


var getURLParameter = function (url, name) {
	if (url == null) {
		url = window.location.href;
	}
	return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(url) || [, ""])[1].replace(/\+/g, '%20')) || null
}
var removeCachedAuthToken = async function (callback) {
	removeAuthToken();
	if (callback) {
		callback();
	}
	/*chrome.identity.getAuthToken({ 'interactive': true }, function(token) {
		chrome.identity.removeCachedAuthToken({ 'token': token }, function(){
				console.log("cached token removed");
				if(callback){
					callback();
				}
		});
	});*/
}



/****************************OPTIONS********************************/
// var getOptionType = function (option) {
// 	if (option.attributes.type) {
// 		return option.attributes.type.textContent;
// 	} else {
// 		return option.localName;
// 	}
// }
// var getOptionDelayed = function (option) {
// 	if (option.attributes.delayed) {
// 		return true;
// 	} else {
// 		return false;
// 	}
// }
// var isOptionUndefined = function (value) {
// 	return !value || value == "undefined" || value == "null" || value == "";
// }
// var optionSavers = [
// 	{
// 		"type": "text",
// 		"saveevent": "keyup",
// 		"save": function (option) {
// 			localStorage[option.id] = option.value;
// 		},
// 		"load": function (option) {
// 			option.value = this.getValue(option, getDefaultValue(option));
// 		},
// 		"getValue": function (option, defaultValue) {
// 			var id = null;
// 			if (typeof option == "string") {
// 				id = option;
// 			} else {
// 				id = option.id;
// 			}
// 			var value = localStorage[id];
// 			if (isOptionUndefined(value)) {
// 				if (!defaultValue) {
// 					defaultValue = "";
// 				}
// 				value = defaultValue;
// 				this.save(id, defaultValue);
// 			}
// 			return value;
// 		}, "setDefaultValue": function (option) {
// 			if (!option.value) {
// 				var defaultValue = getDefaultValue(option);
// 				if (!isOptionUndefined(defaultValue)) {
// 					option.value = defaultValue;
// 				}
// 			}

// 		}
// 	},
// 	{
// 		"type": "textarea",
// 		"saveevent": "keyup",
// 		"save": function (option) {
// 			localStorage[option.id] = option.value;
// 		},
// 		"load": function (option) {
// 			option.value = this.getValue(option, getDefaultValue(option));
// 		},
// 		"getValue": function (option, defaultValue) {
// 			var id = null;
// 			if (typeof option == "string") {
// 				id = option;
// 			} else {
// 				id = option.id;
// 			}
// 			var value = localStorage[id];
// 			if (isOptionUndefined(value)) {
// 				if (!defaultValue) {
// 					defaultValue = "";
// 				}
// 				value = defaultValue;
// 				this.save(id, defaultValue);
// 			}
// 			return value;
// 		}, "setDefaultValue": function (option) {
// 			if (!option.value) {
// 				var defaultValue = getDefaultValue(option);
// 				if (!isOptionUndefined(defaultValue)) {
// 					option.value = defaultValue;
// 				}
// 			}

// 		}
// 	}, {
// 		"type": "checkbox",
// 		"saveevent": "click",
// 		"save": function (option, value) {
// 			var id = null;
// 			if (typeof option == "string") {
// 				id = option;
// 			} else {
// 				id = option.id;
// 				value = option.checked;
// 			}
// 			localStorage[id] = value;
// 			var onSaveFunc = window["on" + id + "save"];
// 			if (onSaveFunc) {
// 				onSaveFunc(option, value);
// 			}
// 		},
// 		"load": function (option) {
// 			option.checked = this.getValue(option, getDefaultValue(option));
// 		},
// 		"getValue": function (option, defaultValue) {
// 			var id = null;
// 			if (typeof option == "string") {
// 				id = option;
// 			} else {
// 				id = option.id;
// 			}
// 			var value = localStorage[id];
// 			if (isOptionUndefined(value)) {
// 				value = defaultValue;
// 				this.save(id, defaultValue);
// 			} else if (value == "false") {
// 				value = false;
// 			} else {
// 				value = true;
// 			}
// 			return value;
// 		}, "setDefaultValue": function (option) {
// 			if (this.getValue(option, null) == null) {
// 				var defaultValue = getDefaultValue(option);
// 				option.checked = defaultValue;
// 			}
// 		}
// 	}, {
// 		"type": "select",
// 		"saveevent": "change",
// 		"save": function (option) {
// 			localStorage[option.id] = option.value;
// 		},
// 		"load": function (option) {
// 			option.value = this.getValue(option, getDefaultValue(option));
// 			if (option.funcOnChange) {
// 				option.funcOnChange();
// 			}
// 		},
// 		"getValue": function (option, defaultValue) {
// 			var id = null;
// 			if (typeof option == "string") {
// 				id = option;
// 			} else {
// 				id = option.id;
// 			}
// 			var value = localStorage[id];
// 			if (isOptionUndefined(value)) {
// 				if (!defaultValue) {
// 					defaultValue = "";
// 				}
// 				value = defaultValue;
// 				this.save(id, defaultValue);
// 			}
// 			return value;
// 		}, "setDefaultValue": function (option) {
// 			if (!option.value) {
// 				var defaultValue = getDefaultValue(option);
// 				if (!isOptionUndefined(defaultValue)) {
// 					option.value = defaultValue;
// 				}
// 			}

// 		}
// 	}, {
// 		"type": "color",
// 		"saveevent": "change",
// 		"save": function (option) {
// 			localStorage[option.id] = option.value;
// 		},
// 		"load": function (option) {
// 			option.value = this.getValue(option, getDefaultValue(option));
// 			if (option.funcOnChange) {
// 				option.funcOnChange();
// 			}
// 		},
// 		"getValue": function (option, defaultValue) {
// 			var id = null;
// 			if (typeof option == "string") {
// 				id = option;
// 			} else {
// 				id = option.id;
// 			}
// 			var value = localStorage[id];
// 			if (isOptionUndefined(value)) {
// 				if (!defaultValue) {
// 					defaultValue = "";
// 				}
// 				value = defaultValue;
// 				this.save(id, defaultValue);
// 			}
// 			return value;
// 		}, "setDefaultValue": function (option) {
// 			if (!option.value) {
// 				var defaultValue = getDefaultValue(option);
// 				if (!isOptionUndefined(defaultValue)) {
// 					option.value = defaultValue;
// 				}
// 			}

// 		}
// 	}
// ];
// var getOptionSaver = function (option) {
// 	for (var i = 0; i < optionSavers.length; i++) {
// 		var optionSaver = optionSavers[i];
// 		var type = typeof option == "string" ? option : getOptionType(option);
// 		if (optionSaver.type == type) {
// 			return optionSaver;
// 		}
// 	}
// }

// var deviceSufix = "=:=DeviceAutoClipboard=:=";
// var getDeviceIdsToSendAutoClipboard = function () {
// 	var deviceIds = [];
// 	for (var i = 0; i < devices.length; i++) {
// 		var device = devices[i];
// 		if (device.deviceId == localStorage.deviceId) {
// 			continue;
// 		}
// 		if (UtilsDevices.isDeviceGroup(device) || UtilsDevices.isDeviceShare(device)) {
// 			continue;
// 		}
// 		var key = device.deviceId + deviceSufix;
// 		var enabled = localStorage[key] == null || localStorage[key] == "true";
// 		if (enabled) {
// 			deviceIds.push(device.deviceId);
// 		}
// 	};
// 	return deviceIds;
// }

// var getOptionValue = function (type, id, defaultValue) {
// 	if (!defaultValue) {
// 		defaultValue = getDefaultValue(id);
// 	}
// 	var optionSaver = getOptionSaver(type);
// 	return optionSaver.getValue(id, defaultValue);
// }
// var saveOptionValue = function (type, id, value) {
// 	var optionSaver = getOptionSaver(type);
// 	return optionSaver.save(id, value);
// }
// var getDownloadScreenshotsEnabled = function () {
// 	return getOptionValue("checkbox", "downloadscreenshots");
// }
// var getOpenLinksEnabled = function () {
// 	return getOptionValue("checkbox", "autoopenlinks");
// }
// var getDownloadVideosEnabled = function () {
// 	return getOptionValue("checkbox", "downloadvideos");
// }
// var get12HourFormat = function () {
// 	return getOptionValue("checkbox", "12hrformat");
// }
// var getTheme = function () {
// 	return getOptionValue("select", "theme");
// }
// var getAutoClipboard = function () {
// 	return getOptionValue("checkbox", "autoclipboard");
// }
// var getClipboardNotificationShowContents = function () {
// 	return getOptionValue("checkbox", "clipboardnotificationshowcontents");
// }
// var getAutoClipboardNotification = function () {
// 	return getOptionValue("checkbox", "autoclipboardnotification");
// }
// var getFavoriteCommand = function () {
// 	return getOptionValue("select", "select_favourite_command");
// }
// var getFavoriteCommandDevice = function () {
// 	return getOptionValue("select", "select_favourite_command_device");
// }
// var getNotificationSeconds = function () {
// 	return getOptionValue("text", "notificationseconds");
// }
// var getNotificationIgnoreOldPushes = function () {
// 	return getOptionValue("text", "notificationignoreoldpushes");
// }
// var getNotificationRequireInteraction = function () {
// 	return getOptionValue("checkbox", "notificationrequireinteraction");
// }
// var getAddDismissEverywhereButton = function () {
// 	return getOptionValue("checkbox", "adddimisseverywherebutton");
// }
// var getNeverShowSimilarNotifications = function () {
// 	return getOptionValue("checkbox", "nevershowsimilarnotifications");
// }
// var getBetaEnabled = function () {
// 	return getOptionValue("checkbox", "showbetafeatures");
// }
// var getNotificationSound = function () {
// 	return getOptionValue("text", "notificationsound");
// }
// var getNotificationWebsites = function () {
// 	return getOptionValue("textarea", "notificationwebsites");
// }
// var getNotificationNoPopupPackages = function () {
// 	return getOptionValue("textarea", "notificationnopopuppackages");
// }
// var getShowChromeNotifications = function () {
// 	return getOptionValue("checkbox", "chromenotifications");
// }
// var setShowChromeNotifications = function (value) {
// 	saveOptionValue("checkbox", "chromenotifications", value);
// }
// var getPrefixTaskerCommands = function () {
// 	return getOptionValue("checkbox", "prefixtaskercommands");
// }
// var getHideNotificationText = function () {
// 	return getOptionValue("checkbox", "hidenotificationtext");
// }
// var getPlayNotificationSound = function () {
// 	return getOptionValue("checkbox", "playnotificationsound");
// }
// var getAlternativePopupIcon = function () {
// 	return getOptionValue("checkbox", "alternativeicon");
// }
// var getHideNotificationCount = function () {
// 	return getOptionValue("checkbox", "hidenotificationcount");
// }
// var getHideContextMenu = function () {
// 	return getOptionValue("checkbox", "hidecontextmenu");
// }
// var getDontPromptUserLogin = function () {
// 	return getOptionValue("checkbox", "dontpromptuserlogin");
// }
// var getShowInfoNotifications = function () {
// 	return getOptionValue("checkbox", "showinfonotifications");
// }
// var getEventghostPort = function () {
// 	return getOptionValue("text", "eventghostport");
// }
// var getEventghostServer = function () {
// 	return getOptionValue("text", "eventghostserver");
// }
// var getRedirectFullPush = function () {
// 	return getOptionValue("checkbox", "redirectionfullpush");
// }
// var getFavoriteCommandText = function () {
// 	return getOptionValue("text", "text_favourite_command");
// }
// var getVoiceEnabled = function () {
// 	return getOptionValue("checkbox", "voiceenabled");
// }
// var getVoiceContinuous = function () {
// 	return getOptionValue("checkbox", "voicecontinuous");
// }
// var getVoiceWakeup = function () {
// 	return getOptionValue("text", "voicewakeup");
// }
// var getThemeAccentColor = function () {
// 	return getOptionValue("color", "themeColorPicker");
// }
// var getDefaultTab = function () {
// 	return getOptionValue("select", "defaulttabb");
// }
// var onvoiceenabledsave = UtilsObject.async(function* (option, value) {
// 	if (!option) {
// 		return;
// 	}
// 	if (!option.ownerDocument) {
// 		return;
// 	}
// 	var continuousOption = option.ownerDocument.querySelector("#voicecontinuous");
// 	var continuousSection = option.ownerDocument.querySelector("#continuoussection");
// 	if (!value) {
// 		setVoiceContinuous(false);
// 		continuousOption.checked = false;
// 		continuousSection.classList.add("hidden");
// 	} else {
// 		continuousSection.classList.remove("hidden");
// 	}
// });
// var setVoiceContinuous = function (enabled) {
// 	saveOptionValue("checkbox", "voicecontinuous", enabled);
// }
// var onvoicecontinuoussave = async function (option, value) {
// 	console.log("Continuous: " + value);
// 	var callbackPromptFunc = (prompt, notificationTime) => {
// 		return new Promise(function (resolve, reject) {
// 			if (UtilsObject.isString(prompt)) {
// 				chrome.tts.speak(prompt, {
// 					"lang": 'en-US',
// 					"onEvent": function (event) {
// 						if (event.type == 'end' || event.type == 'error' || event.type == 'interrupted' || event.type == 'cancelled') {
// 							resolve();
// 						}
// 					}
// 				});
// 				showNotification("Voice", prompt, notificationTime);
// 			} else {
// 				console.error("Prompt is not text");
// 				console.error(prompt);
// 			}
// 		});
// 	};
// 	var errorFunc = error => {
// 		callbackPromptFunc(error, 10000);
// 	};
// 	if (value) {
// 		try {
// 			await UtilsVoice.voiceRecognizer.isMicAvailable();
// 		} catch (error) {
// 			setVoiceContinuous(false);
// 			chrome.tts.speak("Click the generated notification to enable your mic");
// 			var chromeNotification = new ChromeNotification({
// 				"id": "micnotavailable",
// 				"title": "Error",
// 				"text": "Click here to allow Join to access your microphone",
// 				"url": "chrome-extension://flejfacjooompmliegamfbpjjdlhokhj/options.html"
// 			});
// 			chromeNotification.notify();
// 		}
// 	}
// 	UtilsVoice.toggleContinuous(() => devices, getVoiceWakeup, getVoiceContinuous, callbackPromptFunc, null, errorFunc);
// };
// var onautoclipboardsave = function (option, value) {
// 	console.log("Auto clipboard: " + value);
// 	if (handleAutoClipboard) {
// 		handleAutoClipboard();
// 	}
// }

var updateContextMenu = async () => await contextMenu.update(devices, getHideContextMenu());
var updateContextMenuDevices = async (devices) => await contextMenu.update(devices);
async function getContextMenuContexts() {
	return contextMenu.contexts;
}
var onchromenotificationssave = async function (option, value) {
	console.log("Changed chrome notification popup setting: " + value);
	await updateContextMenu();
}
var onshowbetafeaturessave = function (option, value) {
	if (!option) {
		return;
	}
	if (!option.ownerDocument) {
		return;
	}
	back.console.log("Changed beta setting: " + value);
	option.ownerDocument.location.reload();
}
// var getDefaultValue = function (option) {
// 	var id = null;
// 	if (typeof option == "string") {
// 		id = option;
// 	} else {
// 		id = option.id;
// 	}
// 	return defaultValues[id];
// }
// var defaultValues = {
// 	"downloadscreenshots": true,
// 	"downloadvideos": false,
// 	"12hrformat": false,
// 	"autoclipboard": false,
// 	"clipboardnotificationshowcontents": true,
// 	"autoclipboardnotification": true,
// 	"chromenotifications": true,
// 	"notificationwebsites": JSON.stringify(notificationPages, null, 1),
// 	"notificationnopopuppackages": "",
// 	"prefixtaskercommands": false,
// 	"hidenotificationtext": false,
// 	"hidenotificationcount": false,
// 	"hidecontextmenu": false,
// 	"dontpromptuserlogin": false,
// 	"playnotificationsound": true,
// 	"showinfonotifications": true,
// 	"autoopenlinks": true,
// 	"notificationrequireinteraction": false,
// 	"adddimisseverywherebutton": true,
// 	"showbetafeatures": false,
// 	"voiceenabled": false,
// 	"voicecontinuous": false,
// 	"voicewakeup": "computer",
// 	"themeColorPicker": "#FF9800",
// 	"theme": "auto",
// 	"defaulttabb": "auto",
// 	"favoritepageOpenenable": true,
// 	"favoriteselectionPasteenable": true,
// 	"favoritelinkOpenenable": true,
// 	"favoriteimageDownloadenable": true,
// 	"favoritevideoDownloadenable": true,
// 	"favoriteaudioDownloadenable": true
// };
if (getVoiceContinuous()) {
	onvoicecontinuoussave(null, true);
}
//setShowChromeNotifications(true);
/******************************************************************************/

/*************************************************************************************/

/**************************************************************************************/
setPopupIcon(getAlternativePopupIcon());
var popupWindow = null;
updateBadgeText();
var refreshNotificationsPopup = function () {

	updateBadgeText();
	dispatch("notificationsupdated");
	/*if(popupWindow){
		try{
			popupWindow.writeNotifications();
		}catch(e){
			popupWindow = null;
		}
	}*/
}
var refreshDevicesPopup = function () {
	dispatch("devicesupdated");
	/*if(popupWindow){
		try{
			popupWindow.writeDevices();
		}catch(e){
			popupWindow = null;
		}
	}*/
}

async function downloadFile(fileId) {
	if (!fileId) {
		return null;
	}

	try {
		const accessToken = await getToken();
		const options = {
			headers: { 'Authorization': `Bearer ${accessToken}` }
		}
		const response = await fetch(`https://www.googleapis.com/drive/v2/files/${fileId}?alt=media`, options);

		if (!response.ok) {
			throw new Error('Network response was not ok');
		}

		const data = await response.text();
		return data;
	} catch (error) {
		console.error('Failed to download file:', error);
		return null;
	}
}
/**************************************************************************************/
function extractNotificationDetails(notification) {
	// List of properties to extract from the Notification instance
	const properties = [
		'id',
		'title',
		'body',
		'icon',
		'image',
		'tag',
		'data',
		'requireInteraction',
		'silent',
		'date',
		'text',
		'appName',
		'actionId',
		'appPackage',
		'buttons',
		'color',
		'group',
		'iconData',
		'lines',
		'messages',
		'priority',
		'replyId',
		'statusBarIcon',
		'url',
		'senderId'];

	const options = properties.reduce((acc, prop) => {
		if (prop in notification) {
			acc[prop] = notification[prop];
		}
		return acc;
	}, {});

	// Return the title separately from the options
	return options;
}
async function getNotificationsRaw() {
	// notifications.push(new Notification("bla",{text:"blu",id:"aaa"}));
	const converted = notifications.map(notification => extractNotificationDetails(notification));
	return converted;
}

function getNotificationRaw(notificationId) {
	var notification = getNotification(notificationId);
	if(!notification) return null;

	return extractNotificationDetails(notification);
}
async function cancelNotification(toCancel, localOnly) {
	const existingNotifications = notifications;
	const matchingNotification = existingNotifications.first(existing => {
		const existingExtracted = extractNotificationDetails(existing);
		const toCancelExtracted = extractNotificationDetails(toCancel);
		return UtilsObject.areObjectsEqual(existingExtracted, toCancelExtracted);
	});
	if (!matchingNotification) return;

	matchingNotification.cancel(localOnly);
}
async function doNotificationAction({ notificationId, actionId, text, isReply }) {
	const notification = getNotification(notificationId);
	if (!notification) {
		console.log("Trying to do action on non-existing notification", notificationId);
		return;
	}
	notification.doAction(actionId, text, isReply);
}
var resetNotifications = function () {
	if (notifications) {
		notifications.forEach(n => notifications.removeNotificationsWithSameId(n.id));
	}
	notifications = new Notifications();
	updateBadgeText();
}
var getNotifications = async function (callback) {
	return new Promise((resolve, reject) => {
		resetNotifications();
		var requestId = guid();
		var gcm = new GCMRequestNotifications();
		gcm.requestId = requestId;
		var deviceIds = devices.select(function (device) { return device.deviceId; });
		if (!deviceIds || deviceIds.length == 0) {
			resolve(notifications);
			if (callback) {
				callback(notifications);

			}
			return;
		}
		pendingRequests.push({
			"requestId": requestId, "callback": function (result) {
				resolve(notifications);
				if (callback) {
					callback(notifications);
				}
				console.log(result);
			}
		});
		gcm.send(deviceIds);
		console.log("Requested notifications from: ");
		console.log(deviceIds);
	});
}
var pushClipboard = function (deviceId, notify) {
	getClipboard(function (clipboardData) {
		var push = new GCMPush();
		push.clipboard = clipboardData;
		push.send(deviceId, function () {
			if (notify) {
				showNotification("Join", "Sent Clipboard");
			}
		}, function (error) {
			showNotification("Couldn't send clipboard", error);
		});
		setLastPush(deviceId, "pushClipboard");

	});
}
var openClipboard = function (deviceId, notify) {
	getClipboard(function (clipboardData) {
		var push = new GCMPush();
		push.files = [clipboardData];
		push.send(deviceId, function () {
			if (notify) {
				showNotification("Join", "Sent Clipboard to open");
			}
		}, function (error) {
			showNotification("Couldn't send", error);
		});
		setLastPush(deviceId, "openClipboard");
	});
}
var findDevice = function (deviceId, notify, ignorePrompt) {
	if (!ignorePrompt && !confirm("This will make your phone play your default ringtone at full volume. Are you sure?")) {
		return;
	}
	var push = new GCMPush();
	push.find = true;
	push.send(deviceId, function () {
		if (notify) {
			showNotification("Join", "Device will now ring...");
		}
	}, function (error) {
		showNotification("Couldn't ring device", error);
	});
	setLastPush(deviceId, "findDevice");

}
var sendPushFromCommand = UtilsObject.async(function* (deviceId, notify, text, options) {
	if (!text || (typeof text) != "string") {
		text = yield Dialog.showInputDialog({
			title: options.title,
			placeholder: options.placeholder
		})();
	}
	var push = new GCMPush();
	options.pushModifier(push, text);
	var pushResult = yield push.send(deviceId);
	setLastPushAndNotify(deviceId, notify, options.funcName, options.notificationTextGetter(text))();
});
var speak = function (deviceId, notify, text) {
	sendPushFromCommand(deviceId, notify, text, {
		title: "Text to Say",
		placeholder: "Type some text",
		pushModifier: (push, text) => push.say = text,
		funcName: "speak",
		notificationTextGetter: text => `Saying ${text} out loud...`
	});
}
var openApp = function (deviceId, notify, text) {
	sendPushFromCommand(deviceId, notify, text, {
		title: "App to Open",
		placeholder: "Type the app's name",
		pushModifier: (push, text) => push.app = text,
		funcName: "openApp",
		notificationTextGetter: text => `Opening ${text}...`
	});
}
var getClipboardPush = function (text) {
	var push = new GCMPush();
	push.clipboard = text;
	return push;
}
var sendPushToDeviceId = function (deviceId) {
	return function (push) {
		return push.send(deviceId);
	}
}
var setLastPushAndNotify = function (deviceId, notify, functionName, notificationMessage) {
	return function (result) {
		setLastPush(deviceId, functionName);
		if (notify) {
			showNotification("Join", notificationMessage);
		}
	}
}
var writeText = async function (deviceId, notify, text) {
	if (!text || (typeof text) != "string") {
		text = await (Dialog.showInputDialog({
			title: "Text to write",
			placeholder: "Type some text"
		})());
	}
	var push = getClipboardPush(text);
	var pushResult = await push.send(deviceId);
	setLastPushAndNotify(deviceId, notify, "writeText", `Wrote ${text}`)();

};
var requestLocation = function (deviceId, notify) {
	var push = new GCMPush();
	push.location = true;
	push.send(deviceId, function () {
		if (notify) {
			showNotification("Join", "Requested location...");
		}
	}, function (error) {
		showNotification("Couldn't locate device", error);
	});
	setLastPush(deviceId, "requestLocation");
}
var sendFileRequest = async function ({ type, deviceId, payload }) {
	var requestFile = new RequestFile(type);
	requestFile.payload = payload;
	return new Promise(async (resolve, reject) => {
		try {
			const callback = result => {
				resolve(result);
			};
			await requestFile.send(deviceId, callback);
		} catch (error) {
			reject(error);
		}
	});
}
var doRequestFile = function (deviceId, notify, requestType, funcName, notificationText, startText) {
	if (notify) {
		if (!startText) {
			startText = "Getting " + notificationText + "...";
		}
		showNotification("Join", startText);
	}
	var requestFile = new RequestFile(requestType);
	requestFile.send(deviceId, function (responseFile) {
		var url = responseFile.viewUrl;
		if (getDownloadScreenshotsEnabled()) {
			url = responseFile.downloadUrl;
		}
		openTab(url);
		showNotification("Join", "Got " + notificationText + "!");
	});
	setLastPush(deviceId, funcName);
}
var getScreenshot = function (deviceId, notify) {
	doRequestFile(deviceId, notify, REQUEST_TYPE_SCREENSHOT, "getScreenshot", "screenshot");
}
var getScreenCapture = function (deviceId, notify) {
	doRequestFile(deviceId, notify, REQUEST_TYPE_VIDEO, "getScreenCapture", "screen capture", "Toggling screen capture...");
}
var renameDevice = function (deviceId, notify) {
	var device = devices.first(function (device) { return device.deviceId == deviceId; });
	if (!device) {
		return;
	}
	var oldName = device.deviceName;
	return Promise.resolve()
		.then(Dialog.showInputDialog({
			title: "What do you want to name " + device.deviceName + "?",
			text: device.deviceName,
			placeholder: "Device Name"
		}))
		.then(function (confirm) {
			if (confirm) {
				doPostWithAuth(joinserver + "registration/v1/renameDevice/?deviceId=" + deviceId + "&newName=" + encodeURIComponent(confirm), { "deviceId": deviceId, "newName": confirm }, async function (result) {
					console.log(result);

					var device = devices.first(function (device) {
						return device.deviceId == deviceId;
					});
					if (!result.success) {
						showNotification("Couldn't rename " + device.deviceName, result.errorMessage);
						return;
					}
					device.deviceName = confirm;
					await setDevices(devices);
					refreshDevicesPopup();
					if (showNotification) {
						showNotification("Renamed", oldName + " renamed to " + confirm);
					}
				}, function (error) {
					console.log("Error: " + error);
					showNotification("Error renaming", error);
				});
			}
		}).catch(UtilsObject.ignoreError);
}
var deleteDevice = function (deviceId, notify) {
	var device = devices.first(function (device) { return device.deviceId == deviceId; });
	if (!device) {
		return;
	}
	var confirm = window.confirm("Are you sure you want to delete " + device.deviceName + "?");
	if (confirm) {
		doPostWithAuth(joinserver + "registration/v1/unregisterDevice/?deviceId=" + deviceId, { "deviceId": deviceId }, async function (result) {
			console.log(result);
			devices.removeIf(function (device) {
				return device.deviceId == deviceId;
			});
			await setDevices(devices);
			refreshDevicesPopup();
			if (showNotification) {
				showNotification("Deleted", device.deviceName + " deleted.");
			}
		}, function (error) {
			console.log("Error: " + error);
			showNotification("Error deleting", error);
		});
	}
}
var noteToSelf = UtilsObject.async(function* (deviceId, notify, text) {
	var noteText = text;
	if (!noteText || !UtilsObject.isString(text)) {
		noteText = yield Dialog.showInputDialog({
			title: "Note to self",
			placeholder: "Note text here..."
		})();
	}
	if (!noteText) {
		return;
	}
	var push = new GCMPush();
	push.title = "Note To Self";
	push.text = noteText;
	push.send(deviceId)
		.then(function () {
			if (notify) {
				var device = devices.first(device => device.deviceId == deviceId);
				if (device) {
					showNotification("Join", `Created note on ${device.deviceName}: "${noteText}"`);
				}
			}
		})
		.catch(UtilsObject.handleError);
	setLastPush(deviceId, "noteToSelf");
});
var getCurrentTab = function (callback) {
	chrome.tabs.query({ 'active': true, currentWindow: true }, function (tabs) {
		if (tabs && tabs.length > 0) {
			callback(tabs[0]);
		} else {
			callback(null);
		}
	});
}
async function getSmsWhilePopupClosed(deviceId, purge) {
	return back.backgroundEventHandler.getSmsWhilePopupClosed(deviceId, purge);
}
var getCurrentTabPromise = function () {
	return new Promise(function (resolve, reject) {
		try {
			getCurrentTab(resolve);
		} catch (error) {
			reject(error);
		}
	});
}
var pushUrl = function (deviceId, notify, callback) {
	getCurrentTab(function (tab) {
		if (!tab) {
			showNotification("Join", "No opened tab detected.");
			return;
		}
		console.log("pushing tab " + getSensitiveLogPreview(tab.url));
		if (tab.url.indexOf(DEVICES_POPUP_URL) == 0) {
			setTimeout(function () {
				pushUrl(deviceId, notify, callback);
			}, 100);
			return;
		}
		var pushed = false;
		if (tab.url.indexOf("http") == 0) {
			var url = tab.url;
			text = tab.title;
			var push = new GCMPush();
			push.url = url;
			push.text = text;
			push.send(deviceId, function () {
				if (notify) {
					showNotification("Join", "Pushed current tab");
				}
			}, function (error) {
				showNotification("Couldn't push current tab", error);
			});
			setLastPush(deviceId, "pushUrl");
			pushed = true;
		}
		if (!pushed) {
			showNotification("Join", "Link not supported. Must start with http. Was " + tab.url);
		}
		if (callback) {
			callback();
		}
	});
}
var pushIFTTTEvent = function (deviceId, notify, text) {
	pushCustomCommand(deviceId, notify, text, "Write your Maker event.\n\nSetup an applet in IFTTT to react to it.", "pushIFTTTEvent")
}
var pushCustomCommand = function (deviceId, notify, text) {
	pushCustomCommand(deviceId, notify, text, "Write your command.", "pushCustomCommand")
}
var pushTaskerCommand = function (deviceId, notify, text) {
	pushCustomCommand(deviceId, notify, text, "Write your Tasker command.\n\nSetup a profile with the AutoApps condition to react to it.", "pushTaskerCommand")
}
var pushCustomCommand = function (deviceId, notify, text, promptText, funcName) {
	var push = new GCMPush();
	if (!text || (typeof text) != "string") {
		text = prompt(promptText);
	}
	if (!text) {
		return;
	}
	if (getPrefixTaskerCommands()) {
		text = "=:=" + text;
	}
	push.text = text;
	push.send(deviceId, function () {
		if (notify) {
			showNotification("Join", "Sent command " + text);
		}
	}, function (error) {
		showNotification("Couldn't push tasker command", error);
	});
	setLastPush(deviceId, funcName);
}
var selectContactForCall = function (deviceId) {
	if (!popupWindow && !popupWindowClipboard) {
		showSmsPopup(deviceId);
		back.console.log("Waiting for popup to open...");
		back.eventBus.waitFor(back.Events.PopupLoaded, 5000)
			.then(() => UtilsObject.wait(500))
			.then(() => {
				back.console.log("Popup opened!");
				dispatch("phonecall", { "deviceId": deviceId })
			});
	} else {
		dispatch("phonecall", { "deviceId": deviceId });
	}
}
var showPushHistory = function (deviceId) {
	openTab("components/push-history.html?deviceId=" + deviceId);
}
var pushCall = function (deviceId, notify, contact) {
	var number = contact.number;
	var name = contact.name;
	var push = new GCMPush();
	if (!number) {
		return;
	}
	if (!name) {
		name = number;
	}
	return Dialog
		.confirm("Calling " + name, "This will call " + name + " (" + number + ") on your device. Are you sure?")
		.then(function () {
			push.callnumber = number;
			push
				.send(deviceId)
				.then(function () {
					if (notify) {
						showNotification("Join", "Sent request to call " + number);
					}
				})
				.catch(function (error) {
					showNotification("Couldn't Push Call Request", error);
				});
		})
		.catch(function () {
			console.log("Not calling " + number);
		});
}
var fileInput = null;
var pushFile = async function (deviceId, notify, tab, files) {
	try {
		var initialAction = files ? Promise.resolve(files) : foregroundPage.pickFile();
		var files = await initialAction;
		console.log("pushFile picked files", files);
		var fileInput = { "files": files };
		if (tab) {
			chrome.tabs.remove(tab.id, function () {
			});
		}
		if (!fileInput.files || fileInput.files.length == 0) {
			return;
		}

		var filesLength = fileInput.files.length;
		var whatsUploading = filesLength == 1 ? fileInput.files[0].name : filesLength + " files";
		showNotification("Join", "Uploading " + whatsUploading);
		/*var googleDriveManager = new GoogleDriveManager();
		var filesToUpload = fileInput.files;
		var device = devices.first(function(device){return device.deviceId == deviceId});
		var accountToShareTo = null;
		if(device){
			accountToShareTo = device.userAccount;
		}
		return googleDriveManager.uploadFiles({
			folderName: GoogleDriveManager.getBaseFolderForMyDevice(),
			accountToShareTo:accountToShareTo,
			notify: getShowInfoNotifications()
		}, filesToUpload)
		.then(function(uploadResults){
			var push = new GCMPush();
			push.files = uploadResults;
			push.send(deviceId,function(){
				console.log("pushed files");
				//showNotification("Join", "Sent " + whatsUploading);
			},function(error){
				showNotification("Join", "Couldn't send file: " + error);
			});
			setLastPush(deviceId, "pushFile");
		})*/
		files = await FileUploadProviderFactory.provide({ "files": fileInput.files, "deviceId": deviceId });
		var push = new GCMPush();
		push.files = files;
		push.send(deviceId, function () {
			console.log("pushed files");
			//showNotification("Join", "Sent " + whatsUploading);
		}, function (error) {
			showNotification("Join", "Couldn't send file: " + error);
		});
		setLastPush(deviceId, "pushFile");
	} catch (error) {
		UtilsObject.handleError(error);
	}
}
var smsWindow = null;
var smsWindowId = null;
var showSmsPopup = function (deviceId, number, name, isReply, text) {
	if (!name) {
		name = number;
	}
	dispatch("sendsms", { "deviceId": deviceId, "sms": { "number": number, "text": text }, "reply": isReply });
	if (!popupWindow && !popupWindowClipboard) {
		createPushClipboardWindow("sms", { "deviceId": deviceId, "number": number, "name": name }, { "reply": isReply, "text": text });
	}

}
addEventListener(EVENT_SMS_HANDLED, function (event) {
	var text = event.text;
	var deviceId = event.deviceId;
	var address = event.address;
	if (!text || !deviceId || !address) {
		return;
	}
	var gcm = new GCMSMSHandled();
	gcm.text = text;
	gcm.address = address;
	gcm.send(deviceId);
});
var sendSmsFromButtonCommand = function (deviceId) {
	showSmsPopup(deviceId);
	/*if(smsWindow != null){
		chrome.windows.update(smsWindowId,{"focused":true});
		return;
	}
	//var url =  joinserverBase + "sms.html?deviceId="+deviceId;
	var height = 690;
	var width = 460;
	var url = "smschrome.html?deviceId="+deviceId+"&height="+height+"&width="+width;
	if(number){
		url += "#" + number;
	}
	chrome.windows.create({ url: url, type: 'popup' , left: screen.width - 230, top: Math.round((screen.height / 2) - (height /2)), width : width, height: height},function(win){
		smsWindow = win;
		smsWindowId = win.id;
	});*/
	/*var requestFile = new RequestFile(REQUEST_TYPE_SMS_HISTORY);
	requestFile.send(deviceId, function(responseFile){
		var url = responseFile.viewUrl;
		console.log(url);
		downloadFile(responseFile,function(jsonSMSs){
			showNotification("Join", "Got SMS!");
			var smses = JSON.parse(jsonSMSs);
			console.log(smses);
		})
	});
	setLastPush(deviceId, "sendSms");*/
}
var setLastPush = function (deviceId, functionName) {
	localStorage["lastpush"] = deviceId;
	localStorage["lastpushtype"] = functionName;
}
/******************************************************************************/


var showNotification = function (title, message, timeout, notificationId) {
	if (!timeout) timeout = 3000;
	var options = {
		"type": "basic",
		"iconUrl": "icons/big.png",
		"title": title,
		"message": message
	};
	if (!notificationId) {
		notificationId = guid();
	}
	if (!title || !message) {
		return;
	}
	chrome.notifications.create(notificationId, options, function () {
		setTimeout(function () {
			chrome.notifications.clear(notificationId, function () { })
		}, timeout);
	});
}
var registerDevice = function (callback, callbackError) {
	var registrationId = localStorage.regIdLocal;
	var registrationId2 = localStorage.regIdLocal2;
	if (!registrationId2) {
		registrationId2 = registrationId;
	}

	var myName = localStorage.deviceName || "Chrome";
	return doPostWithAuthPromise(joinserver + "registration/v1/registerDevice/", { "deviceId": localStorage.deviceId, "regId": registrationId, "regId2": registrationId2, "deviceName": myName, "deviceType": 3 })
		.then(function (result) {
			if (!result || !result.deviceId) {
				var errorMessage = (result && result.errorMessage) ? result.errorMessage : JSON.stringify(result);
				throw new Error("Invalid registerDevice response: " + errorMessage);
			}
			if (localStorage.deviceId == result.deviceId) {
				result.sameDeviceId = true;
			}
			localStorage.deviceId = result.deviceId;
			localStorage.regIdServer = result.regId;
			if (callback) {
				callback(result);
			}
			return result;
		})
		.catch(function (error) {
			console.log("registerDevice error: " + error);
			if (callbackError) {
				callbackError(error);
			}
			if (!callback) {
				return Promise.reject(error);
			}
		});
}
var handlePushMessage = message => {
	console.log(message);
	var multiIndexString = message.data.multi;
	var type = message.data.type;
	if (!multiIndexString) {
		executeGcm(message.data.type, message.data.json);
	} else {
		var multiIndex = Number(multiIndexString);
		var length = Number(message.data.length);
		console.log("Got multi message index: " + multiIndex + "/" + length);
		var id = message.data.id;
		var value = message.data.value;
		var gcmMultis = gcmMultiMap.add(id, multiIndex, value, type, length);
		var complete = gcmMultis.getComplete();
		if (complete) {
			console.log("GCM complete! Executing of type " + type);
			delete gcmMultiMap[id];
			executeGcm(complete.type, complete.json);
		}
	}
}
chrome.gcm.onMessage.addListener(async payload => {
	// await UtilsObject.wait(2000);
	payload.pushHandler = "gcm";
	handlePushMessage(payload);
});
/*chrome.gcm.onMessage.addListener(function(message){
	console.log(message);
	var multiIndexString = message.data.multi;
	var type = message.data.type;
	if(!multiIndexString){
		executeGcm(message.data.type,message.data.json);
	}else{
		var multiIndex = Number(multiIndexString);
		var length = Number(message.data.length);
		console.log("Got multi message index: " + multiIndex+"/"+length);
		var id = message.data.id;
		var value = message.data.value;
		var gcmMultis = gcmMultiMap.add(id,multiIndex,value,type,length);
		var complete = gcmMultis.getComplete();
		if(complete){
			console.log("GCM complete! Executing of type " + type);
			delete gcmMultiMap[id];
			executeGcm(complete.type,complete.json);
		}
	}
});*/
var executeGcm = function (type, json) {
	var gcmFunc = window[type];
	if (!gcmFunc) {
		gcmFunc = eval(type);
	}
	if (!gcmFunc) {
		return;
	}
	var gcm = new gcmFunc();
	gcm.fromJsonString(json);
	gcm.execute();
}

var refreshDevices = async function (callback) {
	console.log("Refreshing devices...");
	try {
		const result = await doGetWithAuth(joinserver + "registration/v1/listDevices/");
		console.log(result);

		await setDevices(result.records);
		new GCMLocalNetworkTestRequest().sendToCompatibleDevices();
		if (callback != null) {
			callback(result.records);
		}
		return result.records;
	} catch (error) {
		console.log("Error: " + error);
		if (callback != null) {
			callback(null);
		}
	}
}
if (!localStorage.firstRunDone) {
	localStorage.firstRunDone = true;
	if (!localStorage.accessToken) {
		getAuthToken(null, true);
	}
} else {
	getToken();
}
var handleRegIdRegistration = function (registrationId, regIdLocalKey) {
	if (registrationId == null || registrationId == "") {
		var errorMessage = null;
		if (chrome.runtime.lastError) {
			errorMessage = chrome.runtime.lastError.message;
		}
		if (!errorMessage) {
			errorMessage = "unknown error";
		}
		console.error("Error getting key: " + errorMessage);
		return { "success": false };
	} else {
		console.log(`Got reg id ${regIdLocalKey}:` + getSensitiveLogPreview(registrationId));
		var result = { "success": true };
		if (localStorage[regIdLocalKey] == registrationId) {
			result.sameRegId = true;
		}
		localStorage[regIdLocalKey] = registrationId;
		return result;
	}
}
var setLocalDeviceNameFromDeviceList = function () {
	if (!devices) {
		return;
	}
	if (!localStorage.deviceId) {
		return;
	}
	var myDevice = devices.find(device => device.deviceId == localStorage.deviceId);
	if (!myDevice) {
		return;
	}
	localStorage.deviceName = myDevice.deviceName;
}
const getInstanceIdToken = senderId => {
	return new Promise((resolve, reject) => {
		chrome.instanceID.getToken({ "authorizedEntity": senderId, "scope": "GCM" }, resolve);
	});
}
//const fcmClient = new FCMClientImplementation();
/*fcmClient.getTokens()
	.then(result=>{
		console.log("Got FCM Tokens!",result);
	});*/
/*fcmClient.onMessage(payload=>{
	payload.pushHandler = "fcm";
	handlePushMessage(payload);
});*/
const initPushTokens = async () => {
	const registrationId1 = await getInstanceIdToken("596310809542");
	//const registrationId2 = await fcmClient.getToken("737484412860");
	const registrationId2 = await getInstanceIdToken("737484412860");

	var resultRegId1 = handleRegIdRegistration(registrationId1, "regIdLocal");
	if (!resultRegId1.success) return;

	var resultRegId2 = handleRegIdRegistration(registrationId2, "regIdLocal2");
	if (!resultRegId2.success) return;

	setLocalDeviceNameFromDeviceList();
	if (devices && resultRegId1.sameRegId && resultRegId2.sameRegId && localStorage.deviceId) {
		return;
	}

	try {
		const result = await registerDevice();
		if (!result?.sameDeviceId) {
			await refreshDevices();
		}
		setLocalDeviceNameFromDeviceList();
		if (!localStorage.deviceName && localStorage.deviceId) {
			await refreshDevices();
			setLocalDeviceNameFromDeviceList();
		}
	} catch (error) {
		console.log("initPushTokens registration failed: " + error);
	}
};
initPushTokens();
/*chrome.instanceID.getToken({"authorizedEntity":"596310809542","scope":"GCM"},registrationId1=>{
	var resultRegId1 = handleRegIdRegistration(registrationId1,"regIdLocal");
	if(resultRegId1.success){
		chrome.instanceID.getToken({"authorizedEntity":"737484412860","scope":"GCM"},registrationId2=>{
			var resultRegId2 = handleRegIdRegistration(registrationId2,"regIdLocal2");
			if(resultRegId2.success){
				setLocalDeviceNameFromDeviceList();
				if(!devices || !resultRegId1.sameRegId || !resultRegId2.sameRegId || !localStorage.deviceId){
					registerDevice(function(result){
						if(!result.sameDeviceId){
							refreshDevices();	
						}else{
							setLocalDeviceNameFromDeviceList();
						}
					});	
				}
			}
		});		
	}
});*/

/*chrome.gcm.register(["596310809542","737484412860"],function(registrationId) {
	if (registrationId == null || registrationId == "") {
		var errorMessage = null;
		if(chrome.runtime.lastError){
			errorMessage = chrome.runtime.lastError.message;
		}
		if(!errorMessage){
			errorMessage = "unknown error";
		}
		console.log("Error getting key: " + errorMessage);
	} else {
		console.log("Got key: " + registrationId);
		localStorage.regIdLocal = registrationId;
		registerDevice(function(){
			refreshDevices();
		});
	}
});*/


var devicesJson = localStorage["devices"];

var devices = [];
if (devicesJson && devicesJson != "undefined") {
	try {
		devices = JSON.parse(devicesJson);
	} catch (error) {
		console.log("Error parsing stored devices in join.js");
		console.log(error);
	}
} else {
}


var getDeviceById = function (deviceId) {
	for (var i = 0; i < devices.length; i++) {
		var device = devices[i];
		if (device.deviceId == deviceId) {
			return device;
		}
	}
}
var setDevices = async function (devicesToSet) {
	UtilsVoice.resetDeviceEntities();
	devices = [];
	if (devicesToSet) {
		for (var i = 0; i < devicesToSet.length; i++) {
			var device = devicesToSet[i];
			if (!joindevices.groups.deviceGroups.isDeviceInGroup(device)) continue;
			if ((!localStorage.deviceId || localStorage.deviceId != device.deviceId)) {
				devices.push(device);
			} else {
				devices.unshift(device);
			}
		}
		console.log("After setting devices: " + localStorage.deviceId);
		if (localStorage.deviceId) {
			devicesToSet.doForAll(function (deviceToSet) {
				if (localStorage.deviceId == deviceToSet.deviceId) {
					localStorage.deviceName = deviceToSet.deviceName;
				}
			});
		}
		if (localStorage.deviceName) {
			devices.doForAll(function (storedDevice) {
				if (storedDevice.deviceName == localStorage.deviceName && storedDevice.deviceId != localStorage.deviceId) {

					/*var findRightName = () => {
						var baseName = "Chrome";
						var name = baseName;
						var i = 0;
						while(true){
							if(i>100){
								return baseName;
							}
							if(i > 0){
								name = baseName + " " + i;
							}			
							var otherWithSameName = devices.find(device=>device.deviceId != localStorage.deviceId && device.deviceName == name);			
							if(!otherWithSameName){
								return name;
							}
							i++;
						}
					}*/
					var newName = prompt("One of your Join devices is already named '" + localStorage.deviceName + "'. What do you want to name this Chrome installation?");
					var message = "You can always rename your devices by long-touching them in the Android app.";
					if (newName) {
						var oldName = localStorage.deviceName;
						localStorage.deviceName = newName;
						var localDevice = devices.first(function (device) { return device.deviceId == localStorage.deviceId; });
						if (localDevice) {
							localDevice.deviceName = newName;
						}
						doPostWithAuth(joinserver + "registration/v1/renameDevice/?deviceId=" + localStorage.deviceId + "&newName=" + encodeURIComponent(newName), { "deviceId": localStorage.deviceId, "newName": newName }, function (result) {
							if (!result || !result.success) {
								localStorage.deviceName = oldName;
								if (localDevice) {
									localDevice.deviceName = oldName;
								}
								alert("Error renaming: " + (result && result.errorMessage ? result.errorMessage : JSON.stringify(result)));
								return;
							}
							alert("This device was named " + newName + ". " + message);
						}, function (error) {
							localStorage.deviceName = oldName;
							if (localDevice) {
								localDevice.deviceName = oldName;
							}
							alert("Error renaming: " + JSON.stringify(error));
						});
					} else {
						alert(message);
					}
				}
			});
		}
		devices.removeIf(device => device.deviceType == DEVICE_TYPE_GROUP);
		var groups = joindevices.groups.deviceGroups.getGroups(devices);
		for (var i = 0; i < groups.length; i++) {
			var group = groups[i];
			var deviceFromGroup = {
				"deviceId": "group." + group.id,
				"deviceName": group.name,
				"deviceType": DEVICE_TYPE_GROUP
			};
			devices.push(deviceFromGroup);
		}
		setLocalDeviceNameFromDeviceList();
		UtilsObject.sort(devices, true, device => device.deviceId != localStorage.deviceId, device => device.deviceId.indexOf("group") >= 0, device => device.deviceId.indexOf("share") >= 0, device => device.deviceType, device => device.deviceName);
		localStorage["devices"] = JSON.stringify(devices);
	}
	await updateContextMenu();
	refreshDevicesPopup();
}
function directCopy(str, setLastClipboard) {
	if (!str) {
		return;
	}
	if (setLastClipboard) {
		lastClipboard = str;
	}
	document.oncopy = function (event) {
		event.clipboardData.setData("Text", str);
		event.preventDefault();
	};
	document.execCommand("Copy");
	document.oncopy = undefined;
	console.log("Set clipboard to: " + getSensitiveLogPreview(str));
}
function getClipboard(callback) {

	document.onpaste = function (event) {
		var clipboardData = event.clipboardData.getData("Text");
		event.preventDefault();
		callback(clipboardData);
	};
	document.execCommand("paste");
	document.onpaste = undefined;
}
function getClipboardAsync() {
	return new Promise((resolve, reject) => {
		getClipboard(clipboard => resolve(clipboard));
	});
}
function doForDevices(action) {
	if (!devices || devices.length == 0) {
		return;
	}
	for (var i = 0; i < devices.length; i++) {
		var device = devices[i];
		action(device);
	}
}

var sentLastAutoClipboard = false;
var lastClipboard = null;
var autoCheckClipboard = getAutoClipboard();
var checkClipboardRecursive = function () {
	if (!autoCheckClipboard) {
		return;
	}
	getClipboard(function (clipboardData) {

		const send = () => {
			if (lastClipboard != clipboardData) {
				lastClipboard = clipboardData;
				if (!sentLastAutoClipboard) {
					var devicesToSendClipboard = getDeviceIdsToSendAutoClipboard();
					if (devicesToSendClipboard.length > 0) {
						var gcmParams = {};
						gcmParams[GCM_PARAM_TIME_TO_LIVE] = 0;
						var params = { "deviceIds": devicesToSendClipboard, "text": encrypt(clipboardData) };
						var gcmAutoClipboard = new GCMAutoClipboard();
						gcmAutoClipboard.text = params.text;
						new DeviceIdsAndDirectDevices(devicesToSendClipboard).send(function (serverDeviceIds, callback, callbackError) {
							params.deviceIds = serverDeviceIds;
							doPostWithAuth(joinserver + "messaging/v1/sendAutoClipboard/", params, callback, callbackError);
						}, gcmAutoClipboard, gcmParams, function (result) {
							console.log("Sent clipboard automatically: " + getSensitiveLogPreview(result));
						}, function (error) {
							console.log("Error: " + error);
						});
						return true;
					}
				}
			}
			return false;
		};
		sentLastAutoClipboard = send();
	});
	if (autoCheckClipboard) {
		setTimeout(checkClipboardRecursive, 2000);
	}
}
var handleAutoClipboard = function () {
	if (getAutoClipboard()) {
		autoCheckClipboard = true;
		getClipboard(function (clipboardData) {
			lastClipboard = clipboardData;
			checkClipboardRecursive();
		});
	} else {
		autoCheckClipboard = false;
	}
}
handleAutoClipboard();



var sanitizeHTML = DOMPurify.sanitize;
async function sanitizeAndCreateLinksInHtml(text) {
	return sanitizeHTML(back.Autolinker.link(text, { "stripPrefix": false }));
}
var getPushesWhileAway = async () => {
	var googleDriveManager = new GoogleDriveManager();
	try {
		const device = await googleDriveManager.getMyDevicePushes(true, true);
		if (!device || !device.pushes || device.pushes.length == 0) {
			console.log("No stored pushes to process");
			return;
		}
		UtilsObject.sort(device.pushes, true, push => push.date);
		console.log(device.pushes);
		for (var push of device.pushes) {
			var gcm = new GCMPush();
			push.receiveIfNewer = true;
			gcm.push = push;
			gcm.execute();
		}
		return googleDriveManager.clearDevicePushes(device, true);
	} catch (error) {
		if (UtilsObject.isMissingDriveFileError(error)) {
			console.log("No stored pushes file found on Google Drive yet.");
			return;
		}
		console.warn(error);
	}
};
setTimeout(getPushesWhileAway, 1000);

if (devices) {
	devices.forEach(device => UtilsDevices.setCanContactViaLocalNetwork(device, false));
	new GCMLocalNetworkTestRequest().sendToCompatibleDevices();
}
var v2Stuff = {
	EventBus: EventBus
}

/*UtilsObject.wait(2000,function(timeOut){
   // clearTimeout(timeOut);
})
.then(()=>{

	var test = "aaaa";
	console.log(`done waiting ${test}`)
})*/
/*var result = Dialog.showInputDialog({
	text:"Something",
	title:"Input stuffs",
	subtitle:"I said stufff",
	placeholder:"write stuff man"
})()
.then(function(result){
	console.log("Input result");
	console.log(result);
}).catch(UtilsObject.ignoreError);*/
/*var result = Dialog.showMultiChoiceDialog({
	items:[
		{id:0,text:"First"},
		{id:1,text:"Second"},
		{id:2,text:"Third"},
		{id:2,text:"Fourth"},
	],
	title:"Select One"
})()
.then(function(result){
	console.log("Input result");
	console.log(result);
}).catch(UtilsObject.ignoreError);*/
/*var googleDriveManager = new GoogleDriveManager();
	console.log("Finding file");*/
/*googleDriveManager.getFile({
	folderName:"Join Files/From Nexus 5X",
	fileName:"faqold.png"
}).then(function(file){
	console.log("Found file");
	console.log(file);
}).catch(function(error){
	console.log("Error: " + error);
});*/
/*googleDriveManager.getFolderId({
	folderName: "Join Files/blabla"
}).then(function(result){
	console.log("FOLDER RESULT");
	console.log(result)
}).catch(function(error){
	console.log("FOLDER ERROR");
	console.log(error)
});*/
/*var promise = googleDriveManager.uploadContent({
	folderName:"Join Files/From Nexus 5X",
	fileName:"stuff.json",
	content:{"hello":"bye"},
	overwrite:false
}).then(function(file){
	console.log("Uploaded file");
	console.log(file);
}).catch(function(error){
	console.log("Didn't upload file: " + error);
});*/
//Dialog.showEmojiDialog()();
/*navigator.webkitTemporaryStorage.requestQuota(1024*1024, function(grantedBytes) {
  window.requestFileSystem(PERSISTENT, grantedBytes, function(){},  function(){});
}, function(e) {
  console.log('Error', e);
});*/
//UtilsVoice.doVoiceCommand("screenshot my chrome");

/*UtilsVoice.doVoiceCommand(devices,prompt=>console.log(prompt),"locate my lg g4")
.then(result=>{
	console.log("Done recognizing!")
	console.log(result);
	result.command.func(result.device.deviceId,true);
})
.catch(error=>{
	console.log("Error recognizing!")
	console.log(error);
});
*/
//back.Dialog.showRequestMicDialog()().then(result=>console.log("Got mic: " + result));

// const testingEventBus = {
// 	onTest1: (test1) => console.log("tested 1", test1),
// 	onTest2: (test2) => {
// 		console.log("tested 2", test2)
// 		eventBusCrossContext.unregister(testingEventBus);
// 	},
// }
// const eventBusCrossContext = new EventBusCrossContext();
// eventBusCrossContext.register(testingEventBus);