PhoneGap: detecta si se ejecuta en el navegador de escritorio

Estoy desarrollando una aplicación web que usa PhoneGap: Build para una versión móvil y quiero tener una única base de código para las versiones de 'escritorio' y móviles. Quiero poder detectar si las llamadas de PhoneGap funcionarán (es decir, si el usuario de un dispositivo móvil admitirá PhoneGap).

He buscado y no puedo creer que no haya una forma sencilla de hacer esto. Mucha gente ha ofrecido sugerencias;

• http://www.sencha.com/forum/showthread.php?144127-Checking-if-running-in-PhoneGap-or-Mobile-Web-Browser
• http://groups.google.com/group/phonegap/browse_thread/thread/322e80bd41bb1a54/a421300eb2a2029f?lnk=gst&q=detect+desktop#a421300eb2a2029f
• http://groups.google.com/group/phonegap/browse_thread/thread/8a95dfeb0f313792/3ff10d8f35211739?lnk=gst&q=detect+desktop+browser#3ff10d8f35211739

Ninguno de los cuales funciona, a menos que elimine el archivo PhoneGap Javascript de la versión de escritorio de la aplicación, lo que frustra mi objetivo de tener una base de código.

Hasta ahora, la única solución que he encontrado es el rastreo del agente de usuario / navegador, pero esto no es robusto por decir lo menos. ¡Cualquier solución mejor bienvenida!

EDITAR: Una solución ligeramente mejor es intentar llamar a una función PhoneGap después de un pequeño tiempo de espera; si no funciona, suponga que el usuario está en un navegador web de escritorio.

Yo uso este código:

if (navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry|IEMobile)/)) {
  document.addEventListener("deviceready", onDeviceReady, false);
} else {
  onDeviceReady(); //this is the browser
}

ACTUALIZAR

Hay muchas otras formas de detectar si phonegap se está ejecutando en un navegador o no, aquí hay otra gran opción:

var app = document.URL.indexOf( 'http://' ) === -1 && document.URL.indexOf( 'https://' ) === -1;
if ( app ) {
    // PhoneGap application
} else {
    // Web page
}  

como se ve aquí: Detecta entre un navegador móvil o una aplicación PhoneGap

Escribí una publicación al respecto hace unos días. Esta es la mejor solución que puede encontrar (hasta que PhoneGap lance algo, tal vez o no), es breve, simple y perfecta (la he comprobado de todas las formas y plataformas posibles).

Esta función hará el trabajo en el 98% de los casos.

/**
 * Determine whether the file loaded from PhoneGap or not
 */
function isPhoneGap() {
    return (window.cordova || window.PhoneGap || window.phonegap) 
    && /^file:\/{3}[^\/]/i.test(window.location.href) 
    && /ios|iphone|ipod|ipad|android/i.test(navigator.userAgent);
}

if ( isPhoneGap() ) {
    alert("Running on PhoneGap!");
} else {
    alert("Not running on PhoneGap!");
}

Para completar el otro 2% de los casos, siga estos pasos (implica un ligero cambio en el código nativo):

Cree un archivo llamado __phonegap_index.html , con la fuente:

<!-- __phonegap_index.html -->
<script type="text/javascript">
    function isPhoneGap() {
        //the function's content is as described above
    }

    //ensure the 98% that this file is called from PhoneGap.
    //in case somebody accessed this file directly from the browser.
    if ( isPhoneGap() )
        localStorage.setItem("isPhoneGap","1");

    //and redirect to the main site file.
    window.location = "index.html";
</script>

Ahora, en nativo, simplemente cambie la página de inicio de index.html a __phonegap_index.html en todas sus plataformas PhoneGap. Digamos que el nombre de mi proyecto es un ejemplo , los archivos que necesita cambiar son (como para PhoneGap versión 2.2.0):

• iOS -CordovaLibApp/AppDelegate.m
• Android -src/org/apache/cordova/example/cordovaExample.java
• Windows 8 -example/package.appxmanifest
• BlackBerry -www/config.xml
• WebOS -framework/appinfo.json
• Bada - src/WebForm.cpp(línea 56)
• Window Phone 7 : no tengo idea de dónde (¿alguien todavía está desarrollando en esa plataforma?)

