versioni - android wikipedia




Sta smettendo una domanda disapprovata? (20)

Passando al mio tentativo di imparare Android, ho appena letto quanto segue :

Domanda: l'utente ha la possibilità di uccidere l'applicazione a meno che non inseriamo un'opzione di menu per ucciderla? Se questa opzione non esiste, come può l'utente terminare l'applicazione?

Risposta: (Romain Guy): l'utente no, il sistema lo gestisce automaticamente. Questo è ciò che è il ciclo di vita dell'attività (specialmente onPause / onStop / onDestroy). Indipendentemente da ciò che fai, non mettere un pulsante dell'applicazione "esci" o "esci". È inutile con il modello di applicazione di Android. Ciò è anche contrario al modo in cui funzionano le applicazioni di base.

Hehe, per ogni passo che passo nel mondo di Android mi imbatto in una sorta di problema = (

A quanto pare, non è possibile chiudere un'applicazione in Android (ma il sistema Android può distruggere completamente la tua app quando lo si sente). Cosa succede con quello? Sto iniziando a pensare che sia impossibile scrivere un'app che funzioni come una "normale app" - che l'utente possa uscire dall'app quando decide di farlo. Non è qualcosa su cui basarsi il sistema operativo.

L'applicazione che sto cercando di creare non è un'applicazione per Android Market. Non è un'applicazione per "largo uso" da parte del pubblico in generale, è un'app aziendale che verrà utilizzata in un campo di attività molto ristretto.

In realtà non vedevo l'ora di sviluppare per la piattaforma Android, poiché affronta un sacco di problemi che esistono in Windows Mobile e .NET. Tuttavia, la scorsa settimana è stata un po 'una svolta per me ... Spero di non dover abbandonare Android, ma al momento non sembra molto buono = (

C'è un modo per farmi davvero chiudere l'applicazione?


Risposta: (Romain Guy): l'utente no, il sistema lo gestisce automaticamente. Questo è ciò che è il ciclo di vita dell'attività (specialmente onPause / onStop / onDestroy). Indipendentemente da ciò che fai, non mettere un pulsante dell'applicazione "esci" o "esci". È inutile con il modello di applicazione di Android. Ciò è anche contrario al modo in cui funzionano le applicazioni di base.

1: L'uscita totale di un'applicazione può essere generalmente non obbligatoria, ma non è inutile. Cosa succede se Windows non ha un'opzione di uscita? Il sistema sarebbe doggy lento come la memoria era piena e il sistema operativo doveva indovinare a quali programmi si era fatto. Non mi interessa cosa dicono Romain Guy o Larry Page e Sergey Brin - questi sono fatti indiscutibili: i sistemi corrono più lentamente quando devono uccidere i compiti per ottenere la loro memoria prima che una nuova app possa essere lanciata. Non puoi dirmi che non ci vuole tempo per uccidere un'app! Anche la luce proveniente da stelle lontane prendere tempo ... V'è un certo uso nel permettere all'utente di chiudere completamente le applicazioni.

2: Contrariamente a come funzionano le applicazioni di base? Cosa dovrebbe significare? Quando ho finito di eseguire un'app per ora, non sta più lavorando ... Sta solo aspettando di essere ucciso dal sistema operativo quando è necessaria la sua memoria.

In breve, c'è una netta differenza tra minimizzare ed uscire, e nessuno dei due colpisce bene per l'altro. Lasciamo un cacciavite in ogni vite? O una chiave in ogni porta? Lasciamo tutti i nostri elettrodomestici in alto fino a quando l'interruttore non soffia e abbiamo bisogno di accendere un altro apparecchio? Lasciamo la lavastoviglie piena di piatti, e ne tiriamo fuori ogni volta solo abbastanza per fare spazio a dei nuovi sporchi? Lasciamo tutte le macchine che corrono nel vialetto fino a quando - oh, non importa.

Se l'utente desidera ridurre a icona un'app, la cosa migliore è ridurla al minimo. Se un utente vuole uscire da un'app, allora è meglio uscire.

È accigliato? Questo è il punto di vista di Android: si accigliano. E molti molti sviluppatori indipendenti di rookie Android si accigliano.

Ma quando arriva fino in fondo, c'è una buona codifica e una cattiva programmazione. Vi sono buoni modelli di flusso di programma e ci sono modelli di flusso di programma non validi.

Lasciare programmi in memoria quando l'utente sa di aver finito con loro semplicemente non è un buon flusso di programma. Non ha assolutamente alcuno scopo e rallenta le cose quando si lanciano nuove app o quando le app in esecuzione allocano più memoria.

È un po 'come la tua auto: ci sono momenti in cui lo lasci correre, come fermarsi a una luce di stop, o forse il fast food che attraversa, o fermarsi allo sportello automatico. Ma ci sono altre situazioni in cui vorresti spegnerlo, come quando vai al lavoro, o al supermercato o anche a casa.

Allo stesso modo, se stai giocando e il telefono suona, sì. Metti in pausa il gioco e continua a farlo funzionare. Ma se l'utente ha finito il gioco per un po ', allora lasciatelo uscire.

Il pulsante di uscita su alcune applicazioni dovrebbe essere più in evidenza rispetto ad altri. I giochi, ad esempio, oi programmi in cui è probabile che l'utente desideri uscire completamente, dovrebbero avere un'uscita ovvia. Altri programmi, come, forse, i programmi di posta elettronica, dove l'uscita è un desiderio improbabile (in modo che possa continuare a controllare la posta elettronica), questi programmi non dovrebbero sprecare spazio di input di controllo principale con un'opzione di uscita, ma per un buon flusso del programma, dovrebbe avere un'opzione di uscita. Cosa succede se qualcuno decide che non vogliono che il loro programma di posta provi a controllare la posta elettronica quando si trovano in un'area con scarsa copertura, o magari in una chiamata Skype o altro? Lasciali uscire dal programma di posta elettronica, se lo desiderano!

Sospendere ed uscire sono due compiti vitali e nessuno dei due svolge il ruolo dell'altro.


Post del blog Quando includere un pulsante di uscita nelle app Android (suggerimento: mai) lo spiega molto, molto meglio di me. Vorrei che ogni sviluppatore Android lo avesse già letto.

estratti:

Nella mia esperienza, ciò che [gli utenti] vogliono veramente è: un modo inequivocabile per garantire che un'app smetta di consumare risorse (batteria, cicli della CPU, trasferimento dei dati, ecc.).

Molti utenti percepiscono che un pulsante di uscita implementa questo requisito e chiede che venga aggiunto. Gli sviluppatori, cercando di compiacere i loro utenti, ne aggiungono di buon grado uno. Poco dopo, entrambi falliscono.

  • Nella maggior parte dei casi, il pulsante di uscita chiama semplicemente Activity.finish() . Questo è esattamente equivalente a premere il pulsante Indietro. Esattamente. I servizi continuano a funzionare e continuano a verificarsi sondaggi. Gli utenti potrebbero pensare di aver ucciso l'app, ma non l'hanno fatto, e presto saranno ancora più infastiditi.
  • Il comportamento di uscita è ora ambiguo. Il pulsante di uscita dovrebbe chiudere l'attività o dovrebbe anche interrompere tutti i servizi, i ricevitori e gli allarmi associati? Cosa dovrebbe fare Back ? Cosa succede se colpiscono invece Casa ? Cosa succede se la tua app ha un widget? Il pulsante di uscita dovrebbe impedire anche l'aggiornamento?

La soluzione consiste nel fare in modo che il pulsante Indietro si comporti come ci si aspetterebbe dal pulsante di uscita. Meglio ancora, basta smettere di consumare risorse ogni volta che l'app non è visibile.

Vai avanti e leggi l'articolo completo.


Questa è una discussione interessante e perspicace con così tanti esperti che contribuiscono. Ritengo che questo post debba essere riavviato all'interno del sito Web principale di sviluppo Android, perché ruota attorno a uno dei progetti principali del sistema operativo Android.

Vorrei anche aggiungere i miei due centesimi qui.

Finora sono rimasto impressionato dal modo in cui Android gestiva gli eventi del ciclo di vita, portando il concetto di un'esperienza simile al web nelle app native.

Detto questo, credo ancora che dovrebbe esserci un pulsante Quit . Perché? ... non per me o Ted o qualcuno dei guru della tecnologia qui, ma al solo scopo di soddisfare una domanda degli utenti finali.

Anche se non sono un grande fan di Windows, ma a lungo hanno introdotto un concetto a cui la maggior parte degli utenti finali è abituato (un pulsante X) ... "Voglio smettere di eseguire un widget quando" I "vuole".

Ciò non significa che qualcuno (OS, sviluppatore?) Si prenderà cura di questo a sua discrezione ... significa semplicemente "dov'è il mio pulsante X rosso a cui sono abituato". La mia azione dovrebbe essere analoga a 'terminare una chiamata premendo un pulsante', 'spegnere il dispositivo premendo un pulsante', e così via e così via ... è una percezione. Porta una soddisfazione di per sé che la mia azione raggiunge davvero il suo scopo.

Anche se uno sviluppatore può spoofare questo comportamento usando i suggerimenti forniti qui, rimane comunque la percezione cioè che un'applicazione dovrebbe cessare completamente di funzionare (ora), da una fonte indipendente, attendibile e neutra (OS) su richiesta da parte dell'utente finale.


Questo alla fine arriverà alla tua domanda, ma prima voglio affrontare una serie di problemi che solleverai nei tuoi vari commenti alle varie risposte già date al momento in cui scrivo. Non ho intenzione di cambiare idea - piuttosto, questi sono qui per gli altri che vengono a leggere questo post in futuro.

Il punto è che non posso permettere che Android determini quando la mia app verrà terminata. quella deve essere la scelta dell'utente.

Milioni di persone sono perfettamente soddisfatte del modello in cui l'ambiente chiude l'applicazione secondo necessità. Questi utenti non pensano semplicemente a "terminare" l'app per Android, così come non pensano a "chiudere" una pagina Web o a "chiudere" un termostato.

Gli utenti di iPhone sono più o meno allo stesso modo, in quanto premendo il pulsante iPhone non necessariamente "senti" come l'app è stata terminata, dal momento che molte app per iPhone riprendono da dove l'utente era stato interrotto, anche se l'app era realmente chiusa (solo da iPhone consente un'app di terze parti alla volta, al momento).

Come ho detto sopra, nella mia app c'è un sacco di cose (i dati vengono PUSHed al dispositivo, gli elenchi con le attività che dovrebbero sempre essere lì, ecc.).

Non so che cosa significhi "elenchi con compiti che dovrebbero sempre essere lì", ma i "dati che vengono PUSHed al dispositivo" sono una finzione piacevole e non dovrebbero essere svolti da un'attività in ogni caso. Utilizzare un'attività pianificata (tramite AlarmManager ) per aggiornare i dati per la massima affidabilità.

I nostri utenti accedono e non possono farlo ogni volta che ricevono una telefonata e Android decide di uccidere l'app.

Ci sono molte applicazioni iPhone e Android che si occupano di questo. Di solito, è perché mantengono le credenziali di accesso, piuttosto che costringere gli utenti ad accedere ogni volta manualmente.

Ad esempio, vogliamo verificare gli aggiornamenti quando si esce dall'applicazione

Questo è un errore su qualsiasi sistema operativo. Per quel che ne sai, il motivo per cui la tua applicazione viene "abbandonata" è perché il sistema operativo si sta spegnendo, e quindi il tuo processo di aggiornamento fallirà nel mid-stream. In generale, non è una buona cosa. O controllare gli aggiornamenti all'avvio o controllare gli aggiornamenti in modo totalmente asincrono (ad esempio, tramite un'attività pianificata), mai in uscita.

