¿Cómo puedo llamar a finish() y otros métodos estáticos de una DialogFragment en la actividad que lo creó? He intentado pasar los mensajes de la OnClickLisener en el DialogFragment, fue en vano.

Tengo una muy simple aplicación, conssting de un MainActivity y DialogFragment:

    public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle arg0) {
    super.onCreate(arg0);
    setContentView(R.layout.activity);
    showDialog();
}
public void showDialog() {
    DialogFragment newFragment = new ConfirmDialog();
    newFragment.show(getFragmentManager(), "dialog");
}

}
Y el Diálogo es muy simple:

public class ConfirmDialog extends DialogFragment {
@Override
public AlertDialog onCreateDialog(Bundle savedInstanceState) {
    //Use the Builder class for convenient dialog construction
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage("Confirm you want to continue?")
           .setPositiveButton("Yes.", new DialogInterface.OnClickListener() {
               public void onClick(DialogInterface dialog, int id) {
                   //finish() MainActvity
                  }
               })
           .setNegativeButton("No.", new DialogInterface.OnClickListener() {
               public void onClick(DialogInterface dialog, int id) {
                 //Do nothing in MainActity
               }
           });
    //Create the AlertDialog object and return it
    return builder.create();
}

}

OriginalEl autor Hennaz | 2012-11-12