Finalmente, puede usarlo en cualquier lugar de su sitio, si se ejecuta en PhoneGap o no:

if ( localStorage.getItem("isPhoneGap") ) {
    alert("Running on PhoneGap!");
} else {
    alert("Not running on PhoneGap!");
}

Espero eso ayude. :-)

Sé que ha sido respondida hace un tiempo, pero "PhoneGap.available" ya no existe. Deberías usar:

if (window.PhoneGap) {
  //do stuff
}

o desde 1.7, prefiera:

if (window.cordova) {
  //do stuff
}

EDITAR 2019: como se dijo en los comentarios, esto solo funciona si no incluye cordova lib en la compilación de su navegador de escritorio. Y, por supuesto, es una buena práctica incluir solo los archivos javascript / html / css mínimos estrictos para cada dispositivo al que se dirija

La forma más confiable que encontramos para saber si estamos en una aplicación cordova / phonegap es modificar el agente de usuario de la aplicación cordova usando esta configuración AppendUserAgent .

Además config.xml:

<preference name="AppendUserAgent" value="Cordova" />

Luego llame:

var isCordova = navigator.userAgent.match(/Cordova/i))

¿Por qué?

1. window.cordovay document.addEventListener('deviceready', function(){});están sujetos a condiciones de carrera
2. navigator.standaloneno funciona cuando <content src="index.html" />es un sitio web (ej .: <content src="https://www.example.com/index.html" />o con cordova-plugin-remote-injection )
3. Intentar incluir agentes de usuario en la lista blanca para adivinar si se trata de un navegador real es muy complicado. Los navegadores de Android suelen ser vistas web personalizadas.

Creo que esto es lo más simple: var isPhoneGap = (location.protocol == "file:")

EDITAR Para algunas personas que no funcionó. Entonces podrías intentarlo (no lo he probado)

var isPhoneGap = ! /^http/.test(location.protocol);

Esto funciona para mí (ejecutando 1.7.0)

if (window.device) {
  // Running on PhoneGap
}

Probado en Chrome y Safari de escritorio.

Al igual que el póster original, estoy usando el servicio de compilación de phonegap. Después de dos días y casi 50 compilaciones de prueba, he encontrado una solución elegante que funciona muy bien para mí.

No pude usar UA sniffing porque quería probar y ejecutar en navegadores móviles. Originalmente me había decidido por la técnica bastante funcional de cobberboy. Esto no funcionó para mí porque el retraso / tiempo de espera de "howPatientAreWe: 10000" era demasiado molesto para el desarrollo en el navegador. Y configurarlo más bajo ocasionalmente fallaría la prueba en el modo de aplicación / dispositivo. Tenía que haber otra manera...

El servicio de compilación de phonegap requiere que el phonegap.jsarchivo se omita de su repositorio de código antes de enviar los archivos de su aplicación al servicio. Por lo tanto, puedo probar su existencia para determinar si se ejecuta en un navegador o en una aplicación.

Otra advertencia, también estoy usando jQueryMobile, por lo que tanto jQM como phonegap tuvieron que inicializarse antes de que pudiera comenzar cualquier script personalizado. El siguiente código se coloca al comienzo de mi archivo index.js personalizado para la aplicación (después de jQuery, antes de jQM). Además, los documentos de compilación de phonegap dicen que se coloque <script src="phonegap.js"></script>en algún lugar del HTML. Lo dejo completamente y lo cargo usando $ .getScript () para probar su existencia.

isPhoneGap = false;
isPhoneGapReady = false;
isjQMReady = false;

$.getScript("phonegap.js")
.done(function () {
    isPhoneGap = true;
    document.addEventListener("deviceready", function () {
        console.log("phonegap ready - device/app mode");
        isPhoneGapReady = true;
        Application.checkReadyState();
    }, false);
})
.fail(function () {
    console.log("phonegap load failed - browser only");
    isPhoneGapReady = true;
    Application.checkReadyState();
});

