Cosa succede al codice JavaScript dopo che l'app è stata compilata utilizzando Titanium Mobile

StackOverflow https://stackoverflow.com/questions/4217551

Domanda

Ho installato Titanium da appcelerator e ho creato l'applicazione di esempio "KitchenSink".

Funziona tutto bene, mi chiedo solo dove finisce il codice JavaScript in un'app creata.

Ho grep-ed il progetto Xcode e anche l'applicazione dei risultati così come l'ho trovata Library/Application Support/iPhone Simulator/....KitchenSink.app, ma non riesco a trovare alcun nome di funzione da .js file, nemmeno i testi delle stringhe utilizzati all'interno dell'applicazione.

Le informazioni più vicine che ho trovato sono una risposta qui: Come funziona Appcelerator Titanium Mobile? ma non capisco bene come funziona il processo.

Il codice Javascript viene compilato in un codice binario (quale compilatore viene utilizzato allora?), o viene semplicemente trasformato in un formato dati speciale e interpretato in un'applicazione in esecuzione?

Aggiornamento:

Questo è ciò che posso vedere in una directory build/android di KitchenSink:

michal:bin mac$ find . -name table_view_layout\*
./assets/Resources/examples/table_view_layout.js
./assets/Resources/examples/table_view_layout_2.js
./assets/Resources/examples/table_view_layout_3.js
./assets/Resources/examples/table_view_layout_4.js
./assets/Resources/examples/table_view_layout_5.js
./classes/org/appcelerator/generated/examples/table_view_layout.class
./classes/org/appcelerator/generated/examples/table_view_layout_2.class
./classes/org/appcelerator/generated/examples/table_view_layout_3.class
./classes/org/appcelerator/generated/examples/table_view_layout_4.class
./classes/org/appcelerator/generated/examples/table_view_layout_5.class
michal:bin mac$ unzip -t app.apk | grep table_view_layout
    testing: assets/Resources/examples/table_view_layout.js   OK
    testing: assets/Resources/examples/table_view_layout_2.js   OK
    testing: assets/Resources/examples/table_view_layout_3.js   OK
    testing: assets/Resources/examples/table_view_layout_4.js   OK
    testing: assets/Resources/examples/table_view_layout_5.js   OK

Non ho esaminato app.apk prima, tutto quello che ho potuto vedere erano questi file di classe corrispondenti a ciascuno dei file javascript.Pertanto ho ipotizzato che su Android javascript venga compilato per JVM.Perché non è possibile trovarli in app.apk?

È stato utile?

Soluzione

Il titanio non è un wrapper per una vista tela come detto prima (anche se che spiega con precisione come funziona PhoneGap). risposta di Jeff, collegata nella domanda, è un tecnicamente corretta spiegazione di come funziona in titanio, ma qui è la migliore versione che ho sentito finora, da Marshall Culpepper :

E 'vero che il titanio mobile utilizzato il WebView (sia Android e iOS) nei pre-1.0 giorni. Tuttavia, questo non è più vero e non è stato dal nostro rilascio 1.0 è marzo 2010.

Dal 1.0, abbiamo spedito due tempi di esecuzione JavaScript distinto con le nostre applicazioni, e ci sono in esecuzione il codice Javascript direttamente senza una WebView. Tutta la vostra applicazione dall'inizio alla fine è ora controllata da JS, e mettiamo a disposizione un set completo di API native che consentono questo. Tutto da widget UI (sì, tra cui WebView), core API come Networking, Filesystem, Database, tutto il senso alle cose OS-specifici, come JS Attività in Android. Sul fronte runtime JS, stiamo spedizione una versione biforcuta di JavaScriptCore da parte di WebKit in iOS e un'istantanea di Rhino 1.7 R3 CVS per Android. Quello che realmente facciamo con la vostra sorgente JavaScript dipende dalla piattaforma, ma in genere si rompe in questo modo:

  • Fonte viene analizzato in modo statico per trovare i riferimenti ai moduli di titanio
  • stringhe di localizzazione (strings.xml), App metadati (tiapp.xml), e le immagini specifiche densità tutte generano analoghi specifici della piattaforma.
  • Nella iOS:
    • Un progetto XCode / configurazione viene generato
    • JS Source è base64'd e inline come variabile in un file C generato
    • xcodebuild viene utilizzato per generare i file binari finali
    • profili di provisioning, la firma di chiavi ecc vengono applicate
    • iTunes e qualche altra colla vengono utilizzati per inviare l'IPA per il proprio dispositivo iOS
  • In Android:
    • Un progetto Android / Eclipse viene generato
    • Nella schermata di "sviluppo", fonte JS è confezionato come attività APK
    • Nella schermata "Distribuzione" (produzione), quando si è pronti per spedire l'app, compiliamo il JS di bytecode Java utilizzando il compilatore di Rhino JSC. È inoltre possibile attivare questo durante la modalità di sviluppo impostando "ti.android.compilejs" a "true" in tiapp.xml, vedere: http://developer.appcelerator.com/question/100201/enable-android-byte-code-compile
    • dex, aapt e altri strumenti SDK Android vengono utilizzati per costruire e generare l'APK finale
    • ADB e keytool sono utilizzati per la spinta l'APK verso l'emulatore e / o dispositivo