Alcuni commenti suggeriscono che premere il pulsante Indietro non uccide affatto l'app (vedi il collegamento nella mia domanda sopra).

Premendo il pulsante INDIETRO non "uccide l'app". Termina l'attività visualizzata sullo schermo quando l'utente ha premuto il pulsante INDIETRO.

Dovrebbe terminare solo quando gli utenti vogliono terminarlo, mai e poi mai diversamente. Se non riesci a scrivere app che si comportano così in Android, allora penso che Android non possa essere utilizzato per scrivere app reali = (

Quindi nemmeno le applicazioni Web possono. O WebOS , se capisco il loro modello correttamente (non ho ancora avuto la possibilità di giocare con uno). In tutti questi, gli utenti non "terminano" nulla - se ne vanno. L'iPhone è un po 'diverso, in quanto consente attualmente solo una cosa di funzionare alla volta (con poche eccezioni), e quindi l'atto di lasciare implica una chiusura abbastanza immediata dell'app.

C'è un modo per farmi davvero chiudere l'applicazione?

Come tutti gli altri ti hanno detto, gli utenti (tramite BACK) o il tuo codice (tramite finish() ) possono chiudere l'attività in corso. Gli utenti generalmente non hanno bisogno di nient'altro, per applicazioni scritte correttamente, non più di quanto abbiano bisogno di un'opzione "esci" per l'utilizzo di applicazioni Web.

Non esistono due ambienti applicativi uguali, per definizione. Ciò significa che puoi vedere le tendenze negli ambienti quando ne nascono di nuovi e altri vengono sepolti.

Ad esempio, c'è un movimento crescente per cercare di eliminare la nozione di "file". La maggior parte delle applicazioni Web non obbliga gli utenti a pensare ai file. Le app per iPhone in genere non costringono gli utenti a pensare ai file. Le app Android generalmente non costringono gli utenti a pensare ai file. E così via.

Allo stesso modo, c'è un movimento crescente per cercare di eliminare la nozione di "terminare" un'app. La maggior parte delle applicazioni Web non obbliga l'utente a disconnettersi, ma piuttosto a disconnettere implicitamente l'utente dopo un periodo di inattività. Stessa cosa con Android, e in misura minore, iPhone (e forse WebOS).

Ciò richiede maggiore enfasi sulla progettazione delle applicazioni, concentrandosi sugli obiettivi di business e non attenendosi a un modello di implementazione legato a un ambiente applicativo precedente. Gli sviluppatori che non hanno il tempo o la voglia di farlo saranno frustrati dagli ambienti più recenti che interrompono il loro modello mentale esistente. Questa non è la colpa di nessuno dei due ambienti, non più di quanto sia colpa di una montagna per le tempeste che scorrono intorno ad essa piuttosto che attraverso di essa.

Ad esempio, alcuni ambienti di sviluppo, come Hypercard e Smalltalk, avevano l'applicazione e gli strumenti di sviluppo combinati in un'unica configurazione. Questo concetto non ha attecchito molto, al di fuori delle estensioni della lingua alle app (ad esempio, VBA in Excel , Lisp in AutoCAD ). Gli sviluppatori che hanno inventato modelli mentali che presumevano l'esistenza di strumenti di sviluppo nell'app stessa, quindi, hanno dovuto cambiare il loro modello o limitarsi agli ambienti in cui il loro modello sarebbe vero.

Quindi, quando scrivi:

Insieme ad altre cose disordinate che ho scoperto, penso che lo sviluppo della nostra app per Android non accadrà.

Questo sembrerebbe essere il migliore, per te, per ora. Allo stesso modo, vorrei consigliarti di tentare di trasferire la tua applicazione sul Web, dal momento che alcuni degli stessi problemi che hai segnalato con Android si trovano anche nelle applicazioni Web (ad esempio, nessuna "terminazione"). Oppure, al contrario, un giorno se porti la tua app sul Web, potresti scoprire che il flusso dell'applicazione Web potrebbe essere migliore per Android, e puoi rivisitare una porta Android in quel momento.


Smetti di pensare alla tua applicazione come un'applicazione monolitica. Si tratta di un set di schermate dell'interfaccia utente che l'utente può interagire con la "domanda" e le "funzioni" fornite tramite i servizi Android.

Non sapere cosa sia la tua misteriosa app "fa" non è davvero importante. Supponiamo che entri in tunnel in una intranet aziendale super sicura, eseguendo il monitoraggio o l'interazione e rimanga connesso fino a quando l'utente "chiude l'applicazione". Poiché il tuo reparto IT lo comanda, gli utenti devono essere molto consapevoli di quando sono IN o OUT dell'intranet. Quindi la tua mentalità è importante per gli utenti di "smettere".

Questo è semplice Crea un servizio che inserisce una notifica in corso nella barra delle notifiche che dice "Sono nella intranet o sono in esecuzione". Fai in modo che quel servizio esegua tutte le funzionalità necessarie per la tua applicazione. Avere attività che si legano a quel servizio per consentire ai tuoi utenti di accedere ai bit dell'interfaccia utente di cui hanno bisogno per interagire con la tua "applicazione". E avere un menu Android -> Esci (o disconnetti o qualsiasi altro) pulsante che dice al servizio di uscire, quindi chiude l'attività stessa.

Questo è, a tutti gli effetti, esattamente ciò che dici che vuoi. Fatto il modo Android. Guarda Google Talk o Google Maps Navigation per esempi di questa "uscita" è possibile mentalità. L'unica differenza è che premendo il pulsante Indietro fuori dall'attività potresti lasciare il processo UNIX in agguato nel caso in cui l'utente desideri ripristinare la tua applicazione. Questo non è molto diverso da un moderno sistema operativo che memorizza nella cache i file di recente accesso. Dopo aver chiuso il programma Windows, probabilmente le risorse più necessarie sono ancora in memoria, in attesa di essere sostituite da altre risorse mentre vengono caricate ora che non sono più necessarie. Android è la stessa cosa.

Davvero non vedo il tuo problema.


Ted, quello che stai cercando di realizzare può essere fatto, forse non proprio come lo stai pensando in questo momento.

Ti suggerisco di leggere su Attività e servizi. Smetti di usare il termine "app" e inizia a fare riferimento ai componenti, ad esempio Attività, Servizio. Penso che tu abbia solo bisogno di saperne di più sulla piattaforma Android; è un cambiamento di mentalità da un'app per PC standard. Il fatto che nessuno dei tuoi post abbia la parola "Attività" (a meno di una citazione di FAQ, cioè non le tue parole) in essi mi dice che devi leggerne un altro.


Vorrei solo aggiungere una correzione qui per i futuri lettori di questo thread. Questa particolare sfumatura mi è sfuggita per molto tempo, quindi voglio assicurarmi che nessuno di voi commetta gli stessi errori:

System.exit() non uccide la tua app se hai più di una attività in pila. Quello che succede in realtà è che il processo viene ucciso e riavviato immediatamente con una sola attività in pila. Questo è anche ciò che accade quando l'app viene uccisa dalla finestra di dialogo Chiudi forza o anche quando si tenta di terminare il processo da DDMS. Questo è un fatto completamente non documentato, per quanto ne so.

La risposta breve è, se vuoi uscire dalla tua applicazione, devi tenere traccia di tutte le attività nel tuo stack e finish() TUTTE quelle quando l'utente vuole uscire (e no, non c'è modo di scorrere attraverso lo stack delle attività, quindi devi gestirlo tu stesso). Anche questo in realtà non uccide il processo o eventuali riferimenti penzolanti che potresti avere. Termina semplicemente le attività. Inoltre, non sono sicuro che Process.killProcess(Process.myPid()) meglio; Non l'ho provato

