PhoneGap: detecta se está em execução no navegador de desktop

Estou desenvolvendo um aplicativo da web que usa PhoneGap: Build para uma versão móvel e quero ter uma única base de código para as versões 'desktop' e móvel. Quero ser capaz de detectar se as chamadas do PhoneGap funcionarão (ou seja, se o usuário está em um dispositivo móvel compatível com o PhoneGap).

Eu procurei e não consigo acreditar que não existe uma maneira simples de fazer isso. Muitas pessoas deram sugestões;

• 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

Nada disso funciona, a menos que você remova o arquivo Javascript do PhoneGap da versão desktop do aplicativo, o que anula meu objetivo de ter uma base de código.

Até agora, a única solução que encontrei foi farejar o navegador / agente do usuário, mas isso não é robusto para dizer o mínimo. Quaisquer soluções melhores são bem-vindas!

EDIT: Uma solução marginalmente melhor é tentar chamar uma função PhoneGap após um pequeno tempo limite - se não funcionar, suponha que o usuário esteja em um navegador da web de desktop.

Eu 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
}

ATUALIZAR

Existem muitas outras maneiras de detectar se o phonegap está sendo executado em um navegador ou não; aqui está outra ótima opção:

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

como visto aqui: Detectar entre um navegador móvel ou um aplicativo PhoneGap

Eu escrevi um post sobre isso há alguns dias. Esta é a melhor solução que você pode encontrar (até que o PhoneGap lance algo, talvez ou talvez não), é curta, simples e perfeita (eu verifiquei de todas as formas e plataformas possíveis).

Esta função fará o trabalho para 98% dos 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 os outros 2% dos casos, siga estas etapas (envolve uma ligeira mudança no código nativo):

Crie um arquivo chamado __phonegap_index.html , com a fonte:

<!-- __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>

Agora, no nativo, basta alterar a página inicial de index.html para __phonegap_index.html em todas as suas plataformas PhoneGap. Digamos que o nome do meu projeto seja um exemplo , os arquivos que você precisa alterar são (como no PhoneGap versão 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(linha 56)
• Window Phone 7 - Não faço ideia de onde (alguém ainda está desenvolvendo nessa plataforma ?!)

Finalmente, você pode usá-lo em qualquer lugar do seu site, se estiver ou não rodando no PhoneGap:

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

Espero que ajude. :-)

Sei que foi respondido há um tempo, mas "PhoneGap.available" não existe mais. Você deveria usar:

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

ou desde 1.7, prefira:

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

EDIT 2019: como dito nos comentários, isso só funciona se você não incluir cordova lib em seu navegador de desktop. E, claro, é uma boa prática incluir apenas os arquivos javascript / html / css mínimos estritos para cada dispositivo de destino

A maneira mais confiável que encontramos de saber se estamos em um aplicativo cordova / phonegap é modificar o agente do usuário do aplicativo cordova usando esta configuração AppendUserAgent .

Além disso config.xml:

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

Então ligue:

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

Por quê?

1. window.cordovae document.addEventListener('deviceready', function(){});estão sujeitos às condições de corrida
2. navigator.standalonenão funciona quando <content src="index.html" />é um site (Ex: <content src="https://www.example.com/index.html" />ou com cordova-plugin-remote-inject )
3. Tentar colocar agentes de usuário na lista de permissões para adivinhar se é um navegador real é muito complicado. Os navegadores Android geralmente são visualizações da web personalizadas.

Acho que é o mais simples: var isPhoneGap = (location.protocol == "file:")

EDITAR Para algumas pessoas que não funcionou. Então você pode tentar (não testei)

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

Isso funciona para mim (executando 1.7.0)

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

Testado em desktop Chrome e Safari.

Como o autor do pôster original, estou usando o serviço de construção do phonegap. Depois de dois dias e quase 50 compilações de teste, descobri uma solução elegante que funciona muito bem para mim.