$(document).bind("mobileinit", function () {
    Application.mobileInit();
    $(document).one("pageinit", "#Your_First_jQM_Page", function () {
        isjQMReady = true;
        Application.checkReadyState();
    });
});

Application = {
    checkReadyState: function () {
        if (isjQMReady && isPhoneGapReady) {
            Application.ready();
        }
    },
    mobileInit: function () {
        // jQM initialization settings go here
        // i.e. $.mobile.defaultPageTransition = 'slide';
    },
    ready: function () {
        // Both phonegap (if available) and jQM are fired up and ready
        // let the custom scripting begin!
    }
}

Curiosamente, muchas respuestas, pero no incluyen estas tres opciones:

1: cordova.js establecerá el objeto cordova en el ámbito global. Si está allí, lo más probable es que se esté ejecutando en un ámbito de Cordova.

var isCordovaApp = !!window.cordova;

2 - Cordova ejecutará su aplicación como abriría un documento HTML desde su escritorio. En lugar del protocolo HTTP, utilizará FILE. Detectar esto le dará la oportunidad de asumir que su aplicación se cargó localmente.

var isCordovaApp = document.URL.indexOf('http://') === -1
  && document.URL.indexOf('https://') === -1;

3 - Utilice el evento de carga del script cordova para detectar el contexto. El script incluido se puede eliminar fácilmente en el proceso de compilación o la carga del script simplemente fallará en un navegador. Para que no se establezca esta variable global.

<script src="../cordova.js" onload="javascript:window.isCordovaApp = true;"></script>

El crédito es para Damien Antipa de Adobe

Yo uso este método:

debug = (window.cordova === undefined);

debugestará trueen el entorno del navegador, falseen el dispositivo.

Esto parece ser viable y lo he usado en producción:

if (document.location.protocol == "file:") {
    // file protocol indicates phonegap
    document.addEventListener("deviceready", function() { $(initInternal);} , false);
}
else {
    // no phonegap, start initialisation immediately
    $(initInternal);
}

Fuente: http://tqcblog.com/2012/05/09/detecting-phonegap-cordova-on-startup/

La esencia del problema es que mientras cordova.device no esté definido, su código no puede estar seguro si es porque cordova ha establecido que su dispositivo no es compatible, o si es porque cordova todavía se está preparando y deviceready se activará más tarde. (o tercera opción: cordova no se cargó correctamente).

La única solución es definir un período de espera y decidir que después de este período su código debe asumir que el dispositivo no es compatible. Me gustaría que cordova estableciera un parámetro en algún lugar para decir "Intentamos encontrar un dispositivo compatible y nos rendimos", pero parece que no existe tal parámetro.

Una vez establecido esto, es posible que desee hacer algo específico precisamente en aquellas situaciones en las que no hay un dispositivo compatible. Como ocultar enlaces al mercado de aplicaciones del dispositivo, en mi caso.

He reunido esta función que debería cubrir prácticamente todas las situaciones. Le permite definir un controlador listo para el dispositivo, un controlador que nunca está listo y un tiempo de espera.

//Deals with the possibility that the code will run on a non-phoneGap supported
//device such as desktop browsers. Gives several options including waiting a while
//for cordova to load after all.
//In:
//onceReady (function) - performed as soon as deviceready fires
//patience 
//  (int) - time to wait before establishing that cordova will never load
//  (boolean false) - don't wait: assume that deviceready will never fire
//neverReady 
//  (function) - performed once it's established deviceready will never fire
//  (boolean true) - if deviceready will never fire, run onceReady anyhow
//  (boolean false or undefined) - if deviceready will never fire, do nothing
function deviceReadyOrNot(onceReady,patience,neverReady){

    if (!window.cordova){
            console.log('Cordova was not loaded when it should have been')
            if (typeof neverReady == "function"){neverReady();}
        //If phoneGap script loaded...
        } else {
            //And device is ready by now...
            if  (cordova.device){
                callback();
            //...or it's loaded but device is not ready
            } else {
                //...we might run the callback after
                if (typeof patience == "number"){
                    //Run the callback as soon as deviceready fires
                    document.addEventListener('deviceready.patience',function(){
                        if (typeof onceReady == "function"){onceReady();}
                    })
                    //Set a timeout to disable the listener
                    window.setTimeout(function(){
                        //If patience has run out, unbind the handler
                        $(document).unbind('deviceready.patience');
                        //If desired, manually run the callback right now
                        if (typeof neverReady == 'function'){neverReady();}
                    },patience);
                //...or we might just do nothing
                } else {
                    //Don't bind a deviceready handler: assume it will never happen
                    if (typeof neverReady == 'function'){neverReady();} 
                    else if (neverReady === true){onceReady();} 
                    else {
                       //Do nothing
                    }
                }
            }
    }

}

