setgravity - toast android make text




Come evitare sovrapposizioni multiple di pane tostato (5)

Ho utilizzato un "myToast" comune che uso " myToast.cancel() prima di pubblicare un nuovo brindisi. Per Android v2.3 e myToast.cancel() precedenti, funziona myToast.cancel() . Quando deve essere inviato un nuovo brindisi, quello vecchio , se è ancora sullo schermo, viene cancellato (e scompare immediatamente) per essere sostituito con il nuovo brindisi, evitando così di impilare un mucchio di toast se l'utente preme un tasto più volte che necessita dell'avviso (e di altre condizioni). caso viene visualizzato un brindisi quando viene premuto un tasto sbagliato e un altro viene visualizzato se non viene premuto il tasto Cancella.

Per Android 4.0 e 4.1, l'emissione di un myToast.cancel() prima del prossimo brindisi uccide sia il brindisi corrente sia quello successivo. L'attuale cancel() API indica che annulla l'attuale E il prossimo brindisi (che sembra piuttosto stupido). Perché cancellare un brindisi che vuoi mettere su?

Qualche idea su come cancellare funziona in modo coerente tra le versioni di Android (e il modo in cui funziona nella v2.3 e precedenti)?

Proverò un inelegante sistema dual toast con tracciamento per il quale è in uso il toast, ma sembra un tale problema aggirare questo cattivo comportamento in 4.x per ottenere ciò che funziona perfettamente e logicamente nelle versioni precedenti di Android.

Ok, l'ho risolto, ma non è così pulito come avrei voluto. Ho implementato un approccio dual toast, in cui si alterna tra due toast. Per prima cosa definiamo i toast per l'attività prima di OnCreate :

Toast toast0;
Toast toast1;
private static boolean lastToast0 = true;

In OnCreate:

toast0 = new Toast(getApplicationContext());
toast0.cancel();
toast1 = new Toast(getApplicationContext());
toast1.cancel();

E infine, quando ho bisogno di visualizzare il brindisi e cancellare il brindisi precedente allo stesso tempo, uso qualcosa di simile a:

if (lastToast0) {
    toast0.cancel();
    toast1.setDuration(Toast.LENGTH_LONG);
    toast1.setText("new message");
    toast1.show();
    lastToast0 = false;
} else {
    toast1.cancel();
    toast0.setDuration(Toast.LENGTH_LONG);
    toast0.setText("new message");
    toast0.show();
    lastToast0 = true;
}

Se devi semplicemente cancellare un toast esistente (prima che scada) usa:

toast0.cancel();
toast1.cancel();

Testato su Nexus 7 (4.1), Emulator 4.0 e diversi dispositivi con Android 2.2, 2.3.


Creare un oggetto Toast:

Toast toastobject=null;

Ora usa il codice seguente per visualizzare il brindisi. Questo funzionerà trovare per me

    int index = clickCounter-1;


    if(toastobject!= null)
            {
                toastobject.cancel();
            }
            toastobject = Toast.makeText(this,"Toast Text" , Toast.LENGTH_SHORT);
            listItems.remove(index);
            toastobject.show();

Ecco la mia risposta copiata da un'altra domanda simile qui:

  • Android cancella Toast quando si esce dall'app e quando viene visualizzato il brindisi

La classe Boast realizza esattamente ciò di cui hai bisogno.

Il trucco è di tenere traccia dell'ultimo Toast che è stato mostrato e di cancellare quello.

Quello che ho fatto è creare un wrapper Toast , che contenga un riferimento statico all'ultimo Toast visualizzato.

Quando ho bisogno di mostrarne uno nuovo, prima cancello il riferimento statico, prima di mostrare quello nuovo (e di salvarlo nello statico).

Ecco il codice completo del wrapper Boast ho creato: riproduce abbastanza metodi Toast da usarlo. Per impostazione predefinita, Boast annulla il precedente, quindi non crei una coda di Toast in attesa di essere visualizzata.

Se vuoi solo sapere come cancellare le notifiche quando esci dall'app, troverai molto aiuto.

package mobi.glowworm.lib.ui.widget;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.Resources;
import android.support.annotation.Nullable;
import android.widget.Toast;