Não pude usar o UA sniffing porque queria testar e executar em navegadores móveis. Eu havia me decidido originalmente pela técnica bastante funcional do cobberboy. Isso não funcionou para mim porque o atraso / tempo limite de "howPatientAreWe: 10000" era muito incômodo para o desenvolvimento no navegador. E defini-lo para um valor mais baixo ocasionalmente falha no teste no modo app / dispositivo. Tinha que haver outra maneira...

O serviço de construção do phonegap requer que o phonegap.jsarquivo seja omitido de seu repositório de código antes de enviar os arquivos de seu aplicativo para o serviço. Portanto, posso testar sua existência para determinar se está sendo executado em um navegador ou em um aplicativo.

Outra ressalva: também estou usando o jQueryMobile, então tanto o jQM quanto o phonegap tiveram que inicializar antes que eu pudesse iniciar qualquer script personalizado. O código a seguir é colocado no início do meu arquivo index.js personalizado para o aplicativo (após jQuery, antes de jQM). Além disso, os documentos de construção do phonegap dizem para colocar <script src="phonegap.js"></script>em algum lugar no HTML. Deixo-o completamente de fora e o carrego usando $ .getScript () para testar a sua existência.

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, muitas respostas, mas não incluem essas três opções:

1 - O cordova.js irá definir o objeto cordova no âmbito global. Se estiver lá, provavelmente você está executando em um osciloscópio Cordova.

var isCordovaApp = !!window.cordova;

2 - O Cordova executará seu aplicativo da mesma forma que você abriria um documento HTML na sua área de trabalho. Em vez do protocolo HTTP, ele usará FILE. Detectar isso lhe dará a chance de presumir que seu aplicativo foi carregado localmente.

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

3 - Use o evento load do script cordova para detectar o contexto. O script include pode ser facilmente removido no processo de construção ou o carregamento do script simplesmente falhará em um navegador. Para que esta variável global não seja configurada.

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

O crédito vai para Damien Antipa, da Adobe

Eu uso este método:

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

debugestará trueno ambiente do navegador, falseno dispositivo.

Isso parece viável e eu usei na produção:

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

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

A essência do problema é que, desde que cordova.device seja indefinido, seu código não pode ter certeza se é porque cordova estabeleceu que seu dispositivo não é compatível ou se é porque cordova ainda está se preparando e o dispositivo irá disparar mais tarde (ou terceira opção: cordova não carregou corretamente).

A única solução é definir um período de espera e decidir que após esse período seu código deve assumir que o dispositivo não é compatível. Gostaria que cordova definisse um parâmetro em algum lugar para dizer "Tentamos encontrar um dispositivo compatível e desistimos", mas parece que esse parâmetro não existe.

Uma vez que isso seja estabelecido, você pode querer fazer algo específico precisamente nas situações em que não há dispositivo compatível. Como esconder links para o mercado de aplicativos do aparelho, no meu caso.

Reuni essa função que deve abranger praticamente todas as situações. Ele permite que você defina um gerenciador pronto para o dispositivo, um gerenciador que nunca está pronto para o dispositivo e um tempo 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
                    }
                }
            }
    }

}

Estou fazendo isso usando uma variável global que é substituída por uma versão somente para navegador do cordova.js. Em seu arquivo html principal (geralmente index.html), tenho os seguintes scripts que dependem do pedido:

    <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 -->

E por dentro cordova.jstenho simplesmente:

__cordovaRunningOnBrowser__ = true

Ao construir para um dispositivo móvel, o cordova.js não será usado (e em vez disso o arquivo cordova.js específico da plataforma será usado), então este método tem a vantagem de ser 100% correto, independentemente dos protocolos, userAgents ou biblioteca variáveis ​​(que podem mudar). Pode haver outras coisas que eu deveria incluir em cordova.js, mas ainda não sei o que são.

Outra forma, baseada na solução do SlavikMe:

Basta usar um parâmetro de consulta passado index.htmlde sua fonte do PhoneGap. Ou seja, no Android, em vez de

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

usar

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