La forma en que lo estoy haciendo es usando una variable global que está sobrescrita por una versión de cordova.js solo para navegador. En su archivo html principal (normalmente index.html) tengo los siguientes scripts que dependen del orden:

    <script>
        var __cordovaRunningOnBrowser__ = false
    </script>
    <script src="cordova.js"></script> <!-- must be included after __cordovaRunningOnBrowser__ is initialized -->
    <script src="index.js"></script> <!-- must be included after cordova.js so that __cordovaRunningOnBrowser__ is set correctly -->

Y por dentro cordova.jstengo simplemente:

__cordovaRunningOnBrowser__ = true

Al compilar para un dispositivo móvil, no se usará cordova.js (y en su lugar se usará el archivo cordova.js específico de la plataforma), por lo que este método tiene la ventaja de ser 100% correcto independientemente de los protocolos, agentes de usuario o biblioteca variables (que pueden cambiar). Puede haber otras cosas que debería incluir en cordova.js, pero todavía no sé cuáles son.

Otra forma, basada en la solución de SlavikMe:

Simplemente use un parámetro de consulta pasado a index.htmldesde su fuente PhoneGap. Es decir, en Android, en lugar de

super.loadUrl("file:///android_asset/www/index.html");

utilizar

super.loadUrl("file:///android_asset/www/index.html?phonegap=1");

SlavikMe tiene una gran lista sobre dónde hacer esto en otras plataformas.

Entonces index.htmlpuedes simplemente hacer esto:

if (window.location.href.match(/phonegap=1/)) {
  alert("phonegap");
}
else {
  alert("not phonegap");
}

Para mantener una base de código, lo que interesa es la "plataforma" en la que se ejecuta el código. Para mí, esta "plataforma" puede ser tres cosas diferentes:

• 0: navegador de computadora
• 1: navegador móvil
• 2: phonegap / cordova

La forma de verificar la plataforma:

var platform;
try {
 cordova.exec(function (param) {
   platform = 2;
  }, function (err) {}, "Echo", "echo", ["test"]);
} catch (e) {
  platform = 'ontouchstart' in document.documentElement ? 1 : 0;
}

Nota:

• Esto debe ejecutarse solo después de que se haya cargado cordova.js (body onload (...), $ (document) .ready (...))

• 'ontouchstart' en document.documentElement estará presente en las computadoras portátiles y monitores de escritorio que tienen una pantalla táctil, por lo que informará un navegador móvil aunque sea un escritorio. Hay diferentes formas de hacer una verificación más precisa, pero la uso porque todavía se ocupa del 99% de los casos que necesito. Siempre puedes sustituir esa línea por algo más robusto.

Aarons, prueba

if (PhoneGap.available){
    do PhoneGap stuff;
}

La solución de GeorgeW está bien, pero incluso en un dispositivo real, PhoneGap.available solo es verdadero después de que se hayan cargado las cosas de PhoneGap, por ejemplo, onDeviceReady en document.addEventListener ('deviceready', onDeviceReady, false) ha sido llamado.

Antes de ese momento, si quieres saber, puedes hacer así:

runningInPcBrowser =
    navigator.userAgent.indexOf('Chrome')  >= 0 ||
    navigator.userAgent.indexOf('Firefox') >= 0

Esta solución asume que la mayoría de los desarrolladores desarrollan usando Chrome o Firefox.

Tengo el mismo problema.

Me inclino a agregar # cordova = true a la URL cargada por el cliente cordova y probar location.hash.indexOf ("cordova = true")> -1 en mi página web.

