PhoneGap: Rileva se in esecuzione su browser desktop

Sto sviluppando un'applicazione web che utilizza PhoneGap: Build per una versione mobile e desidero avere un'unica base di codice per le versioni "desktop" e mobile. Voglio essere in grado di rilevare se le chiamate PhoneGap funzioneranno (cioè, l'utente su un dispositivo mobile che supporterà PhoneGap).

Ho cercato e non riesco a credere che non ci sia un modo semplice per farlo. Molte persone hanno offerto suggerimenti;

• 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

Nessuno dei quali funziona, a meno che non rimuovi il file Javascript PhoneGap dalla versione desktop dell'app, il che sconfigge il mio obiettivo di avere una base di codice.

Finora l'unica soluzione che ho escogitato è lo sniffing del browser / user agent, ma questo non è a dir poco robusto. Qualsiasi soluzione migliore è benvenuta!

MODIFICA: una soluzione leggermente migliore è provare a chiamare una funzione PhoneGap dopo un breve timeout: se non funziona, supponi che l'utente sia su un browser web desktop.

Uso questo codice:

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

AGGIORNARE

Esistono molti altri modi per rilevare se phonegap è in esecuzione su un browser o meno, ecco un'altra ottima opzione:

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

come mostrato qui: Rileva tra un browser mobile o un'applicazione PhoneGap

Ho scritto un post a riguardo qualche giorno fa. Questa è la migliore soluzione che puoi trovare (fino a quando PhoneGap non rilascerà qualcosa, forse o forse no), è breve, semplice e perfetta (l'ho controllata in ogni modo e piattaforma possibile).

Questa funzione farà il lavoro per il 98% dei casi.

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

Per completare il restante 2% dei casi, segui questi passaggi (comporta una leggera modifica al codice nativo):

Crea un file chiamato __phonegap_index.html , con l'origine:

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

Ora, su native cambia semplicemente la pagina iniziale da index.html a __phonegap_index.html su tutte le tue piattaforme PhoneGap. Diciamo che il nome del mio progetto è di esempio , i file che devi modificare sono (come per PhoneGap versione 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(linea 56)
• Window Phone 7 - Non ho idea di dove (qualcuno sta ancora sviluppando su quella piattaforma ?!)

Infine, puoi usarlo ovunque sul tuo sito, se è in esecuzione su PhoneGap o meno:

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

Spero che sia d'aiuto. :-)

So che è stato risposto tempo fa, ma "PhoneGap.available" non esiste più. Dovresti usare:

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

o dalla 1.7, preferisci:

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

EDIT 2019: come detto nei commenti, funziona solo se non includi cordova lib nella build del tuo browser desktop. E ovviamente è una buona pratica includere solo i file javascript / html / css minimi rigorosi per ogni dispositivo target

Il modo più affidabile che abbiamo trovato per sapere se siamo in un'applicazione cordova / phonegap è modificare l'agente utente dell'applicazione cordova utilizzando questa configurazione AppendUserAgent .

Inoltre config.xml:

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

Quindi chiama:

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

Perché?

1. window.cordovae document.addEventListener('deviceready', function(){});sono soggetti alle condizioni di gara
2. navigator.standalonenon funziona quando <content src="index.html" />è un sito Web (Es: <content src="https://www.example.com/index.html" />o con cordova-plugin-remote-injection )
3. Cercare di inserire nella whitelist gli user agent per indovinare se si tratta di un vero browser è molto complicato. I browser Android sono spesso visualizzazioni web personalizzate.

Penso che questo sia il più semplice: var isPhoneGap = (location.protocol == "file:")

EDIT Per alcune persone che non hanno funzionato. Allora potresti provare (non testato)

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

Questo funziona per me (in esecuzione 1.7.0)

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

Testato su desktop Chrome e Safari.

Come il poster originale, sto usando il servizio di compilazione phonegap. Dopo due giorni e quasi 50 build di test, ho trovato una soluzione elegante che funziona alla grande per me.

Non potevo usare UA sniffing perché volevo testarlo ed eseguirlo nei browser mobili. Inizialmente avevo scelto la tecnica abbastanza funzionale di Cobberboy. Questo non ha funzionato per me perché il ritardo / timeout "howPatientAreWe: 10000" era troppo fastidioso per lo sviluppo nel browser. E impostarlo su un valore inferiore occasionalmente fallirebbe il test in modalità app / dispositivo. Doveva esserci un altro modo ...

Il servizio di compilazione phonegap richiede che il phonegap.jsfile venga omesso dal tuo repository di codice prima di inviare i file della tua app al servizio. Pertanto sono in grado di testarne l'esistenza per determinare se è in esecuzione in un browser o in un'app.

Un altro avvertimento, sto anche usando jQueryMobile, quindi sia jQM che phonegap dovevano essere inizializzati prima che potessi iniziare qualsiasi script personalizzato. Il codice seguente viene inserito all'inizio del mio file index.js personalizzato per l'app (dopo jQuery, prima di jQM). Anche i documenti di compilazione phonegap dicono di posizionarli <script src="phonegap.js"></script>da qualche parte nell'HTML. Lo tralascio completamente e lo carico usando $ .getScript () per testarne l'esistenza.

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

È interessante notare che molte risposte, ma non includono queste tre opzioni:

1 - Il cordova.js imposterà l'oggetto cordova nell'ambito globale. Se è lì, molto probabilmente stai correndo in un ambito Cordova.

var isCordovaApp = !!window.cordova;

2 - Cordova eseguirà la tua applicazione come apriresti un documento HTML dal desktop. Invece del protocollo HTTP utilizzerà FILE. Rilevarlo ti darà la possibilità di presumere che la tua app sia stata caricata localmente.

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

3 - Utilizza l'evento di caricamento dello script cordova per rilevare il contesto. L'inclusione dello script può essere facilmente rimossa nel processo di compilazione o il caricamento dello script fallirà semplicemente in un browser. In modo che questa variabile globale non venga impostata.

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

Il merito va a Damien Antipa di Adobe

Uso questo metodo:

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

debugsarà truenell'ambiente del browser, falsesul dispositivo.

Questo sembra essere fattibile e l'ho usato in produzione:

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/

L'essenza del problema è che fintanto che cordova.device è indefinito, il tuo codice non può essere sicuro se è perché cordova ha stabilito che il tuo dispositivo non è supportato, o se è perché cordova si sta ancora preparando e deviceready si attiverà più tardi (o terza opzione: cordova non è stata caricata correttamente).

L'unica soluzione è definire un periodo di attesa e decidere che dopo questo periodo il codice deve presumere che il dispositivo non sia supportato. Vorrei che Cordova impostasse un parametro da qualche parte per dire "Abbiamo provato a trovare un dispositivo supportato e ci siamo arresi", ma sembra che non ci sia tale parametro.

Una volta stabilito questo, potresti voler fare qualcosa di specifico proprio in quelle situazioni in cui non è presente alcun dispositivo supportato. Come nascondere i collegamenti al mercato delle app del dispositivo, nel mio caso.

Ho messo insieme questa funzione che dovrebbe coprire praticamente ogni situazione. Ti consente di definire un gestore pronto per il dispositivo, un gestore che non è mai pronto per il dispositivo e un tempo di attesa.

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

}

Il modo in cui lo sto facendo è usare una variabile globale che viene sovrascritta da una versione solo browser di cordova.js. Nel tuo file html principale (di solito index.html) ho i seguenti script che dipendono dall'ordine:

    <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 dentro cordova.jsho semplicemente:

__cordovaRunningOnBrowser__ = true

Quando si crea per un dispositivo mobile, cordova.js non verrà utilizzato (e verrà utilizzato invece il file cordova.js specifico della piattaforma), quindi questo metodo ha il vantaggio di essere corretto al 100% indipendentemente dai protocolli, dagli userAgents o dalla libreria variabili (che possono cambiare). Potrebbero esserci altre cose che dovrei includere in cordova.js, ma non so ancora cosa siano.

Un altro modo, basato sulla soluzione di SlavikMe:

Usa semplicemente un parametro di query passato a index.htmldalla tua fonte PhoneGap. Cioè, in Android, invece di

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

uso

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

SlavikMe ha un ottimo elenco su dove farlo su altre piattaforme.

Quindi index.htmlpuoi semplicemente farlo:

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

Per mantenere una base di codice, ciò che interessa è la "piattaforma" su cui è in esecuzione il codice. Per me questa "piattaforma" può essere tre cose diverse:

• 0: browser del computer
• 1: browser per dispositivi mobili
• 2: phonegap / cordova

Il modo per verificare la piattaforma:

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

Nota:

• Deve essere eseguito solo dopo che cordova.js è stato caricato (body onload (...), $ (document) .ready (...))

• "ontouchstart" in document.documentElement sarà presente nei laptop e nei monitor desktop che dispongono di uno schermo abilitato al tocco, quindi segnalerebbe un browser mobile anche se è un desktop. Ci sono diversi modi per fare un controllo più preciso, ma lo uso perché si occupa comunque del 99% dei casi di cui ho bisogno. Puoi sempre sostituire quella linea con qualcosa di più robusto.

Aarons, prova

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

La soluzione di GeorgeW è OK, ma anche sul dispositivo reale, PhoneGap.available è vero solo dopo che le cose di PhoneGap sono state caricate, ad esempio onDeviceReady in document.addEventListener ('deviceready', onDeviceReady, false) è stato chiamato.

Prima di quel momento, se vuoi sapere, puoi fare così:

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

Questa soluzione presuppone che la maggior parte degli sviluppatori sviluppi utilizzando Chrome o Firefox.

Ho lo stesso problema.

Sono propenso ad aggiungere # cordova = true all'URL caricato dal client cordova e testare location.hash.indexOf ("cordova = true")> -1 nella mia pagina web.

Quanto segue funziona per me con il più recente PhoneGap / Cordova (2.1.0).

Come funziona:

• Molto semplice nel concetto
• Ho invertito la logica di alcune delle soluzioni di timeout di cui sopra.
• Registrati per l'evento device_ready (come consigliato dai documenti di PhoneGap )
  • Se l'evento NON si è ancora attivato dopo un timeout, eseguire il fallback assumendo un browser.
  • Al contrario, le altre soluzioni sopra si basano sul test di alcune funzionalità di PhoneGap o su altre e sul guardare la loro interruzione di prova.

vantaggi:

• Utilizza l'evento device_ready consigliato da PhoneGap.
• L'app mobile non ha ritardi. Non appena si attiva l'evento device_ready, procediamo.
• Nessuno sniffing di user-agent (mi piace testare la mia app come sito web per dispositivi mobili, quindi lo sniffing del browser non era un'opzione per me).
• Nessun affidamento su funzioni / proprietà PhoneGap non documentate (e quindi fragili).
• Mantieni il tuo cordova.js nella tua base di codice anche quando usi un browser desktop o mobile. Quindi, questo risponde alla domanda dell'OP.
• Wytze ha affermato sopra: "Vorrei che cordova impostasse un parametro da qualche parte per dire" Abbiamo provato a trovare un dispositivo supportato e ci siamo arresi ", ma sembra che non ci sia tale parametro." Quindi ne fornisco uno qui.

svantaggi:

• I timeout sono icky. Ma la nostra logica dell'app per dispositivi mobili non si basa su un ritardo; piuttosto, viene utilizzato come riserva quando siamo in modalità browser web.

==

Crea un nuovo progetto PhoneGap vuoto. Nell'esempio index.js fornito, sostituisci la variabile "app" in basso con questa:

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

Mi sono imbattuto in questo problema diversi mesi fa quando ho iniziato la nostra app, perché volevamo che anche l'app fosse " browser-compatible" (con la consapevolezza che alcune funzionalità sarebbero state bloccate in quello scenario: registrazione audio, bussola, ecc.).

L'unica 100%(e insisto sulla condizione del 100%) per determinare PRE-determinare il contesto di esecuzione dell'app era questa:

• inizializza una variabile "flag" JS su true e cambiala in false quando in un contesto tutto web;

• quindi puoi usare una chiamata come " willIBeInPhoneGapSometimesInTheNearFuture()" (che è PRE-PG, ovviamente hai ancora bisogno di un metodo POST-PG per verificare se puoi chiamare le API PG, ma quello è banale).

• Quindi dici: " but how do you determine the execution context?"; la risposta è: "tu non" (perché non credo che tu possa essere affidabile, a meno che quei brillanti ragazzi di PG non lo facciano nel loro codice API);

• scrivi uno script di build che lo faccia per te: un codebase con due varianti.

Non è proprio una risposta alla domanda, ma quando eseguo il test in un browser desktop, imposto semplicemente un valore localstorage per far caricare al browser l'app nonostante il dispositivo pronto a non attivarsi.

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

Nessuno dei quali funziona, a meno che non rimuovi il file Javascript PhoneGap dalla versione desktop dell'app, il che sconfigge il mio obiettivo di avere una base di codice.

Un'altra opzione potrebbe essere quella di utilizzare la cartella Merge , vedi screenshot qui sotto.

È possibile aggiungere file specifici della piattaforma / sovrascrivere quelli predefiniti.

(dovrebbe fare il trucco in alcuni scenari)

In altre parole: invece di rilevare il browser, semplicemente non includi determinati file per la creazione del desktop / alleghi determinati file solo per iOS.

Rileva il browser desktop anche se il dispositivo di emulazione è attivo

Funziona su macchine Windows e Mac. Necessità di trovare una soluzione per Linux Visualizza i dettagli

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
}

In realtà ho trovato che una combinazione di due delle tecniche elencate qui ha funzionato al meglio, in primo luogo controlla che sia possibile accedere a cordova / phonegap controlla anche se il dispositivo è disponibile. Così:

function _initialize() {
    //do stuff
}

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

Prova questo approccio:

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

Uso una combinazione di quanto suggerito da GeorgeW e 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.')
   }

Immagino che in qualche modo non siano così diversi, vero? Ah ah ... non è divertente. Chi non pensava che questo non sarebbe stato un problema? Ecco la soluzione più semplice per le tue considerazioni. Spingi file diversi sul tuo server e poi su PhoneGap. Vorrei anche andare temporaneamente con il controllo http: suggerito sopra.

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

Il mio interesse è spingere verso l'alto la barra di navigazione del browser, quindi posso semplicemente eliminare il tag dello script isolato e premere ricostruisci [in DW] (ci sarà comunque un po 'di pulizia per la distribuzione, quindi questa può essere una di quelle attività.) Comunque mi sento è una buona opzione (considerando che non è disponibile molto altro) per commentare manualmente in modo efficiente le cose con isMobileBrowserAndNotPhoneGap quando si spinge su PG). Anche in questo caso per me nella mia situazione cancellerò semplicemente il tag per il file (codice isolato) che spinge verso l'alto la barra di navigazione quando è un browser mobile (sarà molto più veloce e più piccolo). [Quindi sì, se riesci a isolare il codice per quella soluzione ottimizzata ma manuale.]

Leggermente modificato, ma per me funziona perfettamente senza problemi.

L'intento è caricare Cordova solo su un dispositivo incorporato, non su un desktop, quindi evito completamente Cordova su un browser desktop. Il test e lo sviluppo dell'interfaccia utente e di MVVM è quindi molto comodo.

Metti questo codice ad es. nel file 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);
}

Quindi, invece di includere cordova javascript stesso, includere 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 il tuo lavoro! :)

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

Solo per info il modo in 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 nel framework YASMF

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

Stavo provando con gli oggetti finestra ma non ha funzionato mentre stavo aprendo l'URL remoto in InAppBrowser. Impossibile farlo. Quindi il modo migliore e più semplice per ottenerlo era aggiungere una stringa all'URL che devi aprire dall'app phonegap. Quindi controlla se alla posizione del documento è stata aggiunta una stringa.

Di seguito è riportato il semplice codice per esso

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

Vedrai che viene aggiunta una stringa all'URL "#phonegap". Quindi nell'URL del dominio aggiungi il seguente script

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