4 Comentarios

  1. 28

    Hay muchas opciones. Uno de ellos es definir una interfaz con un método único en el interior.

    1. Tiene el cuadro de diálogo llamada implementar la interfaz.
    2. Mantener una variable global que apunta a la persona que llama.
    3. Establecer la variable en el onAttach(Activity activity) método.
    4. Nula de que la variable en el onDetach() método.
    5. Llamar a la variable (miembro de interfaz) método en el onClick.

    Ejemplo:

    public class MainActivity extends Activity implements MyInterface { 
        //...
    
        @Override
        public void onChoose() { finish(); }
    
    }

    Y dentro de ConfirmDialog:

    public static interface MyInterface {
        public void onChoose();
    }
    
    private MyInterface mListener;
    
    @Override
    public void onAttach(Activity activity) {
        mListener = (MyInterface) activity;
        super.onAttach(activity);
    }
    
    @Override
    public void onDetach() {
        mListener = null;
        super.onDetach();
    }

    Y, a continuación, llamar a mListener.onChoose() cualquier lugar dentro de su clase.


    Sé que ha sido marcado como aceptado, pero pensé que podía dar más comentarios a la discusión.

    Una nota sobre el uso o no interfaces. Andy respuesta funciona como derecho como el mío, por lo tanto ¿por qué me dijo «Hay muchas opciones. Uno de ellos es…».

    Sin embargo, la razón por la que prefiero interfaces para este problema en particular es porque la mayoría de las veces vas a extender y reutilizar simple/común cuadros de diálogo de confirmación como que. hey es demasiado genérico como para ser «desperdiciado» (o peor: duplicado si las diferentes acciones del evento surgir).

    Menos que son mortales seguro de que usted va a usar que sólo una vez, para un objetivo (acabado), en general se debe evitar la conexión permanente (y simplificando) los detalles de la implementación de la Activity en su clase de diálogo. La flexibilidad, la abstracción y la eficiencia. Menos código para mantener.

    Y sí, hay un telltale que usted necesite que: el public palabra clave que usted está utilizando, especialmente si es en un archivo de clase, lo cual plantea para la reutilización (demasiado). De lo contrario, usted debe ocultar que la clase en el interior de su principal Activity, desde los detalles de implementación (haría) se refieren sólo a uno. También, usted sería la eliminación de la public palabra clave.

    Sí, se podría utilizar para más de una Activity, pero te limita a finish()ing. La interfaz le dará la flexibilidad para hacer lo que quiera en cada Activity. En otras palabras, es el ejecutor para definir cómo debe comportarse para ese evento. Auto-contiene detalles de implementación.

    Como una nota al margen, lo que yo hago es crear un paquete con todos los cuadros de diálogo que puede tener para mi aplicación. Para los cuadros de diálogo de confirmación como que, yo reutilización para diferentes mensajes y botones. I proporcionar valores por defecto, pero también permiten cambiar el uso de setArguments. Y mantener las interfaces relacionadas con así que no necesitas crear una interfaz para cada cuadro de diálogo. El ejecutor responde según la cual el diálogo se desencadena la «diálogos de devolución de llamada». La flexibilidad, la abstracción y la eficiencia, todo evitando las cosas con humor llamado Hydra y la Familia Real. Así. Al final, como he dicho, muchas opciones. No ingeniero, pero no simplificar demasiado, demasiado temprano (dejar espacio para el agraciado de expansión).

    Es más importante entender las ventajas y dificultades que la elección de esta o la otra respuesta.

    Gracias por tu ayuda un montón, hombre. Traté de ambas soluciones, pero este funciona muy bien. Que se haga esto fue sólo un poco de aplicación de pruebas, en mi aplicación real I plan para el uso de este nuevo y de nuevo y de modo que una Interfaz es la solución correcta, creo.
    Agrega una edición para aclarar por qué menciono el uso de los oyentes en este caso no es necesario. En cualquier caso, de cualquier manera está perfectamente bien y no ser regañado, de cualquier manera por otros desarrolladores Hennaz 🙂

    OriginalEl autor davidcesarino

  2. 21

    Aunque la cantidad de trabajo involucrado para hacer que la interfaz es pequeño, no veo por qué usted necesita llamar a finish() de la Actividad que la ha creado. Llamar finish() desde dentro de la DialogFragment sí será suficiente. Si usted necesita para enviar información de vuelta con él por algún motivo, usted siempre puede llamar a getActivity() y de la cadena de un método que existe en la Actividad. En última instancia no importa dónde usted llame a terminar, se desprenda la Fragmentar y destruir.

    Solo para aclarar cómo llamar a un método de su Actividad en su Fragmento

    ((YourActivity)getActivity()).someMethod(param);

    DEBE casta porque Java no sabe que la Actividad tiene cualquiera sea el método que quieres llamar. Que nunca usted decide ir con la buena suerte 🙂

    saludos

    EDITAR

    Agradezco su aclaración David. En general, usted está en lo correcto. Pero para ser honesto, en este caso, son incorrectos debido a la naturaleza de los Fragmentos y de su relación con la Actividad. De nuevo, usted va a ser esencialmente la creación de un oyente con el fin de ser llamado por un Fragmento que ya tiene una relación muy cercana con la clase de Actividad que se llevará a cabo por. Cualquiera de los beneficios proporcionados por no hecho nada a través de los oyentes se pierde en este caso. Usted todavía será la reescritura de código personalizado para cada cuadro de Diálogo. Mientras que en mi método, usted puede escribir un método en la clase de Actividad de tal forma que sólo tiene que escribir una vez.

    Sólo hay dos razones por las que considera necesario utilizar un Oyente:

    1. Si estás escribiendo código que otras personas van a utilizar. Así que usted proporciona una manera fácil de dar información, mientras que el mantenimiento de una cierta estructura (como los Androides DatePickerDialog).

    2. Si no hay ninguna conexión entre dos partes que están tratando de mantener conectados (como la interfaz gráfica de usuario en Java).

    Así que no estoy tratando de decir que David está mal en diciendo esto, y estoy agradecido de que él está trayendo porque es importante que la gente comprenda cuándo utilizarlos. Pero, de nuevo, en este caso, los beneficios que él menciona son inexistentes debido a la conexión entre los Fragmentos y la clase de Actividad. Sólo quería aclarar por qué creo que los oyentes no son necesarias aquí.

    He intentado esto, funciona gracias!
    +1 para el «por un Fragmento que ya tiene una relación muy cercana con la clase de Actividad que se llevará a cabo por«

    OriginalEl autor Andy

  3. 0

    Esto tal vez no es la mejor manera de cómo hacerlo, pero funciona. En crear referencia de su Actividad, a continuación, crear un método estático que se llama startActivity y acabado, y llamar a este método estático de su diálogo, si es «ok». El código a continuación:

    private static Activity mActivity = null;
    @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mActivity = this;
    }
    
    public static void staticMethodToCall(){
             Intent intent = new Intent(mActivity,Second.class);
             intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
             mActivity.startActivity(intent);
             mActivity.finish();
        }

    Y en el cuadro de diálogo

     builder.setMessage("Confirm you want to continue?")
               .setPositiveButton("Yes.", new DialogInterface.OnClickListener() {
                   public void onClick(DialogInterface dialog, int id) {
    
                       TheClassWithTheStaticMetod.staticMethodToCall();
                      }
                   })

    OriginalEl autor Mikelis Kaneps

  4. 0

    Lugar de:

    .setPositiveButton("Yes.", new DialogInterface.OnClickListener() { 
        public void onClick(DialogInterface dialog, int id) { 
            //finish() MainActvity
        }
    })

    Uso:

    .setPositiveButton("Yes.", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) { 
            //this gets the current activity.              
            Activity currentActivity = getActivity();
            //this finish() method ends the current activity.
            currentActivity.finish(); 
        }
    })

    OriginalEl autor Moses Katsina

Dejar respuesta

Please enter your comment!
Please enter your name here