Se, d'altra parte, è giusto che tu rimanga delle attività nel tuo stack, c'è un altro metodo che rende le cose super facili per te: Activity.moveTaskToBack(true) farà semplicemente uno sfondo del tuo processo e mostrerà la schermata principale.

La lunga risposta implica una spiegazione della filosofia alla base di questo comportamento. La filosofia nasce da una serie di presupposti:

  1. Prima di tutto, questo accade solo quando la tua app è in primo piano. Se è in background, il processo terminerà correttamente. Tuttavia, se è in primo piano, il sistema operativo presuppone che l'utente voglia continuare a fare qualsiasi cosa stia facendo. (Se stai provando ad uccidere il processo da DDMS, dovresti prima premere il pulsante Home e poi ucciderlo)
  2. Assume anche che ogni attività sia indipendente da tutte le altre attività. Questo è spesso vero, ad esempio nel caso in cui la tua app avvii l'attività del browser, che è completamente separata e non è stata scritta da te. L'attività del browser può o non può essere creata sulla stessa attività, a seconda dei suoi attributi manifest.
  3. Presuppone che ciascuna delle tue attività sia completamente autosufficiente e possa essere uccisa / ripristinata in un attimo. (Non mi piace questa particolare ipotesi, dal momento che la mia app ha molte attività che si basano su una grande quantità di dati memorizzati nella cache, troppo grandi per essere serializzati in modo efficiente durante onSaveInstanceState , ma andrà bene?) Per la maggior parte delle app Android ben scritte questo dovrebbe essere vero , dal momento che non sai mai quando la tua app verrà eliminata in background.
  4. Il fattore finale non è tanto un'ipotesi, ma piuttosto una limitazione del sistema operativo: uccidere l'app in modo esplicito equivale all'arresto dell'app, e allo stesso modo di Android uccidere l'app per recuperare la memoria. Questo culmina nel nostro colpo di grazia: poiché Android non può sapere se l'app è terminata o si è arrestata in modo anomalo o è stata uccisa in background, si presuppone che l'utente desideri tornare da dove è stato interrotto e così ActivityManager riavvia il processo.