Lo siguiente funciona para mí con el PhoneGap / Cordova más reciente (2.1.0).

Cómo funciona:

• Muy simple en concepto
• Invertí la lógica de algunas de las soluciones de tiempo de espera anteriores.
• Regístrese para el evento device_ready (según lo recomendado por los documentos de PhoneGap )
  • Si el evento aún NO se ha disparado después de un tiempo de espera, vuelva a asumir un navegador.
  • Por el contrario, las otras soluciones anteriores se basan en probar alguna función de PhoneGap u otra, y ver cómo se rompe la prueba.

Ventajas:

• Utiliza el evento device_ready recomendado por PhoneGap.
• La aplicación móvil no tiene demora. Tan pronto como se active el evento device_ready, procedemos.
• Sin rastreo de usuario-agente (me gusta probar mi aplicación como un sitio web móvil, por lo que el rastreo del navegador no era una opción para mí).
• No depende de las características / propiedades de PhoneGap indocumentadas (y por lo tanto frágiles).
• Mantenga su cordova.js en su código base incluso cuando utilice un navegador de escritorio o móvil. Por lo tanto, esto responde a la pregunta del OP.
• Wytze dijo anteriormente: "Me gustaría que Córdoba estableciera un parámetro en algún lugar para decir" Intentamos encontrar un dispositivo compatible y nos rendimos ", pero parece que no existe tal parámetro". Así que proporciono uno aquí.

Desventajas:

• Los tiempos de espera son asquerosos. Pero nuestra lógica de aplicación móvil no depende de un retraso; más bien, se usa como respaldo cuando estamos en modo de navegador web.

==

Cree un nuevo proyecto PhoneGap en blanco. En el index.js de muestra proporcionado, reemplace la variable "aplicación" en la parte inferior con esto:

var app = {
    // denotes whether we are within a mobile device (otherwise we're in a browser)
    iAmPhoneGap: false,
    // how long should we wait for PhoneGap to say the device is ready.
    howPatientAreWe: 10000,
    // id of the 'too_impatient' timeout
    timeoutID: null,
    // id of the 'impatience_remaining' interval reporting.
    impatienceProgressIntervalID: null,

    // Application Constructor
    initialize: function() {
        this.bindEvents();
    },
    // Bind Event Listeners
    //
    // Bind any events that are required on startup. Common events are:
    // `load`, `deviceready`, `offline`, and `online`.
    bindEvents: function() {
        document.addEventListener('deviceready', this.onDeviceReady, false);
        // after 10 seconds, if we still think we're NOT phonegap, give up.
        app.timeoutID = window.setTimeout(function(appReference) {
            if (!app.iAmPhoneGap) // jeepers, this has taken too long.
                // manually trigger (fudge) the receivedEvent() method.   
                appReference.receivedEvent('too_impatient');
        }, howPatientAreWe, this);
        // keep us updated on the console about how much longer to wait.
        app.impatienceProgressIntervalID = window.setInterval(function areWeThereYet() {
                if (typeof areWeThereYet.howLongLeft == "undefined") { 
                    areWeThereYet.howLongLeft = app.howPatientAreWe; // create a static variable
                } 
                areWeThereYet.howLongLeft -= 1000; // not so much longer to wait.

                console.log("areWeThereYet: Will give PhoneGap another " + areWeThereYet.howLongLeft + "ms");
            }, 1000);
    },
    // deviceready Event Handler
    //
    // The scope of `this` is the event. In order to call the `receivedEvent`
    // function, we must explicity call `app.receivedEvent(...);`
    onDeviceReady: function() {
        app.iAmPhoneGap = true; // We have a device.
        app.receivedEvent('deviceready');

        // clear the 'too_impatient' timeout .
        window.clearTimeout(app.timeoutID); 
    },
    // Update DOM on a Received Event
    receivedEvent: function(id) {
        // clear the "areWeThereYet" reporting.
        window.clearInterval(app.impatienceProgressIntervalID);
        console.log('Received Event: ' + id);
        myCustomJS(app.iAmPhoneGap); // run my application.
    }
};

