web-dev-qa-db-fra.com

Retour d'un dialogue ou d'une activité avec résultat

J'aimerais savoir si je peux geler l'activité en cours pendant que j'attends qu'une autre activité ou un autre dialogue (que ce soit le cas) se termine.

Je sais que je peux démarrer une activité pour obtenir des résultats et la gérer, mais le code après startActivityForResult () sera toujours exécuté.

c'est quelque chose que j'aimerais faire:

PopupDialog dialog = new PopupDialog(this,Android.R.style.Theme_Black_NoTitleBar);
dialog.show();
// wait here, and continue the code after the dialog has finishes
int result = getResultFromDialogSomehow();
if (result == 1){
    //do something
}else{
    //do something else
}

Je sais que cela doit paraître assez étrange, mais j'apprécierais vraiment que quiconque puisse me dire comment obtenir une telle fonctionnalité.

androidandroid-activitydialog
16
zidarsk8

Dans une boîte de dialogue Si vous voulez un résultat de boîte de dialogue alors votre chemin n’est pas le bon moyen d’obtenir un résultat de boîte de dialogue. À la place de votre chemin sous Android, il existe une méthode de rappel qui peut être exécutée après votre sélection de boutons de boîte de dialogue.

par exemple

AlertDialog.Builder builder = new AlertDialog.Builder(getDialogContext());
builder.setMessage("Message");
builder.setPositiveButton("Yes", new Dialog.OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog, int which) { 
        Toast.makeText(this, "Yes", Toast.LENGTH_SHORT).show();
        dialog.cancel();
    }

});

builder.setNegativeButton("No", new Dialog.OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog, int which) {
        Toast.makeText(this, "Yes", Toast.LENGTH_SHORT).show();
        dialog.cancel();

    }

});

builder.show();

Lorsque vous exécutez ce code, le code à l'intérieur de la méthode onClick ne sera pas exécuté, mais il s'exécutera lorsque vous cliquez sur les boutons de la boîte de dialogue. Lorsque vous cliquez sur l'un des boutons de la boîte de dialogue, vous obtenez une méthode de rappel onClick qui s'exécute.

9
Dharmendra

Vous pouvez aussi utiliser onActivityResult
Dans votre appel d'activité principale
startActivityForResult(intent, 1); //here 1 is the request code 

Dans votre classe de dialogue 

Intent intent = new Intent();
intent.putExtra(....) //add data if you need to pass something
setResult(2,intent); //Here 2 result code

donc votre activité principale

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data){
if (resultCode == 2 && requestCode ==1){
    //do something
}else{
    //do something else
}
}
9
Labeeb Panampullan

J'utilise un rappel dans ma boîte de dialogue pour renvoyer une chaîne ou une valeur sélectionnée par l'utilisateur.

c'est-à-dire implémenter une interface dans votre dialogue

3
Someone Somewhere

Pour ceux qui sont intéressés à implémenter une boîte de dialogue pour obtenir un résultat, mais sans en utilisant onActivityResult voici un exemple avec callbacks . De cette façon, vous pouvez appeler cette boîte de dialogue personnalisée de n'importe où et faire quelque chose en fonction du choix.

UN COURT MANIEMENT 

public void getDialog(Context context, String title, String body, 

    DialogInterface.OnClickListener listener){

        AlertDialog.Builder ab = new AlertDialog.Builder(context);
        ab
                .setTitle(title)
                .setMessage(body)
                .setPositiveButton("Yes", listener)
                .setNegativeButton("Cancel", listener)
        ;//.show();

        Dialog d=ab.create();
        d.setCanceledOnTouchOutside(false);

        d.show();
    }

    private void showDialog(){
        DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                switch (which){
                    case DialogInterface.BUTTON_POSITIVE:
                        //DO
                        break;

                    case DialogInterface.BUTTON_NEGATIVE:
                        //DO
                        break;
                }
            }
        };

        getDialog(
                this,
                "Delete",
                "Are you sure to delete the file?",
                dialogClickListener
        );

    }

Autre moyen , approprié si vous devez implémenter différentes variantes de boîtes de dialogue, car vous pouvez définir toutes les actions à un seul endroit.

MyDialog.Java 

public class MyDialog{

    public void deleteDialog(Context context){
        DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                switch (which){
                    case DialogInterface.BUTTON_POSITIVE:
                        if(listener!=null)
                            listener.onDeleteDialogResponse(true);
                        break;

                    case DialogInterface.BUTTON_NEGATIVE:
                        if(listener!=null)
                            listener.onDeleteDialogResponse(false);
                        break;
                }
            }
        };

        AlertDialog.Builder ab = new AlertDialog.Builder(context);
        ab.setMessage("Are you sure to delete?")
                .setPositiveButton("Yes", dialogClickListener)
                .setNegativeButton("Cancel", dialogClickListener)
                .show();


    }