Quando ci pensi, questo è appropriato per la piattaforma. Innanzitutto, questo è esattamente ciò che accade quando il processo viene ucciso in background e l'utente ritorna ad esso, quindi deve essere riavviato nel punto in cui è stato interrotto. In secondo luogo, questo è ciò che accade quando l'app si arresta in modo anomalo e presenta la temuta finestra di dialogo Chiudi forza.

Diciamo che voglio che i miei utenti siano in grado di scattare una foto e caricarla. Lancio l'attività fotocamera dalla mia attività e chiedo di restituire un'immagine. La fotocamera viene spinta nella parte superiore della mia attività corrente (anziché essere creata nella propria attività). Se la fotocamera ha un errore e si blocca, dovrebbe verificarsi un'interruzione dell'intera app? Dal punto di vista dell'utente, solo la fotocamera ha avuto esito negativo e devono essere restituiti alla loro attività precedente. Quindi riavvia semplicemente il processo con tutte le stesse attività nello stack, meno la fotocamera. Dal momento che le tue attività dovrebbero essere progettate in modo che possano essere uccise e ripristinate alla caduta di un cappello, questo non dovrebbe essere un problema. Sfortunatamente, non tutte le app possono essere progettate in questo modo, quindi è un problema per molti di noi, indipendentemente da quello che ti dicono Romain Guy o chiunque altro. Quindi, dobbiamo usare soluzioni alternative.