app.initialize();

function myCustomJS(trueIfIAmPhoneGap) {
    // put your custom javascript here.
    alert("I am "+ (trueIfIAmPhoneGap?"PhoneGap":"a Browser"));
}

Me encontré con este problema hace varios meses al comenzar nuestra aplicación, porque queríamos que fuera "browser-compatible " (entendiendo que algunas funciones se bloquearían en ese escenario: grabación de audio, brújula, etc.).

La única 100%solución (e insisto en la condición del 100%) para PRE-determinar el contexto de ejecución de la aplicación fue esta:

• inicializar una variable de "bandera" JS a verdadero, y cambiarlo a falso cuando en un contexto de toda la web;

• por lo tanto, puede usar una llamada como " willIBeInPhoneGapSometimesInTheNearFuture()" (eso es PRE-PG, por supuesto, todavía necesita un método POST-PG para verificar si puede llamar a las API de PG, pero ese es trivial).

• Entonces dices: " but how do you determine the execution context?"; la respuesta es: "tú no" (porque no creo que puedas hacerlo de manera confiable, a menos que esa gente brillante de PG lo hiciera en su código API);

• escribe un script de compilación que lo hace por usted: una base de código con dos variantes.

No es realmente una respuesta a la pregunta, pero cuando pruebo en un navegador de escritorio, simplemente establezco un valor de almacenamiento local para que el navegador cargue la aplicación a pesar de que el dispositivo ya no se enciende.

function main() {

    // Initiating the app here.
};

/* Listen for ready events from pheongap */
document.addEventListener("deviceready", main, false);

// When testing outside ipad app, use jquerys ready event instead. 
$(function() {

    if (localStorage["notPhonegap"]) {

        main();
    }
});

Ninguno de los cuales funciona, a menos que elimine el archivo PhoneGap Javascript de la versión de escritorio de la aplicación, lo que frustra mi objetivo de tener una base de código.

Otra opción sería usar fusiones carpeta de , vea la captura de pantalla a continuación.

Puede agregar archivos específicos de la plataforma / anular los predeterminados.

(debería funcionar en algunos escenarios)

En otras palabras: en lugar de detectar el navegador, simplemente no incluye ciertos archivos para la compilación de escritorio / adjunta ciertos archivos solo para iOS.

Detecta el navegador de escritorio incluso si el dispositivo de emulación está activo

Funciona en máquinas Windows y Mac. Necesito encontrar una solución para linux Ver detalles

var mobileDevice = false;
if(navigator.userAgent.match(/iPhone|iPad|iPod|Android|BlackBerry|IEMobile/))
    mobileDevice = true; 

if(mobileDevice && navigator.platform.match(/Win|Mac/i))
    mobileDevice = false; // This is desktop browser emulator

if(mobileDevice) {
    // include cordova files
}

De hecho, he encontrado que una combinación de dos de las técnicas enumeradas aquí ha funcionado mejor, en primer lugar, compruebe que se puede acceder a cordova / phonegap y compruebe si el dispositivo está disponible. Al igual que:

function _initialize() {
    //do stuff
}

if (window.cordova && window.device) {
    document.addEventListener('deviceready', function () {
      _initialize();
    }, false);
} else {
   _initialize();
}

Prueba este enfoque:

/**
 * Returns true if the application is running on an actual mobile device.
 */
function isOnDevice(){
    return navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry)/);
}

function isDeviceiOS(){
    return navigator.userAgent.match(/(iPhone)/);
}

/**
 * Method for invoking functions once the DOM and the device are ready. This is
 * a replacement function for the JQuery provided method i.e.
 * $(document).ready(...).
 */
function invokeOnReady(callback){
    $(document).ready(function(){
        if (isOnDevice()) {
            document.addEventListener("deviceready", callback, false);
        } else {
            invoke(callback);
        }
    });
}

Utilizo una combinación de lo que sugirieron GeorgeW y mkprogramming :

   if (!navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry)/)) {
      onDeviceReady();
   } else if (Phonegap.available){
      onDeviceReady();
   } else {
      console.log('There was an error loading Phonegap.')
   }

