gratis - habilitar javascript en chrome en windows
Verifica si el usuario tiene una extensión de Chrome instalada (13)
Chrome ahora tiene la capacidad de enviar mensajes desde el sitio web a la extensión.
Entonces, en la extensión background.js (content.js no funcionará) agrega algo como:
chrome.runtime.onMessageExternal.addListener(
function(request, sender, sendResponse) {
if (request) {
if (request.message) {
if (request.message == "version") {
sendResponse({version: 1.0});
}
}
}
return true;
});
Esto le permitirá hacer una llamada desde el sitio web:
var hasExtension = false;
chrome.runtime.sendMessage(extensionId, { message: "version" },
function (reply) {
if (reply) {
if (reply.version) {
if (reply.version >= requiredVersion) {
hasExtension = true;
}
}
}
else {
hasExtension = false;
}
});
Luego puede verificar la variable hasExtension. El único inconveniente es que la llamada es asincrónica, por lo que debe solucionarlo de alguna manera.
Editar: como se menciona a continuación, deberá agregar una entrada al archivo manifest.json que enumere los dominios que pueden enviar mensajes a su complemento. P.ej:
"externally_connectable": {
"matches": ["*://localhost/*", "*://your.domain.com/*"]
},
Estoy en el proceso de crear una extensión de Chrome, y para que todo funcione como me gustaría, necesito un script de JavaScript externo para poder detectar si un usuario tiene mi extensión instalada.
Por ejemplo: un usuario instala mi complemento y luego va a un sitio web con mi script. El sitio web detecta que mi extensión está instalada y actualiza la página en consecuencia.
es posible?
Estoy seguro de que hay una forma directa (llamar directamente a las funciones de su extensión, o al usar las clases JS para las extensiones), pero un método indirecto (hasta que surja algo mejor):
Haga que su extensión de Chrome busque un DIV u otro elemento específico en su página, con una ID muy específica.
Por ejemplo:
<div id="ExtensionCheck_JamesEggersAwesomeExtension"></div>
Haz un getElementById y configura el innerHTML como el número de versión de tu extensión o algo así. Luego puede leer los contenidos de ese lado del cliente.
Sin embargo, una vez más, debe usar un método directo si hay uno disponible.
EDIT: método directo encontrado !!
Utilice los métodos de conexión que se encuentran aquí: https://developer.chrome.com/extensions/extension#global-events
No probado, pero deberías poder hacer ...
var myPort=chrome.extension.connect(''yourextensionid_qwerqweroijwefoijwef'', some_object_to_send_on_connect);
Hay otro método que se muestra en esta publicación de Grupos de Google . En resumen, podría intentar detectar si el icono de extensión se carga correctamente. Esto puede ser útil si la extensión que está buscando no es suya.
La página web interactúa con la extensión a través de la secuencia de comandos de fondo.
manifest.json:
"background": {
"scripts": ["background.js"],
"persistent": true
},
"externally_connectable": {
"matches": ["*://(domain.ext)/*"]
},
background.js:
chrome.runtime.onMessageExternal.addListener(function(msg, sender, sendResponse) {
if ((msg.action == "id") && (msg.value == id))
{
sendResponse({id : id});
}
});
page.html:
<script>
var id = "some_ext_id";
chrome.runtime.sendMessage(id, {action: "id", value : id}, function(response) {
if(response && (response.id == id)) //extension installed
{
console.log(response);
}
else //extension not installed
{
console.log("Please consider installig extension");
}
});
</script>
Muchas de las respuestas hasta ahora son solo de Chrome o incurren en una multa por sobrecarga HTTP. La solución que estamos usando es un poco diferente:
1. Agregue un nuevo objeto a la lista del manifiesto content_scripts de la siguiente manera:
{
"matches": ["https://www.yoursite.com/*"],
"js": [
"install_notifier.js"
],
"run_at": "document_idle"
}
Esto permitirá que el código en install_notifier.js se ejecute en ese sitio (si aún no tenía permisos allí).
2. Envíe un mensaje a cada sitio en la clave de manifiesto anterior.
Agregue algo como esto a install_notifier.js (tenga en cuenta que esto está utilizando un cierre para evitar que las variables sean globales, pero eso no es estrictamente necesario):
// Dispatch a message to every URL that''s in the manifest to say that the extension is
// installed. This allows webpages to take action based on the presence of the
// extension and its version. This is only allowed for a small whitelist of
// domains defined in the manifest.
(function () {
let currentVersion = chrome.runtime.getManifest().version;
window.postMessage({
sender: "my-extension",
message_name: "version",
message: currentVersion
}, "*");
})();
Su mensaje podría decir cualquier cosa, pero es útil enviar la versión para que sepa a qué se enfrenta. Entonces...
3. En su sitio web, escuche ese mensaje.
Agregue esto a su sitio web en alguna parte:
window.addEventListener("message", function (event) {
if (event.source == window &&
event.data.sender &&
event.data.sender === "my-extension" &&
event.data.message_name &&
event.data.message_name === "version") {
console.log("Got the message");
}
});
Esto funciona en Firefox y Chrome, y no incurre en sobrecarga de HTTP ni manipula la página.
Otra posible solución si posee el sitio web es utilizar la instalación en línea .
if (chrome.app.isInstalled) {
// extension is installed.
}
Sé que esta es una vieja pregunta, pero de esta manera fue introducida en Chrome 15, así que pensé en listarla para cualquiera que esté buscando una respuesta.
Otro método es exponer un recurso accesible a través de la web , aunque esto permitirá que cualquier sitio web pruebe si su extensión está instalada.
Supongamos que el ID de su extensión es aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa , y agrega un archivo (por ejemplo, una imagen de píxeles transparente) como test.png en los archivos de su extensión.
Luego, expone este archivo a las páginas web con la clave de manifiesto web_accessible_resources :
"web_accessible_resources": [
"test.png"
],
En su página web, puede intentar cargar este archivo por su URL completa (en una etiqueta <img> , a través de XHR o de cualquier otra forma):
chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/test.png
Si el archivo se carga, entonces la extensión está instalada. Si hay un error al cargar este archivo, entonces la extensión no está instalada.
// Code from https://groups.google.com/a/chromium.org/d/msg/chromium-extensions/8ArcsWMBaM4/2GKwVOZm1qMJ
function detectExtension(extensionId, callback) {
var img;
img = new Image();
img.src = "chrome-extension://" + extensionId + "/test.png";
img.onload = function() {
callback(true);
};
img.onerror = function() {
callback(false);
};
}
Nota: si hay un error al cargar este archivo, dicho error de la pila de red aparecerá en la consola sin posibilidad de silenciarlo. Cuando Chromecast utilizó este método, causó bastante controversia debido a esto; con la eventual solución muy fea de simplemente incluir en la lista negra errores muy específicos de Dev Tools por parte del equipo de Chrome.
Nota importante: este método no funcionará en WebExtensions de Firefox. Los recursos accesibles a través de la web exponen intrínsecamente la extensión a la toma de huellas dactilares, ya que la URL es predecible al conocer la ID. Firefox decidió cerrar ese agujero asignando una URL aleatoria específica de la instancia a recursos accesibles en la web:
Los archivos estarán disponibles usando una URL como:
moz-extension://<random-UUID>/<path/to/resource>Este UUID se genera aleatoriamente para cada instancia del navegador y no es la identificación de su extensión. Esto evita que los sitios web tomen las huellas dactilares de las extensiones que un usuario ha instalado.
Sin embargo, aunque la extensión puede usar runtime.getURL() para obtener esta dirección, no puede codificarla en su sitio web.
Pensé que compartiría mi investigación sobre esto. Necesitaba poder detectar si se instaló una extensión específica para algunos archivos: /// para trabajar. Me encontré con este artículo blog.kotowicz.net/2012/02/intro-to-chrome-addons-hacking.html Explicaba un método para obtener el manifiesto.json de una extensión.
Ajusté un poco el código y se me ocurrió:
function Ext_Detect_NotInstalled(ExtName,ExtID) {
console.log(ExtName + '' Not Installed'');
if (divAnnounce.innerHTML != '''')
divAnnounce.innerHTML = divAnnounce.innerHTML + "<BR>"
divAnnounce.innerHTML = divAnnounce.innerHTML + ''Page needs '' + ExtName + '' Extension -- to intall the LocalLinks extension click <a href="https://chrome.google.com/webstore/detail/locallinks/'' + ExtID +''">here</a>'';
}
function Ext_Detect_Installed(ExtName,ExtID) {
console.log(ExtName + '' Installed'');
}
var Ext_Detect = function(ExtName,ExtID) {
var s = document.createElement(''script'');
s.onload = function(){Ext_Detect_Installed(ExtName,ExtID);};
s.onerror = function(){Ext_Detect_NotInstalled(ExtName,ExtID);};
s.src = ''chrome-extension://'' + ExtID + ''/manifest.json'';
document.body.appendChild(s);
}
var is_chrome = navigator.userAgent.toLowerCase().indexOf(''chrome'') > -1;
if (is_chrome==true)
{
window.onload = function() { Ext_Detect(''LocalLinks'',''jllpkdkcdjndhggodimiphkghogcpida'');};
}
Con esto, debería poder usar Ext_Detect (ExtensionName, ExtensionID) para detectar la instalación de cualquier cantidad de extensiones.
Podría hacer que la extensión establezca una cookie y hacer que los sitios web de JavaScript verifiquen si esa cookie está presente y actualícela en consecuencia. Este y probablemente la mayoría de los otros métodos mencionados aquí pueden ser inventados por el usuario, a menos que intente que la extensión cree cookies personalizadas en función de marcas de tiempo, etc., y haga que su aplicación las analice en el servidor para ver si realmente es un usuario con el extensión o alguien que pretende tenerlo modificando sus cookies.
Si tienes control sobre la extensión de Chrome, puedes probar lo que hice:
// Inside Chrome extension
var div = document.createElement(''div'');
div.setAttribute(''id'', ''myapp-extension-installed-div'');
document.getElementsByTagName(''body'')[0].appendChild(div);
Y entonces:
// On web page that needs to detect extension
if ($(''#myapp-extension-installed-div'').length) {
}
Se siente un poco raro, pero no pude hacer funcionar los otros métodos, y me preocupa que Chrome cambie su API aquí. Es dudoso que este método deje de funcionar en el corto plazo.
Su extensión podría interactuar con el sitio web (por ejemplo, cambiar variables) y su sitio web podría detectar esto.
Pero debería haber una mejor manera de hacer esto. Me pregunto cómo lo está haciendo Google en su galería de extensiones (las aplicaciones ya instaladas están marcadas).
Editar:
La galería utiliza la función chrome.management.get . Ejemplo:
chrome.management.get("mblbciejcodpealifnhfjbdlkedplodp", function(a){console.log(a);});
Pero solo puede acceder al método desde páginas con los permisos adecuados.
También podría usar un método de navegador cruzado de lo que he usado. Utiliza el concepto de agregar un div.
en su script de contenido (cada vez que se carga el script, debería hacerlo)
if ((window.location.href).includes(''*myurl/urlregex*'')) {
$(''html'').addClass(''ifextension'');
}
en su sitio web afirma algo así como,
if (!($(''html'').hasClass(''ifextension'')){}
Y arroja el mensaje apropiado.
Usé el método de cookie:
En mi archivo manifest.js, incluí un script de contenido que solo se ejecuta en mi sitio:
"content_scripts": [
{
"matches": [
"*://*.mysite.co/*"
],
"js": ["js/mysite.js"],
"run_at": "document_idle"
}
],
en mi js / mysite.js tengo una línea:
document.cookie = "extension_downloaded=True";
y en mi página index.html busco esa cookie.
if (document.cookie.indexOf(''extension_downloaded'') != -1){
document.getElementById(''install-btn'').style.display = ''none'';
}