Quindi, il mio consiglio di chiusura:

  • Non cercare di uccidere il processo. O chiamare finish() su tutte le attività o chiamare moveTaskToBack(true) .
  • Se il tuo processo si blocca o viene ucciso, e se, come me, hai bisogno dei dati che erano in memoria e che ora sono persi, dovrai tornare all'attività di root. Per fare questo, dovresti chiamare startActivity() con un Intent che contiene il flag Intent.FLAG_ACTIVITY_CLEAR_TOP .
  • Se vuoi uccidere la tua app dalla prospettiva DDMS di Eclipse, è meglio non essere in primo piano, altrimenti si riavvierà da solo. Dovresti prima premere il pulsante Home e poi uccidere il processo.

Prima di tutto, non utilizzare mai mai System.exit (0). È come far dormire una persona dandogli un pugno sulla testa!

Secondo: sto affrontando questo problema. Prima di condividere la mia soluzione, voglio condividere i miei pensieri.

Penso che un "pulsante di uscita" sia stupido. Davvero veramente veramente stupido. E penso che anche gli utenti (consumatori) che chiedono un pulsante di uscita per la tua applicazione siano stupidi. Non capiscono come funziona il sistema operativo e come gestiscono le risorse (e fa un ottimo lavoro).

Penso che se si scrive un buon pezzo di codice che fa le cose giuste (aggiorna, salva e spinge) al momento giusto e alle condizioni e usando le cose corrette (Servizio e Ricevitore) funzionerà abbastanza bene e nessuno si lamenterà .