O SlavikMe tem uma grande lista de onde fazer isso em outras plataformas.

Então você index.htmlpode simplesmente fazer isto:

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

Para manter uma base de código, o que interessa é a "plataforma" em que o código está sendo executado. Para mim, essa "plataforma" pode ser três coisas diferentes:

• 0: navegador do computador
• 1: navegador móvel
• 2: phonegap / cordova

A forma de verificar a 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:

• Isso deve ser executado somente depois que cordova.js foi carregado (body onload (...), $ (document) .ready (...))

• 'ontouchstart' em document.documentElement estará presente em laptops e monitores de desktop que possuem uma tela habilitada para toque, de forma que ele reportaria um navegador móvel, mesmo sendo um desktop. Existem diferentes maneiras de fazer uma verificação mais precisa, mas eu uso porque ainda atende 99% dos casos de que preciso. Você sempre pode substituir essa linha por algo mais robusto.

Aarons, tente

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

A solução de GeorgeW é OK, mas mesmo em um dispositivo real, PhoneGap.available só é verdadeiro depois que as coisas do PhoneGap foram carregadas, por exemplo, onDeviceReady em document.addEventListener ('deviceready', onDeviceReady, false) foi chamado.

Antes disso, se você quiser saber, pode fazer assim:

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

Esta solução pressupõe que a maioria dos desenvolvedores desenvolve usando Chrome ou Firefox.

Eu tenho o mesmo problema.

Estou inclinado a adicionar # cordova = true ao URL carregado pelo cliente cordova e testar para location.hash.indexOf ("cordova = true")> -1 em minha página da web.

O seguinte funciona para mim com o PhoneGap / Cordova mais recente (2.1.0).

Como funciona:

• Muito simples no conceito
• Eu inverti a lógica de algumas das soluções de tempo limite acima.
• Registre-se para o evento device_ready (conforme recomendado pelos documentos PhoneGap )
  • Se o evento ainda NÃO disparou após um tempo limite, volte a assumir um navegador.
  • Em contraste, as outras soluções acima dependem do teste de algum recurso do PhoneGap ou outro e da observação do intervalo do teste.

Vantagens:

• Usa o evento device_ready recomendado pelo PhoneGap.
• O aplicativo móvel não tem demora. Assim que o evento device_ready disparar, prosseguiremos.
• Sem detecção de user agent (gosto de testar meu aplicativo como um site móvel, portanto, a detecção de navegador não era uma opção para mim).
• Sem dependência de recursos / propriedades não documentados (e, portanto, frágeis) do PhoneGap.
• Mantenha seu cordova.js em sua base de código, mesmo quando estiver usando um desktop ou navegador móvel. Assim, isso responde à pergunta do OP.
• Wytze afirmou acima: 'Gostaria que cordova definisse um parâmetro em algum lugar para dizer' Tentamos encontrar um dispositivo compatível e desistimos ', mas parece que esse parâmetro não existe.' Então, eu forneço um aqui.

Desvantagens:

• Os tempos limite são nojentos. Mas nossa lógica de aplicativo móvel não depende de um atraso; em vez disso, é usado como alternativa quando estamos no modo de navegador da web.

==

Crie um novo projeto PhoneGap em branco. Na amostra index.js fornecida, substitua a variável "app" na parte inferior por:

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"));
}

Eu me deparei com esse problema há vários meses, ao iniciar nosso aplicativo, porque queríamos que o aplicativo browser-compatibletambém fosse " " (com o entendimento de que algumas funcionalidades seriam bloqueadas nesse cenário: gravação de áudio, bússola, etc.).

A única 100%solução (e eu insisto na condição de cem por cento) para pré-determinar o contexto de execução do aplicativo foi esta:

• inicializar uma variável JS "sinalizador" para verdadeiro e alterá-lo para falso quando em um contexto totalmente web;

• portanto, você pode usar uma chamada como " willIBeInPhoneGapSometimesInTheNearFuture()" (que é PRE-PG, é claro que você ainda precisa de um método POST-PG para verificar se você pode chamar APIs de PG, mas esse é trivial).

