Distriggers lo zoom sulla messa a fuoco dell'ingresso nella pagina web di Android

Ecco il dilemma, ho una pagina web (solo per dispositivi android) e in quella pagina ho una casella di input (una casella di text in modo specifico) e quando si concentra il browser esplora lo zoom. Non voglio ingrandire – suoni facile, giusto?

Ecco where è divertente: devo essere in grado di zoomare in generale, quindi non dire

  • Come convertire un object JSONObject in class?
  • Nascondere la data dal selezionatore di data
  • jackson JsonParseException: Inteq UTF-8 middle byte
  • Android: Linear Layout nuova linea
  • Come specificare l'id quando gli usi includono nel file xml di layout
  • org.json.JSONException: Valore del tipo org.json.JSONArray non può essere convertito in JSONObject
  • <meta name='viewport' content='user-scalable=0'> 

    Questo non funziona per me.

    Inoltre, la casella di input non riceve gli events clic. Appare quando si fa clic su un altro button e si ottiene la messa a fuoco in modo programmato.

    Ecco quello che ho provato e sono finora falliti:

     jQuery('head meta[name=viewport]').remove(); jQuery('head').prepend('<meta name="viewport" content="width=720px;intial-scale=1.0;maximum-scale=1.0;user-scalable=no" />'); jQuery("#locationLock input").focus(); jQuery('head meta[name=viewport]').remove(); jQuery('head').prepend('<meta name="viewport" content="width=720px;intial-scale=1.0;maximum-scale=1.0;user-scalable=yes" />'); 

    Anche questo non è riuscito:

     <input type='text' onfocus="return false"> 

    E questo:

     jQuery("#locationLock input").focus(function(e){e.preventDefault();}); 

    Qualche idea?

  • Utilizzo di onConfigurationChanged in un frammento
  • Come le applicazioni popolari autentano le richieste degli utenti dalla propria applicazione mobile al proprio server?
  • Come get l'animation di ripple utilizzando la libreria di supporto?
  • Fornire un'authentication sicura di Facebook con il mio server
  • Imansible importre un nuovo progetto Gradle: imansible trovare la versione di Strumenti di revisione * .0.0
  • Viewpager non ottiene l'ultima voce
  • 30 Solutions collect form web for “Distriggers lo zoom sulla messa a fuoco dell'ingresso nella pagina web di Android”

    Non ansible!

    Ho tutte le cattive notizie per tutti voi. Sono passati 6 mesi e nessuno ha risposto correttamente alla domanda.

    Ho anche finito di lavorare a quel progetto e al datore di lavoro.

    Ho paura di dirlo, ma esattamente quello che ho chiesto è imansible. Spiacenti i popoli. Ma io lascerò la domanda in modo che le persone possano vedere le altre opzioni.

    Il seguente ha funzionato per me (Android Galaxy S2):

     <meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, user-scalable=no;user-scalable=0;"/> 

    Non sono sicuro se questo è il modo migliore ma questo funziona per me su android e iphone.

     input:focus { font-size: 16px!importnt} 

    È ansible utilizzare le query multimediali per specificare solo i dispositivi mobili.

    Problemi di scala Causa Zoom su Focus in ingresso

    C'è una grande difficoltà nel dimensionare il contenuto per diverse risoluzioni e size dello schermo, che in ultima analisi è la causa di questo problema di zoom.

    La maggior parte dei browser mobili dispone di un trigger in focus di input (che non è ansible superare senza difficoltà):

     if (zoom-level < 1) zoom to 1.5 center focused input relative to screen 

    * sì, era troppo semplice.

    Mito di correzioni scala metacarattere.

    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"> Tutte le impostazioni di questo tipo di visualizzazione non impediranno lo zoom in entrata zoom se si è zoomato. Questi inoltre non supereranno qualsiasi altra dimensione di html, corpo o elemento che spingerebbe la window in width più larga dello schermo.

    Causa primaria

    Uso di una window o di un corpo più grande delle size dello schermo del dispositivo.

    Si consideri la dimensione dello schermo standard della maggior parte della linea Galaxy di smartphone Android: 360 x 650. Se il corpo del documento o la window è definito più grande di quello (diciamo 1024 ampiamente per renderlo evidente), alcune cose possono accadere:

    1. Il browser può ridurre automaticamente l'image, per adattarla alla width dello schermo.
      1. L'utente può fare quanto sopra.
      2. Potresti aver fatto quanto sopra.
    2. Il browser ripristina il livello dello zoom nelle visite successive alla pagina.
    3. Stai visualizzando il contenuto a ~ 0.35x zoom.

    Stato iniziale 1x

    Quando caricato, la pagina non si adatta. Alcuni browser possono zoomare per adattarsi alla window, ma l'utente certamente lo farà. Inoltre, se hai ingrandito questa pagina una volta, il browser memorizzerà il livello dello zoom.

    Zoom Out per adattarlo 0.35x

    Una volta ingrandita, la width si adatta bene, e una pagina con più area verticale riempire lo schermo abbastanza bene … ma …

    Si noti che il browser è ora in uno stato in cui il text e l'input (size per il normale zoom 1x) sarebbero troppo piccoli da leggere, innescando così un comportmento di usabilità di zoom sui campi di input quando si ottengono focus.

    Zoom sull'Input-Focus 1.5x

    Comportmento tipico nel caso di cui sopra, è quello di zoomare a 1,5x, per garantire la visibilità dell'input. Il risultato (se hai ideato tutto per sembrare meglio quando è stato ingrandito o per lo schermo più grande) è less che auspicabile.

    Soluzione 1

    Utilizza una combinazione di regole di media di css, rilevamento di periferiche o qualunque cosa sia più adatta alla tua situazione. Impostare la window e il corpo in una dimensione che riempie lo spazio dello schermo, senza superarlo.

    • Questo è il motivo per cui tante persone hanno successo con forzare la dimensione del text di input a 16px;
      • una volta che lo fai, è chiaro che sei in modalità zoom.
      • ha anche il vantaggio aggiunto di ingannare il browser in modo che le windows leggermente ingrandite non attivino lo zoom a fuoco.

    Soluzione 2

    Utilizza la meta viewport, ma presti attenzione con le larghezze di css.

     <meta name="viewport" content="width=device-width, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no"/> 
    • Quando si utilizza questo metodo, è necessario eseguire una delle seguenti operazioni:
      • Utilizza solo percentuali per larghezze.
      • Definire una width di em e utilizzare solo em e% per le larghezze.
      • vedere la soluzione 1 per l'utilizzo di larghezze di px.

    Soluzione 3

    jQuery.mobile $.mobile.zoom.disable();

    Basta assicurarsi di iniziare a sviluppare con esso fin dall'inizio, e non dal centro.

    Sì, è ansible

     input[type='text'],input[type='number'],textarea {font-size:16px;} 

    Testato in browser Android 4.2 e Android Chrome.

    https://stackoverflow.com/a/6394497/4264

    L'unico caso che ho rilevato che continuava a zoomare era in Chrome con Impostazioni -> Accesibilità -> Scala del text superiore al 100%.

    Oggi è entrato in questo problema e potrebbe avere un aggiornamento del cromo che scende al di sotto del pipe che potrebbe risolverlo. Per il problema del cromo indicato da @Jo,

    no.28 jdd … @ chromium.org A partire da https://codereview.chromium.org/196133011/ , l'autozooming è distriggersto nei siti che dispongono di una visualizzazione ottimizzata per il mobile (ad esempio, "width = width-device" o fixed annotazione della visualizzazione della scala della pagina).

    Può ancora essere scorrimento automatico quando si focalizzano gli elementi modificabili su tali siti, per mantenere la visibilità dell'elemento, ma lo zoom sarà distriggersto. Questo andrà in diretta in M41 (ancora un buon numero di settimane da colpire il canale beta).

    Non abbiamo alcuna intenzione di impedire altrimenti l'autozooming per i siti desktop più recenti.

    A partire da questo momento, Chrome è v.40; v.41 è in BETA. Verrà effettuato il check-in per vedere se la messa a fuoco continua a essere persa sul browser Android Chrome.

    Sto guardando questo problema perché è qualcosa che mi ha irritato con la mia applicazione HTML5 Android. Posso offrire una mezza risposta. Vale a dire, come fermare la scalatura della pagina quando è focalizzato un field di text.

    Richiede Jquery Mobile:

     $('#textfield').textinput({preventFocusZoom:true}); 

    fa esattamente questo.

    Ma, come ho detto, questo solo risolve metà del problema. L'altra metà consente all'utente di ingrandire successivamente la pagina. La documentazione che ho trovato sembra suggerire che

      $('#textfield').textinput({preventFocusZoom:false}); 

    o

     $('#textfield').textinput('option','preventFocusZoom',false); 

    dovrei distriggersrla, ma non sono riuscito ad get entrambe le opzioni per lavorare. Non è un problema se stai portndo l'utente ad un'altra pagina dopo, ma di utilizzo limitato se, come me, stai solo andando a caricare il contenuto attraverso AJAX.

    EDIT: Anche se mirato a IOS,

     $.mobile.zoom.disable(); 

    Inoltre arresta lo zoom. In modo più generico. Ma sfortunatamente

     $.mobile.zoom.enable(); 

    Non riesce a ripristinare la funzionalità proprio come il codice precedente.

     font-size: 18px; 

    Questo lo ha risolto per il mio Nexus 7 (2011) che esegue Android 4.3.

    Questo problema esiste solo per me sul Nexus 7, i seguenti dispositivi sembrano felici con la dimensione del carattere: 16px:

    • HTC Desire Android 2.3.7
    • Nexus 4 Android 4.3

    Spero che questo aiuti qualcuno!

    Questo funziona where #inputbox è l'id dell'elemento module di input.

    Sto usando questo per interrompere una casella di ricerca da zoom automatico in IOS, è un mod del post precedente prima che l'evento di mouseover funziona solo la prima volta ma non innesca i tempi successivi. Godetevi questo è stato un vero tiratore di capelli …

     $("#inputbox").live('touchstart', function(e){ $('head meta[name=viewport]').remove(); $('head').prepend('<meta name="viewport" content="user-scalable=0" />'); } ); $("#inputbox").mousedown(zoomEnable); function zoomEnable(){ $('head meta[name=viewport]').remove(); $('head').prepend('<meta name="viewport" content="user-scalable=1" />'); } 

    Solo una nota laterale:

    La soluzione con il meta name="viewport" funziona perfettamente. Tuttavia, entrambi i browser nativi e Chrome in Android dispongono di un'impostazione di accessibilità denominata "Sovrascriva la richiesta del sito per controllare lo zoom". Se questa impostazione è impostata, nulla in HTML, CSS o JavaScript può disabilitare lo zoom.

    Hai bisogno di 2 cose:

    Utilizza un metatag come questo nella tua testa per evitare che l'utente ingrandisca:

     <meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no" /> 

    E poi nel tuo css metti qualcosa come segue per evitare che il browser si ingrandisca:

     * { font-size:16px; } 

    Fatto! Penso che il browser ridimensiona il tuo viewport in base al carattere più piccolo o qualcosa del genere. Forse qualcuno potrebbe spiegare meglio, ma ha funzionato 🙂

    Modello di lavoro

    Abbiamo questo lavoro su Android. Ecco la chiave: la dimensione del font sull'ingresso deve essere la dimensione corretta. Se sei pagina è 320px largo, allora hai bisogno di 16px size del carattere. Se sei dimensione 640px allora hai bisogno di 32px dimensione del carattere.

    Inoltre avete bisogno di quanto segue

    Versione 320 ampia

     <meta name="viewport" content="width=320, initial-scale=1, maximum-scale=1, minimum-scale=1" /> 

    640 versione larga

     <meta name="viewport" content="width=640, initial-scale=.5, maximum-scale=.5, minimum-scale=.5" /> 

    NOTA: QUESTO NON CONTIENE L'ATTRIBUZIONE SCALABILE UTENTE. QUELLO RISOLTA.

    Per coloro che cercano di bloccare lo zoom quando si tenta di concentrarsi su un field di input nascosto, è ansible rendere l'input nascosto come grande (o alless ampio) come l'area dello schermo (o l'area visualizzabile) – questo bloccava lo zoom.

    per esempio

    HIDDENinput.style.width = window.innerWidth;

    HIDDENinput.style.height = window.innerHeight; (opzionale)

    Questa può essere una buona risposta:

     input, textarea { max-width:100%; } 

    Non utilizzare <meta name=viewport content='user-scalable=no'>

    Non sono sicuro se puoi distriggersre lo zoom, ma puoi impostare una restrizione come questa

      <meta id="viewport" name="viewport" content="width=device-width,initial-scale=0.5,maximum-scale=0.5,minimum-scale=0.5,user-scalable=no"> 

    la massima scala = 0.5 e la scala minima = 0.5 dovrebbero fare il trucco. Ha funzionato per me.

    Se si imposta la dimensione del carattere di input a 16px, lo zoom si arresta. I browser per cellulari assumono qualcosa di less di 16px significa che gli utenti dovranno ingrandire, quindi perché non farlo io stesso.

      input[type='text'],input[type='number'],textarea {font-size:16px;} body{ -webkit-text-size-adjust:none;} 

    Puoi anche impostare il meta tag qui sotto ma impedisce la scalabilità dell'utente completamente.

     <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=0;"/> 

    Se si desidera ridimensionare l'utente ma distriggersre solo la scala di input, provare a eseguire questa operazione

     $("input[type=text], textarea").mouseover(zoomDisable).mousedown(zoomEnable); function zoomDisable(){ $('head meta[name=viewport]').remove(); $('head').prepend('<meta name="viewport" content="user-scalable=0" />'); } function zoomEnable(){ $('head meta[name=viewport]').remove(); $('head').prepend('<meta name="viewport" content="user-scalable=1" />'); } 

    provare anche questo

    Forse si potrebbe evitare lo zoom, ripristinando la scala dello zoom su 1.0? Sul mio Android (HTC Wildfire S), posso reimpostare lo zoom a 1.0 come così:

     $('meta[name=viewport]').attr('content', 'initial-scale=1.0, maximum-scale=0.05'); 

    ma questo port la visualizzazione a 0, 0 (l'angolo superiore sinistro della pagina). Così ho $().scrollLeft(...) e .scrollTop(...) tornare al form nuovamente.

    ( initial-scale=1.0, maximum-scale=0.05 è il mio valore iniziale della meta di visualizzazione).

    (Il motivo per cui faccio questo non è quello di impedire a Android di ingrandire, ma di ripristinare lo zoom in una scala conosciuta, a causa di altri bug Android che altrimenti screen.width danneggiare lo screen.width e altri valori correlati.)

    Prova questo, funziona sul mio dispositivo:

     <meta content="minimum-scale=1.0, width=device-width, maximum-scale=1.0, user-scalable=no" name="viewport" /> 

    Tuttavia, quando faccio doppio clic sopra la casella di input, la tastiera scivola e rende la pagina ridotta in altezza.

    Per caso ho scoperto che questo:

      input { line-height:40px; } 

    impedirà di ingrandire l'input sul mio Galaxy Nexus con Chrome per la versione Android 18, anche se questo potrebbe essere specifico per il mio caso:

     <meta name='viewport' data='width=800'> 

    quindi per un futuro riferimento, se tu arrivi qui tramite google, questa potrebbe essere una delle altre soluzioni.

    Ho avuto lo stesso problema (solo nel browser Chrome cromato). Ho risolto il problema come questo.

    1. Rileva l'utenteAgente e lega gli events onFocus e onBlur dei campi di text per modificare il contenuto meta di visualizzazione come segue

       if ((navigator.userAgent.match(/Android/i)) && (navigator.userAgent.toLowerCase().indexOf('chrome') > -1)) { isAndroidChrome = true; } var viewportmeta = document.querySelector('meta[name="viewport"]'); 
    2. OnFocus del field di text, ho impostato il seguente meta content viewportmeta.content = 'width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1';

    3. onBlur del field di text, ripristino il contenuto meta viewport in viewportmeta.content = 'width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1.4'; è ansible impostare la scala massima se lo si desidera o se si desidera che sia scalabile dall'utente, non impostare la scala massima

    Quando si modifica il trigger l'evento onFocus dell'ingresso, se la maximum-scale è 1 , non ingrandisce. Questo ha funzionato per me come un fascino. Spero che funziona anche per te.

    Come ha detto @soshmo, l' user-scalable non è un attributo che WebKit ama e quindi la sua inclusione causa WebKit a scartare l'integer tag di visualizzazione. Ho anche scoperto che questo è il caso di impostare la maximum-scale su qualsiasi cosa diversa da 1, e ciò non ha impedito lo zoom.

    Ripristinando il punto di viewport su each focus e evento di blur funzionato per me:

     var htmlWidth = parseInt($('html').outerWidth()); var screenDPI = parseInt(window.devicePixelRatio); var screenWidth = parseInt(screen.width); var screenHeight = parseInt(screen.height); var scaleVal = (((screenWidth * screenDPI) / htmlWidth)/screenDPI); $('input[type="text"], input[type="password"], input[type="email"]').each(function() { //unchained for clarity $(this).focus(function() { $('meta[name="viewport"]').attr('content', "initial-scale=' + scaleVal + ', maximum-scale=1, minimum-scale=' + (scaleVal) + ', width=device-width, height=device-height"); // Do something to manage scrolling the view (resetting the viewport also resets the scroll) $('html, body').scrollTop(($(this).offset().top - (screenHeight/3))); }); $(this).blur(function() { $('meta[name="viewport"]').attr('content', "initial-scale=' + scaleVal + ', maximum-scale=1, minimum-scale=' + (scaleVal) + ', width=device-width, height=device-height"); }); }); 

    Se ritieni che l'impostazione / il ripristino della viewport vale la pena verificare che WebKit accetta gli attributi del contenuto che utilizzi. Ci sono voluti un po 'di tempo per rendermi conto che utilizzando cose come l' user-scalable causato la viewport della viewport , quindi anche se il JavaScript funzionava, le modifiche non sono state compromesse.

    Impostare la properties; scortable user-scalable della vista sul touchstart ha fatto per me, non c'è bisogno di rimuovere quindi ri-aggiungere semplicemente cambiarlo su touchstart e poi triggersre nuovamente sulla sfocatura. Significa che l'utente non può zoomare mentre si concentra sul field ma un piccolo prezzo da pagare credo.

     var zoomEnable; zoomEnable = function() { $("head meta[name=viewport]").prop("content", "width=device-width, initial-scale=1.0, user-scalable=yes"); }; $("input[type='text']").on("touchstart", function(e) { $("head meta[name=viewport]").prop("content", "width=device-width, initial-scale=1.0, user-scalable=no"); }); $("input[type='text']").blur(zoomEnable); 

    Per Nexus 7 stavo ricevendo questo problema quando la mia query multimediale era –

    @media screen and (max-device-width: 600px) and (orientation : portrait)

    Quindi ho usato sotto la domanda di media per risolvere il problema –

    @media screen and (max-device-width: 600px) and (max-aspect-ratio: 13/9)

    Un po 'in ritardo per la festa, ma ho trascorso un integer pomeriggio ieri a fare i dadi prima di arrivare a questo post e ho capito che era una funzionalità / bug da Android. Così metterò la mia soluzione. Questo ha funzionato per me e permette comunque lo zoom utente:

    Meta:

     <meta id="meta1" name="viewport" content="width=device-width,initial-scale=1,minimal-ui"/> 

    CSS:

     html{ position:absolute; overflow:-moz-scrollbars-vertical; overflow-y:scroll; overflow-x:hidden; margin:0;padding:0;border:0; width:100%; height:100%; } body{ position: relative; width: 100%; height: 100%; min-height:100%; margin: 0; padding: 0; border: 0; } 

    Impostazione HTML in position:absolute e overflow-x:hidden fatto il trucco per me.

    Lavorato per la galassia 4:
    Aggiungere il codice al file dell'indice di intestazione HTML:

     <meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, user-scalable=no;user-scalable=0;"/> 

    Posso submit una risposta perché ho affrontato un problema simile e lo ho risolto.

    La mia condizione è sotto.

    Un'impostazione di una vista in html testa è

     <meta name="viewport" content="width=640"> 

    Gli agenti sono il browser predefinito di Android.
    Non sono Chrome, Firefox e Safari.
    Le versioni di Android sono sotto 4.2.x.

    I dettagli delle nostre situazioni non sono uguali ma penso che abbiano un problema essenzialmente uguale.

    Ho risolto l'aggiunta di "target-densitydpi = device-dpi" nel tag meta [name = viewport].

     <meta name="viewport" content="width=640, target-densitydpi=device-dpi"> 

    Provalo per favore.

    Ma devo dire che "target-densitydpi = device-dpi" avrebbe un effetto collaterale.

    Il caso difettoso è qui.

    1. Un browser OLDo OLD legge "target-densitydpi = device-dpi".
    2. Passa all'altra pagina che non ha properties; targetdensitydpi.
    3. Il browser inizia a rendere la pagina come "target-densitydpi = device-dpi".
    4. Così rende la pagina successiva in un fattore di scala sbagliato.

    Una soluzione di questo caso è quella di riscrivere la properties; targetdensitydpi a "media-dpi" da "device-dpi" usando javascript prima di andare alla pagina successiva.

    Un esempio che utilizza jQuery.

     <a href="go-to-the-other" class="resetDensityDpi">Other page</a> <script> $(function(){ $('.resetDensityDpi').click(function(){ var $meta = $('meta[name="viewport"]'); $meta.attr('content', $meta.attr('content').replace(/target-densitydpi=device-dpi/, 'target-densitydpi=medium-dpi')); return true; }); }); </script> 

    E … questo codice provoca un nuovo problema.
    Alcuni browser rendono i risultati del process javascript utilizzando i dati di cache quando tornano alla pagina precedente utilizzando un button di accesso indietro. Quindi visualizzano la pagina precedente come "target-densitydpi = media-dpi" NON come "target-densitydpi = device-dpi".

    Una soluzione di questo è solo l'opposto di quanto sopra.

     <script> $(function(){ var rollbackDensityDpi = function() { // disable back-forword-cache (bfcache) window.onunload = function(){}; var $meta = $('meta[name="viewport"]'); if ($meta.attr('content').match(/target-densitydpi=medium-dpi/)) { $meta.attr('content', $meta.attr('content').replace(/target-densitydpi=medium-dpi/, 'target-densitydpi=device-dpi')); } }; if (window.addEventListener) { window.addEventListener("load", rollbackDensityDpi, false); } else if (window.attachEvent) { window.attachEvent("onload", rollbackDensityDpi); } else { window.onload = rollbackDensityDpi; } }); </script> 

    Grazie.

    Mantenere il contenuto più stretto della window.

    Dovresti progettare la tua pagina fin dall'inizio con questo in mente, ma è del tutto efficace.

    La chiave è quella di utilizzare la @media css at-rule per consentire solo ai componenti di avere larghezze che conosci la schermata è abbastanza grande da contenere.

    Ad esempio, se si dispone di una width di contenuto impostata in modo che il text non sia troppo distribuito su un monitor più grande, assicurarsi che la width si applica solo alle schermate di grandi size:

     @media (min-width: 960px){ .content{ width : 960px; } } 

    O forse hai un'image che è 500px larga, potrebbe essere necessario hide su schermi più piccoli:

     @media (max-width: 500px){ .image{ display : none; } } 

    aggiungere questo meta tag al file html e risolverà il problema.

     <meta name="viewport" content="width=device-width, user-scalable=no" /> 

    aggiungendo questa linea risolto il problema per me in HTC desiderio 816 e SAMSUNG GALAXY S5.

    Questa può essere una soluzione a questo tipo di problemi

     <meta name="viewport" content="user-scale=no"/> <meta name="viewport" content="width=device-width"/> <meta name="viewport" content="width=device-width, maximum-scale=0.9"/> 

    Il mio consiglio sarebbe quello di dare un'occhiata alle pratiche migliori per lo sviluppo di web di android . Per essere più specifici, potrebbe essere necessario includere di più nel tuo meta tag per evitare che lo zoom compaia. Per esempio:

     <!-- set the screen width to the device width --> <!-- set the viewport to be non-zoomable --> <!-- fix the initial zoom to be 1:1 --> <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"> 
    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.