Ma per farlo devi studiare e imparare come funzionano le cose su Android. Ad ogni modo, questa è la mia soluzione per fornire agli utenti un "pulsante di uscita".

Ho creato un menu Opzioni sempre visibile in ogni attività (ho una super attività che lo fa).

Quando l'utente fa clic su quel pulsante, questo è ciò che accade:

Intent intent = new Intent(this, DashBoardActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

SharedPreferences settings = getSharedPreferences(getString(PREF_ID), Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(FORCE_EXIT_APPLICATION, true);

  // Commit the edits!
editor.commit();
startActivity(intent);
finish();

Quindi sto salvando in SharedPreferences che voglio uccidere la mia app e avvio un Intent. Per favore guarda quelle bandiere; quelli cancelleranno tutto il mio backstack chiamando la mia attività DashBoard che è la mia attività "casa".

Quindi nella mia Dashboard Activity eseguo questo metodo nel menu onResume:

private void checkIfForceKill() {

    // CHECK IF I NEED TO KILL THE APP

    // Restore preferences
    SharedPreferences settings = getSharedPreferences(
            getString(MXMSettingHolder.PREF_ID), Context.MODE_PRIVATE);
    boolean forceKill = settings.getBoolean(
            MusicSinglePaneActivity.FORCE_EXIT_APPLICATION, false);

    if (forceKill) {

        //CLEAR THE FORCE_EXIT SETTINGS
        SharedPreferences.Editor editor = settings.edit();
        editor.putBoolean(FORCE_EXIT_APPLICATION, false);

        // Commit the edits!
        editor.commit();

        //HERE STOP ALL YOUR SERVICES
        finish();
    }
}

E funzionerà abbastanza bene.

L'unica cosa che non capisco perché sta succedendo è che quando faccio l'ultimo traguardo (e ho controllato: sta seguendo tutto il flusso corretto di onPause → onStop → onDestroy) l'applicazione è ancora sull'attività recente (ma è vuoto).

Sembra che l'ultimo intento (che ha avviato DashboardActivity) sia ancora nel sistema.

Devo scavare di più per rimuoverlo.


Il ciclo di vita delle applicazioni Android è progettato per gli utenti di telefoni cellulari, non per gli utenti di computer.

Il ciclo di vita dell'app è il paradigma brutalmente semplicistico richiesto per trasformare un server Linux in un'appliance di consumo.

Android è Java su Linux, un vero e proprio OS server multipiattaforma. È così che si è diffuso così rapidamente. Il ciclo di vita dell'app racchiude la realtà sottostante del sistema operativo.

Per gli utenti mobili, le app sono appena installate o non installate. Non esiste il concetto di correre o uscire. Di fatto, i processi delle app sono pensati per essere eseguiti finché il sistema operativo li rilascia per le proprie risorse detenute.

Poiché si tratta di , chiunque stia leggendo questo è un utente di computer e deve disattivare il 90% delle proprie conoscenze per comprendere il ciclo di vita delle app mobili.


In ogni caso, se vuoi chiudere la tua domanda puoi sempre chiamare System.exit(0); .


Ogni volta che si passa alla pagina successiva attraverso l'intenzione, utilizzare:

`YourActivityname.this.finish()`;

Esempio:

Intent intent = new Intent(getApplicationContext(), SMS.class);

startActivity(intent);
MainActivity.this.finish();

In modo che nessuna attività sarà in esecuzione su sfondo e quando si vuole uscire dall'app, utilizzare:

MainActivity.this.finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
getParent().finish();

Questa uscita ha funzionato come un fascino per me :)


Quando concepisco un'applicazione in Android, la vedo così:

  • Stai lavorando con la tua applicazione
  • Il telefono squillò
  • Tu prendi la chiamata
  • Alla fine della chiamata, torni alla tua applicazione nello stesso posto in cui eri

Per fare ciò, è necessario solo il Backpulsante o il Homepulsante del telefono (sia con una pressione breve o lunga) e la barra di notifica.

Quando Backesco dall'applicazione, utilizzo solo il pulsante finché non ne sono uscito o il Homepulsante.

Ecco come penso che la maggior parte delle applicazioni siano concepite. Ma se ho bisogno di un qualche tipo di sessione o connessione, ho reso chiaro all'utente un pulsante di accesso / uscita e una notifica (barra del titolo o qualsiasi altra cosa). Questo è uno stile piuttosto diverso rispetto alla pura applicazione in stile "uscita".

Su PC, hai un desktop multi-GUI, e su Android, ovviamente hai multi-task, ma puoi visualizzare solo un'app alla volta (non considero i widget qui ^^). E su un telefono cellulare, in qualsiasi momento, potresti ricevere una notifica per qualcosa di più importante di quello che stai facendo.

Quindi l'intero concetto di un'applicazione si basa su qualcosa di diverso che "entra nell'applicazione - lavora - esce dall'applicazione".


Se non riesci a capire come rendere persistenti i tuoi dati / connessioni (e quindi la tua "domanda"), non sarai in grado di fare ciò che hai "bisogno" di fare con Android.

Coloro che scaricano quei piccoli App Killers di solito scoprono di non aiutare la durata della batteria o l'utilizzo della memoria, ma impediscono al sistema operativo di gestire la memoria in modo efficiente ...

http://android-developers.blogspot.com/2010/04/multitasking-android-way.html


Senza una funzione di uscita per lo sviluppatore dell'applicazione per uccidere la propria applicazione, la progettazione è pessima.

La mia applicazione deve consentire all'utente di modificare dinamicamente i dati dinamicamente durante il runtime e l'utente deve riavviare la mia applicazione per apportare l'effetto di modifica, ma Android non ha consentito al mio riavvio dell'applicazione da solo. Il sistema operativo Android ha un ciclo di vita delle applicazioni di progettazione molto negativo.


C'è un (relativamente) design semplice che ti permetterà di aggirare l'enigma di "uscita". Fai in modo che la tua app abbia uno stato "base" (attività) che è solo una schermata vuota. Sul primo onCreate dell'attività, puoi avviare un'altra attività in cui si trova la funzionalità principale della tua app. L'uscita può essere completata da finish () in questa seconda attività e tornare alla base di una schermata vuota. Il sistema operativo può mantenere questo schermo vuoto in memoria per tutto il tempo che vuole ...

In sostanza, poiché non puoi uscire dal sistema operativo, devi semplicemente trasformarti in un nulla creato da te stesso.


Come un'applicazione in un contesto Android è solo un gruppo di attività vagamente correlate, uscire da un'applicazione non ha molto senso. È possibile completare () un'attività e verrà disegnata la vista dell'attività precedente nella pila Attività.


Penso che il punto sia che non è necessario uscire dall'app a meno che non si disponga di software buggato. Android esce dall'app quando l'utente non la utilizza e il dispositivo richiede più memoria. Se hai un'app che deve eseguire un servizio in background, probabilmente vorrai un modo per disattivare il servizio.

Ad esempio, Google Listen continua a riprodurre podcast quando l'app non è visibile. Ma c'è sempre il pulsante di pausa per spegnere il podcast quando l'utente ha finito con esso. Se ricordo male, Listen, mette anche un collegamento nella barra delle notifiche in modo da poter sempre arrivare rapidamente al pulsante di pausa. Un altro esempio è un'app come un'app di Twitter, ad esempio, che esegue costantemente il polling di un servizio su Internet. Questi tipi di app dovrebbero davvero consentire all'utente di scegliere la frequenza con cui eseguire il polling del server o anche il polling in un thread in background.

Se è necessario disporre del codice che viene eseguito all'uscita, è possibile eseguire l'override di onPause (), onStop () o onDestroy () in base alle esigenze. http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle


Per chiudere un'app in qualsiasi momento usa FLAG_ACTIVITY_CLEAR_TOPflag in Intent e poisystem.exit();

O c'è un modo simile, ma senza system.exit()quando vuoi uscire chiama questo metodo:

public void exit() {
    startActivity(new Intent(this, HomeActivity.class).
    setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | IntentCompat.FLAG_ACTIVITY_CLEAR_TASK).putExtra(EXIT_FLAG, true));
}