• Aí você diz: " but how do you determine the execution context?"; a resposta é: "você não faz" (porque eu não acho que você pode confiar, a menos que aquele pessoal brilhante do PG faria isso em seu código API);

• você escreve um script de compilação que faz isso por você: uma base de código com duas variantes.

Não é realmente uma resposta para a pergunta, mas quando eu testo em um navegador de desktop, apenas defino um valor de armazenamento local para fazer o navegador carregar o aplicativo, apesar de o dispositivo não disparar.

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();
    }
});

Nada disso funciona, a menos que você remova o arquivo Javascript do PhoneGap da versão desktop do aplicativo, o que anula meu objetivo de ter uma base de código.

Outra opção seria usar a pasta merges , veja a imagem abaixo.

Você pode adicionar arquivos específicos da plataforma / substituir os padrão.

(deve funcionar em alguns cenários)

Em outras palavras: em vez de detectar o navegador, você simplesmente não inclui certos arquivos para compilar / anexar certos arquivos apenas para iOS.

Detecta o navegador da área de trabalho mesmo se a emulação do dispositivo estiver ativa

Funciona em máquinas Windows e Mac. Precisa encontrar uma solução para linux Ver detalhes

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
}

Na verdade, descobri que uma combinação de duas das técnicas listadas aqui funcionou melhor. Em primeiro lugar, verifique se o cordova / fone de ouvido pode ser acessado e também se o dispositivo está disponível. Igual a:

function _initialize() {
    //do stuff
}

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

Experimente esta abordagem:

/**
 * 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);
        }
    });
}

Eu uso uma combinação do que GeorgeW e mkprogramming sugeriu:

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

Eu acho que de alguma forma eles não são tão diferentes, são? Ha Ha ... não é engraçado. Quem não achou que isso não seria um problema? Esta é a solução mais simples para suas considerações. Envie arquivos diferentes para o seu servidor e depois para o PhoneGap. Eu também iria temporariamente com a http: verificação sugerida acima.

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

Meu interesse é aumentar a barra de navegação dos navegadores, então, na verdade, posso simplesmente excluir a tag do script isolado e pressionar reconstruir [no DW] (haverá alguma limpeza para implantação de qualquer maneira, então essa pode ser uma dessas tarefas). De qualquer forma, sinto é uma boa opção (considerando que não há muito mais disponível) de forma eficiente apenas comentar coisas manualmente com isMobileBrowserAndNotPhoneGap ao enviar para PG). Novamente, para mim, na minha situação, irei simplesmente deletar a tag do arquivo (código isolado) que empurra a barra de navegação quando é um navegador móvel (será muito mais rápido e menor). [Então, sim, se você puder isolar o código para essa solução otimizada, mas manual.]

Ligeiramente modificado, mas funciona perfeitamente para mim sem problemas.

A intenção é carregar o Cordova apenas quando estiver em um dispositivo embutido, não em um desktop, então evito completamente o Cordova em um navegador de desktop. O teste e o desenvolvimento da IU e do MVVM são muito confortáveis.

Coloque este código, por exemplo. no arquivo 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);
}

Então, em vez de incluir o próprio cordova javascript, inclua 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> 

Facilite seu trabalho! :)

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

Apenas para obter informações como no PhoneGap 3.x Mobile Application Development Hotshot

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();
} );

e na estrutura YASMF

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

Eu estava tentando com os objetos da janela, mas não funcionou porque estava abrindo o url remoto no InAppBrowser. Não foi possível fazer isso. Portanto, a melhor e mais fácil maneira de fazer isso é anexar uma string ao url que você precisa abrir no aplicativo phonegap. Em seguida, verifique se o local do documento tem uma string anexada a ele.

Abaixo está o código simples para isso

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

Você verá que uma string é adicionada ao url "#phonegap". Então, no url do domínio, adicione o seguinte script

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