Ci sono molti altri dettagli che ho potuto immergersi in particolare su ciascuno di questi punti, ma il punto che volevo andare a casa è che non usiamo più il WebView come il nostro motore di Javascript. È possono WebViews però ancora incorporare, e mettiamo a disposizione un po 'di una semplice integrazione che consente di chiamare le API di titanio da una WebView incorporato.

Altri suggerimenti

Ciò che jhaynie sta dicendo nella tua domanda collegata è che Titanium interpreta il tuo codice JS e lo converte in qualcosa che è quasi identico a Objective-C.

In un'applicazione web, il browser legge e interpreta il tuo Javascript ed esegue internamente il codice nativo associato (forse C++).Ad esempio, il browser potrebbe dire: "Questo script è in esecuzione getElementById(), quindi eseguirò i miei metodi C++ per raggiungere questo obiettivo." Ciò che Titanium sta facendo è capire in anticipo cosa sarebbe JS->C++ (o in questo caso JS->Objective-C) e compilarlo.Lascia comunque aperto un interprete dove necessario per il tuo codice dinamico, ma convertirà e compilerà ciò che può.

Ciò significa che non troverai nulla che assomigli a ciò che hai scritto originariamente nel tuo script.Tutto ciò che deve essere lasciato a un interprete viene comunque elaborato e convertito e i tuoi simboli cambieranno (ad es.una chiamata a myTestFunction() potrebbe essere convertito in A(), O 10001101001101 :P).

IL solito l'uso di Javascript consiste nel farlo interpretare in tempo reale da un programma in esecuzione.Non è quello che sta succedendo qui, ed è per questo che non puoi vedere alcuna traccia della tua sceneggiatura.

  • Javascript è pre-elaborato

    Titanium esegue l'interpretazione dello script come farebbe qualsiasi altro programma (come un browser web).Capisce quali dipendenze ha il tuo script sull'API Titanium e imposta tutto ciò.Quindi mappa i tuoi simboli direttamente in (nel caso dell'iPhone) Objective-C.

    Un programma di solito legge il tuo script (che è semplicemente una stringa), lo interpreta ed esegue il codice C per realizzare ciò che lo script richiedeva.Titanium lo fa in anticipo per capire quale codice C dovrebbe essere eseguito ed esegue la conversione in anticipo.

  • Il codice viene compilato ove possibile

    In base all'interpretazione del tuo codice e alle sue dipendenze sull'API Titanium, Titanium capisce quale codice può essere compilato direttamente e cosa non deve essere compilato per consentire la piena dinamica di Javascript.Non so come scelga cosa viene compilato e cosa non viene compilato, ma potresti controllare la fonte se vuoi conoscere tutti i dettagli.

    Il codice che deve ancora essere interpretato (lasciato come script) viene comunque convertito in simboli che determinano una mappatura più efficiente al codice nativo.Quindi è ancora uno script interpretato, ma ciò non significa che sia ancora Javascript.Ciò significa che queste parti del tuo script verranno comunque eseguite più velocemente del solito Javascript.

    Per iPhone, il C compilabile viene compilato con GCC per creare un binario nativo.

  • Hai un'app eseguibile*

    Ora hai un'app che puoi eseguire sul tuo dispositivo mobile.Il tuo codice compilabile è stato compilato e funziona alla velocità della luce, mentre il resto viene convertito e interpretato in un modo più efficiente che funziona quasi alla velocità della luce.:P

    • Spero che questo abbia senso ora, perché è tutto ciò che ho!:D

    Autorizzato sotto: CC-BY-SA insieme a attribuzione
    Non affiliato a StackOverflow
    scroll top