Nel tuo HomeActivity.onCreate()codice seguente aggiungi

protected void onCreate(Bundle savedInstanceState) {
    if (getIntent().getBooleanExtra(EXIT_FLAG, false)) {
        if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) == 0) {
            finish();
        }
    }
......................

Questo funzionerà senza interrompere il ciclo di vita di Android.


Sono d'accordo con Ted. Capisco che uscire dall'applicazione non sia il "modo Android", ma non sembra che dovrebbe essere precluso. Ecco tre motivi per cui potresti volere una vera uscita per l'applicazione (non solo l'attività):

  1. L'utente potrebbe volere il controllo su quale app viene uccisa in caso di memoria insufficiente. Se l'app importante A è in esecuzione in background, allora potresti voler uscire dall'app B quando hai finito, in modo che l'app A non venga uccisa dal sistema operativo.

  2. Se la tua applicazione ha dati sensibili memorizzati nella cache, potresti voler uccidere l'app in modo che un app virus / worm / canaglia non possa farcela. So che il modello di sicurezza dovrebbe impedirlo, ma nel caso in cui ...

  3. Se l'applicazione utilizza risorse (come rete, CPU, sensori, ecc.) Che potrebbero influire negativamente sul telefono, allora un modo per assicurarsi che tali risorse vengano liberate è di uscire dall'applicazione. Capisco che le app ben educate dovrebbero liberare risorse quando non sono necessarie. Ma ancora una volta, uscire dall'applicazione sembra un modo ragionevole per garantirlo.


Spero che le cose cambino nel tempo. L'utente dovrebbe essere in grado di uccidere un'app o un processo se la procedura dell'app è corretta in modo sandbox dal sistema operativo. Esiste il concetto che le app dovrebbero essere scritte alla perfezione o l'utente utilizzerà solo le app che seguono tutti i consigli SDK. Penso che sia un compito arduo.







android