Android: Wie man ein modales Dialogfeld oder eine ähnliche modale Verhalten?

Bekam ich einen modalen Dialog während der Verwendung:

setCancelable(false);

auf dem DialogFragment (nicht auf die DialogBuilder).

InformationsquelleAutor der Antwort meises

Entwicklern von Android-und iOS entschieden, dass Sie sind mächtig und schlau genug, um abzulehnen, Modales Dialog-Konzeption (das war auf dem Markt für viele-viele Jahre schon, und nicht stört niemanden vor), leider für uns.

Hier ist meine Lösung, es funktioniert Super:

    int pressedButtonID;
    private final Semaphore dialogSemaphore = new Semaphore(0, true);
    final Runnable mMyDialog = new Runnable()
    {
        public void run()
        {
            AlertDialog errorDialog = new AlertDialog.Builder( [your activity object here] ).create();
            errorDialog.setMessage("My dialog!");
            errorDialog.setButton("My Button1", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    pressedButtonID = MY_BUTTON_ID1;
                    dialogSemaphore.release();
                    }
                });
            errorDialog.setButton2("My Button2", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    pressedButtonID = MY_BUTTON_ID2;
                    dialogSemaphore.release();
                    }
                });
            errorDialog.setCancelable(false);
            errorDialog.show();
        }
    };

    public int ShowMyModalDialog()  //should be called from non-UI thread
    {
        pressedButtonID = MY_BUTTON_INVALID_ID;
        runOnUiThread(mMyDialog);
        try
        {
            dialogSemaphore.acquire();
        }
        catch (InterruptedException e)
        {
        }
        return pressedButtonID;
    }

InformationsquelleAutor der Antwort art926

Schließlich landete ich mit einem wirklich gerade und einfache Lösung.

Menschen, die vertraut mit der Win32-Programmierung vielleicht weiß, wie man implementieren Sie einen modalen dialog. In der Regel läuft eine geschachtelte Nachricht, die Schleife (durch GetMessage/PostMessage), wenn es ein Modaler dialog. Also versuchte ich, die Umsetzung eigener Modaler dialog in dieser traditionellen Weise.

Unter den ersten, die android nicht bieten Schnittstellen zu injizieren in ui-thread (message-loop), oder ich habe keins gefunden. Wenn ich sah in die Quelle, Looper.loop(), ich fand es ist genau das, was ich wollte. Aber immer noch, MessageQueue/Message noch keinen öffentlichen Schnittstellen. Zum Glück haben wir die Reflexion in java.
Im Grunde habe ich nur kopiert genau das, was Einlegen.loop() hast, blockiert es den workflow und noch richtig behandelt Ereignisse. Habe ich noch nicht getestet verschachtelte modalen dialog, aber theoretisch würde es auch funktionieren.

Hier ist mein Quellcode,

public class ModalDialog {

private boolean mChoice = false;        
private boolean mQuitModal = false;     

private Method mMsgQueueNextMethod = null;
private Field mMsgTargetFiled = null;

public ModalDialog() {
}

public void showAlertDialog(Context context, String info) {
    if (!prepareModal()) {
        return;
    }

    //build alert dialog
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(info);
    builder.setCancelable(false);
    builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            ModalDialog.this.mQuitModal = true;
            dialog.dismiss();
        }
    });

    AlertDialog alert = builder.create();
    alert.show();

    //run in modal mode
    doModal();
}

public boolean showConfirmDialog(Context context, String info) {
    if (!prepareModal()) {
        return false;
    }

    //reset choice
    mChoice = false;

    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(info);
    builder.setCancelable(false);
    builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            ModalDialog.this.mQuitModal = true;
            ModalDialog.this.mChoice = true;
            dialog.dismiss();
        }
    });

    builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            ModalDialog.this.mQuitModal = true;
            ModalDialog.this.mChoice = false;
            dialog.cancel();
        }
    });

    AlertDialog alert = builder.create();
    alert.show();

    doModal();
    return mChoice;
}

private boolean prepareModal() {
    Class<?> clsMsgQueue = null;
    Class<?> clsMessage = null;

    try {
        clsMsgQueue = Class.forName("android.os.MessageQueue");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
        return false;
    }

    try {
        clsMessage = Class.forName("android.os.Message");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
        return false;
    }

    try {
        mMsgQueueNextMethod = clsMsgQueue.getDeclaredMethod("next", new Class[]{});
    } catch (SecurityException e) {
        e.printStackTrace();
        return false;
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
        return false;
    }

    mMsgQueueNextMethod.setAccessible(true);

    try {
        mMsgTargetFiled = clsMessage.getDeclaredField("target");
    } catch (SecurityException e) {
        e.printStackTrace();
        return false;
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
        return false;
    }

    mMsgTargetFiled.setAccessible(true);
    return true;
}