import java.lang.ref.WeakReference;

/**
 * {@link Toast} decorator allowing for easy cancellation of notifications. Use this class if you
 * want subsequent Toast notifications to overwrite current ones. </p>
 * <p/>
 * By default, a current {@link Boast} notification will be cancelled by a subsequent notification.
 * This default behaviour can be changed by calling certain methods like {@link #show(boolean)}.
 */
public class Boast {
    /**
     * Keeps track of certain Boast notifications that may need to be cancelled. This functionality
     * is only offered by some of the methods in this class.
     * <p>
     * Uses a {@link WeakReference} to avoid leaking the activity context used to show the original {@link Toast}.
     */
    @Nullable
    private volatile static WeakReference<Boast> weakBoast = null;

    @Nullable
    private static Boast getGlobalBoast() {
        if (weakBoast == null) {
            return null;
        }

        return weakBoast.get();
    }

    private static void setGlobalBoast(@Nullable Boast globalBoast) {
        Boast.weakBoast = new WeakReference<>(globalBoast);
    }


    // ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Internal reference to the {@link Toast} object that will be displayed.
     */
    private Toast internalToast;

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Private constructor creates a new {@link Boast} from a given {@link Toast}.
     *
     * @throws NullPointerException if the parameter is <code>null</code>.
     */
    private Boast(Toast toast) {
        // null check
        if (toast == null) {
            throw new NullPointerException("Boast.Boast(Toast) requires a non-null parameter.");
        }

        internalToast = toast;
    }

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Make a standard {@link Boast} that just contains a text view.
     *
     * @param context  The context to use. Usually your {@link android.app.Application} or
     *                 {@link android.app.Activity} object.
     * @param text     The text to show. Can be formatted text.
     * @param duration How long to display the message. Either {@link Toast#LENGTH_SHORT} or
     *                 {@link Toast#LENGTH_LONG}
     */
    @SuppressLint("ShowToast")
    public static Boast makeText(Context context, CharSequence text, int duration) {
        return new Boast(Toast.makeText(context, text, duration));
    }

    /**
     * Make a standard {@link Boast} that just contains a text view with the text from a resource.
     *
     * @param context  The context to use. Usually your {@link android.app.Application} or
     *                 {@link android.app.Activity} object.
     * @param resId    The resource id of the string resource to use. Can be formatted text.
     * @param duration How long to display the message. Either {@link Toast#LENGTH_SHORT} or
     *                 {@link Toast#LENGTH_LONG}
     * @throws Resources.NotFoundException if the resource can't be found.
     */
    @SuppressLint("ShowToast")
    public static Boast makeText(Context context, int resId, int duration)
            throws Resources.NotFoundException {
        return new Boast(Toast.makeText(context, resId, duration));
    }

    /**
     * Make a standard {@link Boast} that just contains a text view. Duration defaults to
     * {@link Toast#LENGTH_SHORT}.
     *
     * @param context The context to use. Usually your {@link android.app.Application} or
     *                {@link android.app.Activity} object.
     * @param text    The text to show. Can be formatted text.
     */
    @SuppressLint("ShowToast")
    public static Boast makeText(Context context, CharSequence text) {
        return new Boast(Toast.makeText(context, text, Toast.LENGTH_SHORT));
    }

    /**
     * Make a standard {@link Boast} that just contains a text view with the text from a resource.
     * Duration defaults to {@link Toast#LENGTH_SHORT}.
     *
     * @param context The context to use. Usually your {@link android.app.Application} or
     *                {@link android.app.Activity} object.
     * @param resId   The resource id of the string resource to use. Can be formatted text.
     * @throws Resources.NotFoundException if the resource can't be found.
     */
    @SuppressLint("ShowToast")
    public static Boast makeText(Context context, int resId) throws Resources.NotFoundException {
        return new Boast(Toast.makeText(context, resId, Toast.LENGTH_SHORT));
    }

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Show a standard {@link Boast} that just contains a text view.
     *
     * @param context  The context to use. Usually your {@link android.app.Application} or
     *                 {@link android.app.Activity} object.
     * @param text     The text to show. Can be formatted text.
     * @param duration How long to display the message. Either {@link Toast#LENGTH_SHORT} or
     *                 {@link Toast#LENGTH_LONG}
     */
    public static void showText(Context context, CharSequence text, int duration) {
        Boast.makeText(context, text, duration).show();
    }

    /**
     * Show a standard {@link Boast} that just contains a text view with the text from a resource.
     *
     * @param context  The context to use. Usually your {@link android.app.Application} or
     *                 {@link android.app.Activity} object.
     * @param resId    The resource id of the string resource to use. Can be formatted text.
     * @param duration How long to display the message. Either {@link Toast#LENGTH_SHORT} or
     *                 {@link Toast#LENGTH_LONG}
     * @throws Resources.NotFoundException if the resource can't be found.
     */
    public static void showText(Context context, int resId, int duration)
            throws Resources.NotFoundException {
        Boast.makeText(context, resId, duration).show();
    }

    /**
     * Show a standard {@link Boast} that just contains a text view. Duration defaults to
     * {@link Toast#LENGTH_SHORT}.
     *
     * @param context The context to use. Usually your {@link android.app.Application} or
     *                {@link android.app.Activity} object.
     * @param text    The text to show. Can be formatted text.
     */
    public static void showText(Context context, CharSequence text) {
        Boast.makeText(context, text, Toast.LENGTH_SHORT).show();
    }

    /**
     * Show a standard {@link Boast} that just contains a text view with the text from a resource.
     * Duration defaults to {@link Toast#LENGTH_SHORT}.
     *
     * @param context The context to use. Usually your {@link android.app.Application} or
     *                {@link android.app.Activity} object.
     * @param resId   The resource id of the string resource to use. Can be formatted text.
     * @throws Resources.NotFoundException if the resource can't be found.
     */
    public static void showText(Context context, int resId) throws Resources.NotFoundException {
        Boast.makeText(context, resId, Toast.LENGTH_SHORT).show();
    }

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Close the view if it's showing, or don't show it if it isn't showing yet. You do not normally
     * have to call this. Normally view will disappear on its own after the appropriate duration.
     */
    public void cancel() {
        internalToast.cancel();
    }

    /**
     * Show the view for the specified duration. By default, this method cancels any current
     * notification to immediately display the new one. For conventional {@link Toast#show()}
     * queueing behaviour, use method {@link #show(boolean)}.
     *
     * @see #show(boolean)
     */
    public void show() {
        show(true);
    }

    /**
     * Show the view for the specified duration. This method can be used to cancel the current
     * notification, or to queue up notifications.
     *
     * @param cancelCurrent <code>true</code> to cancel any current notification and replace it with this new
     *                      one
     * @see #show()
     */
    public void show(boolean cancelCurrent) {
        // cancel current
        if (cancelCurrent) {
            final Boast cachedGlobalBoast = getGlobalBoast();
            if ((cachedGlobalBoast != null)) {
                cachedGlobalBoast.cancel();
            }
        }

        // save an instance of this current notification
        setGlobalBoast(this);

        internalToast.show();
    }

}

La soluzione di nandeesh non ha funzionato per te? La sua soluzione sarebbe più pulita rispetto all'utilizzo di due diversi toast.

Ad esempio, (espandendo la sua risposta) prima di onCreate dichiareremmo il brindisi:

private Toast myToast;

e su onCreate dovremmo inizializzarlo usando makeToast (altrimenti avremmo un errore):

myToast = Toast.makeText(getApplicationContext(), null, Toast.LENGTH_SHORT);

e ogni volta che vogliamo mostrare un brindisi, chiamiamo semplicemente:

myToast.setText("some text");
myToast.show();

e questo sostituirà correttamente il toast precedente.


Questa mia soluzione funziona perfettamente sia per le versioni 4. * e 2.3 Android

static Toast toast;
.....

if (toast != null)
    toast.cancel();

boolean condition = Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB;
if ((toast == null && condition) || !condition)
    toast = Toast.makeText(context, text, Toast.LENGTH_LONG);
if ((toast != null && condition))
    toast.setText(text);
toast.show();





toast