Supongo que de alguna manera no son tan diferentes, ¿verdad? Ja, ja ... no es gracioso. ¿Quién no pensó que esto no sería un problema? Aquí está la solución más simple para sus consideraciones. Envíe diferentes archivos a su servidor y luego a PhoneGap. También iría temporalmente con el http: check sugerido anteriormente.

var isMobileBrowserAndNotPhoneGap = (document.location.protocol == "http:");

Mi interés es subir la barra de navegación del navegador, así que realmente puedo eliminar la etiqueta del script aislado y presionar reconstruir [en DW] (de todos modos habrá una limpieza para la implementación, por lo que esta puede ser una de esas tareas). es una buena opción (considerando que no hay mucho más disponible) para comentar las cosas manualmente de manera eficiente con isMobileBrowserAndNotPhoneGap al presionar a PG). De nuevo, para mí, en mi situación, simplemente eliminaré la etiqueta del archivo (código aislado) que empuja hacia arriba la barra de navegación cuando es un navegador móvil (será mucho más rápido y más pequeño). [Entonces, si puede aislar el código para esa solución optimizada pero manual.]

Ligeramente modificado, pero me funciona perfectamente sin problemas.

La intención es cargar Cordova solo cuando esté en un dispositivo integrado, no en un escritorio, por lo que evito completamente Cordova en un navegador de escritorio. Probar y desarrollar la interfaz de usuario y MVVM es muy cómodo.

Pon este código, por ejemplo. en el archivo cordovaLoader.js

function isEmbedded() {
    return  
    // maybe you can test for better conditions
    //&& /^file:\/{3}[^\/]/i.test(window.location.href) && 
     /ios|iphone|ipod|ipad|android/i.test(navigator.userAgent);
}

if ( isEmbedded() )
{
   var head= document.getElementsByTagName('head')[0];
   var script= document.createElement('script');
   script.type= 'text/javascript';
   script.src= 'cordova-2.7.0.js';
   head.appendChild(script);
}

Luego, en lugar de incluir cordova javascript, incluya cordovaLoader.js

<head>
  <script src="js/cordovaLoader.js"></script>
  <script src="js/jquery.js"></script>
  <script src="js/iscroll.js"></script>
  <script src="js/knockout-2.3.0.js"></script>
</head> 

¡Facilita tu trabajo! :)

if ( "device" in window ) {
    // phonegap
} else {
    // browser
}

Solo para obtener información, en PhoneGap 3.x Hotshot de desarrollo de aplicaciones móviles

var userLocale = "en-US";
function startApp()
{
// do translations, format numbers, etc.
}
function getLocaleAndStartApp()
{
    navigator.globalization.getLocaleName (
        function (locale) {
            userLocale = locale.value;
            startApp();
        },
        function () {
            // error; start app anyway
            startApp();
        });
}
function executeWhenReady ( callback ) {
    var executed = false;
    document.addEventListener ( "deviceready", function () {
        if (!executed) {
            executed = true;
            if (typeof callback === "function") {
                callback();
            }
        }
    }, false);
    setTimeout ( function () {
        if (!executed) {
            executed = true;
            if (typeof callback === "function") {
                callback();
            }
        }
    }, 1000 );
};
executeWhenReady ( function() {
    getLocaleAndStartApp();
} );

y en el marco YASMF

https://github.com/photokandyStudios/YASMF-Next/blob/master/lib/yasmf/util/core.js#L152

Estaba intentando con los objetos de la ventana pero no funcionó porque estaba abriendo la URL remota en el InAppBrowser. No pude hacerlo. Entonces, la mejor y más fácil forma de lograrlo fue agregar una cadena a la URL que debe abrir desde la aplicación phonegap. Luego, verifique si la ubicación del documento tiene una cadena adjunta.

A continuación se muestra el código simple para ello

var ref = window.open('http://yourdomain.org#phonegap', '_blank', 'location=yes');

Verá que se agrega una cadena a la URL "#phonegap". Por lo tanto, en la URL del dominio agregue el siguiente script

if(window.location.indexOf("#phonegap") > -1){
     alert("Url Loaded in the phonegap App");
}