private void doModal() {
    mQuitModal = false;

    //get message queue associated with main UI thread
    MessageQueue queue = Looper.myQueue();
    while (!mQuitModal) {
        //call queue.next(), might block
        Message msg = null;
        try {
            msg = (Message)mMsgQueueNextMethod.invoke(queue, new Object[]{});
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        if (null != msg) {
            Handler target = null;
            try {
                target = (Handler)mMsgTargetFiled.get(msg);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

            if (target == null) {
                //No target is a magic identifier for the quit message.
                mQuitModal = true;
            }

            target.dispatchMessage(msg);
            msg.recycle();
        }
    }
}
}

Hoffentlich helfen würde.

InformationsquelleAutor der Antwort fifth

One-Lösung ist :

1. Setzen Sie den gesamten code für jede ausgewählte Taste in den listener der jeweiligen Schaltfläche.
2. alert.show(); muss die Letzte code-Zeile in der aufrufenden Funktion die Warnung. Jeder code nach dieser Zeile nicht warten, um zu schließen Sie die Warnung, aber wird sofort ausgeführt.

Hoffnung Hilfe!

InformationsquelleAutor der Antwort Rambo VI

Ich habe eine ähnliche Lösung wie fünfteaber es ist ein bisschen
einfacher und braucht nicht nachdenken. Meine überlegung war, warum nicht
verwenden Sie eine Ausnahme, die zum beenden des Greifers. Also mein custom looper
liest sich wie folgt:

1) die Ausnahme, Die geworfen wird:

final class KillException extends RuntimeException {
}

2) Die custom-looper:

public final class KillLooper implements Runnable {
    private final static KillLooper DEFAULT = new KillLooper();

    private KillLooper() {
    }

    public static void loop() {
        try {
            Looper.loop();
        } catch (KillException x) {
            /* */
        }
    }

    public static void quit(View v) {
        v.post(KillLooper.DEFAULT);
    }

    public void run() {
        throw new KillException();
    }

}

Die Nutzung der custom looper ist ganz einfach. Angenommen
Sie haben eine dialog-foo, dann tun Sie einfach Folgendes
wo Sie wollen, rufen Sie das Dialogfeld foo Modal:

a) Wenn die Berufung in das foo:

foo.show();
KillLooper.loop();

In das Dialogfeld foo, wenn Sie das Programm verlassen möchten, Sie einfach
rufen Sie die quit-Methode der benutzerdefinierten looper. Das sieht
wie folgt:

b) Beim verlassen von foo:

dismiss();
KillLooper.quit(getContentView());

Ich habe vor kurzem gesehen, einige Probleme mit 5.1.1 Android,
nicht rufen Sie ein modales Dialogfeld aus dem Hauptmenü, statt post ein
Veranstaltung, fordert das modale Dialogfeld. Ohne die Buchung der
Hauptmenü stall, und ich habe gesehen, Looper::pollInner()
SIGSEGVs in meiner app.

InformationsquelleAutor der Antwort j4n bur53

Verwenden Sie einen BroadcastReceiver, ruft die nächste Methode in der Aktivität.

Tot-Ende der Tätigkeit code dialogFragment.show(fragmentTransaction, TAG); und weiter im onReceive()--ich bin nicht 100% positiv, aber ich würde legen Geld, startActivityForResult(); beruht genau auf diesem Konzept.

Bis diese Methode aufgerufen wird, von dem Empfänger, der code stand in der Wartezeit für Benutzer-Interaktion, ohne ANR.

DialogFragment die onCreateView-Methode

private static final String ACTION_CONTINUE = "com.package.name.action_continue";

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.fragment_dialog, container, false);
        Button ok_button = v.findViewById(R.id.dialog_ok_button);
        ok_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent();
                i.setAction(ACTION_CONTINUE);
                getActivity().getApplicationContext().sendBroadcast(i);
                dismiss();
            }
        });


    return v;
}

Diese Methode richtet sich auf den Aufbau einer DialogFrament extension-Klasse und dem Aufruf einer Instanz der Klasse durch die Aktivität.

Jedoch...

Einfache, klare, einfache und wirklich modal.

InformationsquelleAutor der Antwort me_