/** my listner */
    public interface MyDialogListener{
        public void onDeleteDialogResponse(boolean respononse);
    }
    private MyDialogListener listener;

    public void setListener(MyDialogListener listener) {
        this.listener = listener;
    }

}

Utilisez-le comme ça 

private void showDialog(){        
        MyDialog dialog=new MyDialog();
        dialog.setListener(new MyDialog.MyDialogListener() {
            @Override
            public void onDeleteDialogResponse(boolean respononse) {
                if(respononse){
                    //toastMe("yessss");
                    //DO SOMETHING IF YES
                }else{
                    //toastMe("noooh");
                    //DO SOMETHING IF NO
                }
            }
        });

            dialog.deleteDialog(this);
}
1
chandima

Vous pouvez utiliser onActivityResult.

voici mon code.

  1. quand vous commencez l'activité. ex) vous appelez TestActivity de MainActivity, vous pouvez le faire comme ceci.

    Constants.REQUEST_CODE = 1000; // this is a global variable...and it must be a unique.
....
Intent intent = new Intent(this, TestActivity.class);
startActivityForResult(intent, Constants.REQUEST_CODE);

  2. dans TestActivity.

    public void onClickCancel() {
    setResult(Activity.RESULT_CANCELED);
    finish();
}

public void onClickConfirm() {
    setResult(Activity.RESULT_OK);
    finish();
}

  3. lorsque vous obtenez le code de résultat sur MainActivity, vous pouvez procéder comme suit.

    @Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == Constants.REQUEST_CODE && resultCode == Activity.RESULT_OK) {
        // todo something...
    } else if (requestCode == Constants.REQUEST_CODE && resultCode == Activity.RESULT_CANCELED) {
        // todo something...
    }
}
1
Rooney

Essayez de donner un bouton à la boîte de dialogue en implémentant une onClickListener avec un appel de méthode à quelque chose de votre activité. Le code de cette méthode ne sera exécuté que lorsque le bouton sera cliqué, vous voudrez donc appeler cette méthode avec un paramètre différent pour les boutons, en fonction de ce qu'ils ont fait.

1
thegrinner

Je ne comprends pas non plus complètement. Si vous voulez attraper le résultat d'une activité, vous pouvez simplement démarrer en indiquant la fonction "startActivityForResult". Si vous souhaitez afficher certains résultats dans la boîte de dialogue, vous pouvez simplement placer toutes les fonctions (qui doivent continuer après que vous avez appuyé sur le bouton de la boîte de dialogue) dans onClickListener de chaque bouton de la boîte de dialogue.

0
Menion Asamm

Je suis en retard de plusieurs années dans cette question, mais voici ma réponse, néanmoins.

J'ai une classe qui représente un formulaire/fichier. Il a un membre public "deleteDialog ()" qui permet de supprimer le fichier à la demande et renvoie une valeur "true" ou "false" à l'appelant.

Voici à quoi cela ressemble:

import Android.app.AlertDialog;
import Android.content.Context;
import Android.content.DialogInterface;

public class Form {

private Context mContext;
private CharSequence mFilePath;
private boolean mDeleted = false; // Set to "true" if this file is deleted. 
    /*...etc etc...*/

public boolean deleteDialog() {
    DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
        //@Override
        public void onClick(DialogInterface dialog, int which) {
            switch (which){
            case DialogInterface.BUTTON_POSITIVE:
                //Do your Yes progress
                mDeleted = mContext.deleteFile(mFilePath.toString());
                break;

            case DialogInterface.BUTTON_NEGATIVE:
                //Do your No progress
                mDeleted = false;
                break;
            }
        }
    };
    AlertDialog.Builder ab = new AlertDialog.Builder(mContext);
    ab.setMessage("Are you sure to delete?")
        .setPositiveButton("Yes", dialogClickListener)
        .setNegativeButton("Cancel", dialogClickListener)
        .show();
    return mDeleted;
}

Vous verrez que la variable de résultat - "mDeleted" - doit être membre de la classe englobante; cela est dû aux aléas étranges mais merveilleux de Java. où une classe interne (dans ce cas: "DialogInterface.OnClickListener dialogClickListener") peut hériter de l'état de sa classe externe.

0
Adam Weingarten