Tener una sólida experiencia en la que no es Java y no Android, yo estoy aprendiendo Android.

Tengo un montón de confusión con las diferentes áreas, una de ellas es cómo manejar clics de botón. Hay al menos 4 manera de hacer que (!!!), ellos se enumeran brevemente aquí

para la consistencia de propósito voy a la lista de ellos:

  1. Un miembro de la View.OnClickListener de la clase en la actividad y asignar a una instancia que se encargará de onClick lógica en el onCreate método de actividad.

  2. Crear ‘onClickListener’ en el ‘onCreate de la actividad método y asignar el botón con setOnClickListener

  3. Implementar ‘onClickListener’ en la misma actividad y asignar ‘este’ como un detector para el botón. Para el caso si la actividad tiene pocos botones, botón de identificación deben ser analizadas para ejecutar ‘onClick’ controlador para el botón apropiado

  4. Han método público sobre la actividad que implementa ‘onClick’ de la lógica y de asignar el botón en la actividad de la declaración xml

Pregunta #1:

Son aquellas que todos los métodos, hay alguna otra opción? (No se necesita ningún otro, sólo por curiosidad)

Para mí, de la manera más intuitiva sería el último: se requiere la menor cantidad de código escrito y es la más legible (al menos para mí).

Aunque, no veo este enfoque se utiliza ampliamente. ¿Cuáles son los contras de usar?

Pregunta #2:

¿Cuáles son los pros y los contras de cada uno de estos métodos? Por favor, comparta su experiencia o un buen enlace.

Cualquier opinión es bienvenida!

P. S. he probado a Google y buscar algo para este tema, pero lo único que he encontrado son la descripción de «cómo» hacerlo, no se por qué es bueno o malo.

InformationsquelleAutor Budda | 2013-02-08

10 Comentarios

  1. 133

    Pregunta 1:
    Por desgracia, la única en la que dices que es más intuitiva es la menos utilizada en Android. Como yo lo entiendo, debe separar la interfaz de usuario (XML) y computacional de la funcionalidad (Archivos de Clase Java). También se hace para facilitar la depuración. En realidad, es mucho más fácil de leer y pensar acerca de Android de la omi.

    Pregunta 2:
    Creo que los dos utilizan principalmente son #2 y #3. Voy a utilizar un Botón de clickButton como un ejemplo.

    2

    es en la forma de una clase anónima.

    Button clickButton = (Button) findViewById(R.id.clickButton);
    clickButton.setOnClickListener( new OnClickListener() {
    
                @Override
                public void onClick(View v) {
                    //TODO Auto-generated method stub
                    ***Do what you want with the click here***
                }
            });

    Este es mi favorito, ya que tiene el método onClick cerca de donde el botón variable se estableció con el findViewById. Me parece muy limpio y ordenado, que todo lo que trata con este clickButton Botón View se encuentra aquí.

    A un estafador que mi compañero de trabajo comentarios, es que imagine que tiene muchos puntos de vista que necesita onclick oyente. Usted puede ver que su onCreate será un proceso muy largo en longitud. Así que ¿por qué le gusta usar:

    3

    Decir tiene, 5 clickButtons:

    Asegúrese de que su Actividad/Fragmento de implementar OnClickListener

    //in OnCreate
    
    Button mClickButton1 = (Button)findViewById(R.id.clickButton1);
    mClickButton1.setOnClickListener(this);
    Button mClickButton2 = (Button)findViewById(R.id.clickButton2);
    mClickButton2.setOnClickListener(this);
    Button mClickButton3 = (Button)findViewById(R.id.clickButton3);
    mClickButton3.setOnClickListener(this);
    Button mClickButton4 = (Button)findViewById(R.id.clickButton4);
    mClickButton4.setOnClickListener(this);
    Button mClickButton5 = (Button)findViewById(R.id.clickButton5);
    mClickButton5.setOnClickListener(this);
    
    
    //somewhere else in your code
    
    public void onClick(View v) {
        switch (v.getId()) {
            case  R.id.clickButton1: {
                //do something for button 1 click
                break;
            }
    
            case R.id.clickButton2: {
                //do something for button 2 click
                break;
            }
    
            //.... etc
        }
    }

    De esta manera ya que mi compañero de trabajo se explica es más prolijo en sus ojos, como todos los onClick cálculo se maneja en un solo lugar y no se empujen el método onCreate. Pero el inconveniente que veo es, que el:

    1. puntos de vista propios,
    2. y cualquier otro objeto que pueda ser ubicado en onCreate utilizado por el método onClick tendrán que ser realizados en un campo.

    Hágamelo saber si usted quisiera más información. No contesté a su pregunta plenamente, ya que ésta es una buena pregunta larga. Y si me encuentro con algunos de los sitios que voy a ampliar mi respuesta, ahora mismo sólo estoy dando un poco de experiencia.

    • Para la opción 2, usted querrá hacer es: clickButton.setOnClickListener( new View.OnClickListener() {@Override public void onClick(View v) { //TODO lo que quieres hacer } }); para ayudar a resolver OnClickListener
    • La opción 3 es probablemente el más limpio y más fácil de extender con patrón MVP.
    • Opción 2 todavía puede producir onCreate() que no es muy largo. El oyente haga clic en tareas y clases anónimas puede ser factorizado a cabo en un método auxiliar que se llama de onCreate().
    • Este ejemplo no funciona
    • Usted no tiene que hacerlo. Añadir extensión a la Clase de Actividad como » implementa la Vista.OnClickListener «.
  2. 10

    #1 yo uso la última con frecuencia al tener los botones en el diseño que no se generan (pero estática obviamente).

    Si se utiliza en la práctica y en una aplicación de negocios, prestar más atención aquí, porque el uso de fuente obfuscater como ProGuard, deberá marcar estos métodos en su actividad como para no ser ofuscado.

    Para el archivo de algún tipo de tiempo de compilación de seguridad con este enfoque, eche un vistazo a Android Lint (ejemplo).


    #2 Pros y los contras para todos métodos son casi los mismos y la lección debería ser:

    Utilizar lo que cada vez es más apropiado o se siente más intuitiva para usted.

    Si usted tiene que asignar la misma OnClickListener a múltiples instancias de botón, guardar en la clase-ámbito de aplicación (#1). Si usted necesita un simple detector de un Botón, hacer un anónimo aplicación:

    button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            //Take action.
        }
    });

    Que tienden a no aplicar la OnClickListener en la actividad, esto se hace un poco confuso de vez en cuando (sobre todo cuando se implementan varios otros eventos y controladores, nadie sabe lo que this está haciendo).

  3. 8

    Yo prefiero la opción 4, pero no tiene sentido intuitivo para mí porque tengo que hacer demasiado trabajo en Grails, Groovy, y JavaFX. La «magia» de las conexiones entre la vista y el controlador son comunes en todos. Es importante indicar el nombre del método así:

    En la vista,agregue el método onClick del botón o de otro widget:

        android:clickable="true"
        android:onClick="onButtonClickCancel"

    A continuación, en la clase, manejar el método:

    public void onButtonClickCancel(View view) {
        Toast.makeText(this, "Cancel pressed", Toast.LENGTH_LONG).show();
    }

    De nuevo, el nombre que el método claramente, algo que debe hacer, de todos modos, y el mantenimiento se convierte en una segunda naturaleza.

    Una de las grandes ventajas es que se puede escribir pruebas unitarias ahora para el método. Opción 1 puede hacer esto, pero 2 y 3 son más difíciles.

    • Voy a waffle un poco y sugieren una quinta opción (no, no, protagonizada por Bruce Willis 🙂 ), una variante de la opción 2: uso de una clase de moderador en un Modelo-Vista-Presentador marco para gestionar clics. Se hace la prueba automatizada MUCHO más fácil. Echa un vistazo a este enlace para mayor información: codelabs.developers.google.com/codelabs/android-testing/…
  4. 4

    Más utilizada es la, anónimo declaración

        Button send = (Button) findViewById(R.id.buttonSend);
        send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //handle click
            }
        });

    También puede crear la Vista.OnClickListener objeto y establecer en el botón más tarde, pero usted todavía necesita para reemplazar método onClick por ejemplo

    View.OnClickListener listener = new View.OnClickListener(){
         @Override
            public void onClick(View v) {
                //handle click
            }
    }   
    Button send = (Button) findViewById(R.id.buttonSend);
    send.setOnClickListener(listener);

    Cuando su actividad implementa la interfaz OnClickListener debe reemplazar onClick(View v) método sobre el nivel de actividad. A continuación, puede realización de esta actividad como oyente a botón, porque ya implementa la interfaz y anula el onClick() método

    public class MyActivity extends Activity implements View.OnClickListener{
    
    
        @Override
        public void onClick(View v) {
            //handle click
        }
    
    
        @Override
        public void onCreate(Bundle b) {
            Button send = (Button) findViewById(R.id.buttonSend);
            send.setOnClickListener(this);
        }
    
    }

    (en mi humilde opinión) 4-th enfoque se utiliza cuando varios botones tienen el mismo controlador, y usted puede declarar un método en la clase de actividad y asignar este método a varios botones en xml de diseño, también puede crear un método para un botón, pero en este caso prefiero
    para declarar los controladores dentro de la actividad de la clase.

  5. 1

    La opción 1 y 2 implica el uso de interior de la clase que hará que el código de tipo de desorden.
    La opción 2 es una especie de desorden, porque habrá una escucha para cada botón. Si usted tiene un pequeño número de botón, esto está bien.
    Para la opción 4 creo que esto va a ser más difícil para depurar ya que se tiene que ir de nuevo y cuarto el xml y el código de java.
    Yo personalmente uso la opción 3 cuando tengo que manejar múltiples clics de botón.

  6. 1

    De mi ejemplo, Probado en Android studio 2.1

    Botón definir en xml de diseño

    <Button
        android:id="@+id/btn1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    Java pulsación detectar

    Button clickButton = (Button) findViewById(R.id.btn1);
    if (clickButton != null) {
        clickButton.setOnClickListener( new View.OnClickListener() {
    
            @Override
            public void onClick(View v) {
                /***Do what you want with the click here***/
            }
        });
    }
  7. 1

    Para hacer las cosas más fáciles asp Pregunta 2 indica, puede hacer uso de lambda método como este para guardar la variable de memoria y para evitar desplazarse hacia arriba y hacia abajo en la clase de vista

    //method 1
    findViewById(R.id.buttonSend).setOnClickListener(v -> {
              //handle click
    });

    pero si usted desea aplicar evento click para el botón a la vez en un método.

    usted puede hacer uso de la Pregunta 3 por @D. Tran respuesta. Pero no te olvides de poner en práctica su visión de la clase con View.OnClickListener.

    En otros el uso de la Pregunta #3 correctamente

    • Esto debe tenerse en cuenta la respuesta moderna combinada con el método de las referencias de la OMI. La mayoría de las otras respuestas no llamar la atención al hecho de que ellos tienen la edad pre Java8 código en Android.
  8. 0

    Pregunta#1 – Estos son la única manera de controlar la vista de clics.

    Pregunta#2 –

    Opción#1/Opción#4 – no Hay mucha diferencia entre la opción#1 opción#4. La única diferencia que veo es que en un caso la actividad es la aplicación de la OnClickListener, mientras que, en el otro caso, no tendría que ser un anónimo aplicación.

    Opción#2 – En este método de una clase anónima será generado. Este método es un poco cumborsome, como, tendría que hacerlo varias veces, si usted tiene varios botones. Para las clases Anónimas, usted tiene que tener cuidado para el manejo de las fugas de memoria.

    Opción#3 – Aunque, esta es una manera fácil. Generalmente, los Programadores trate de no usar ningún método hasta que lo escribe, y por lo tanto, este método no es muy utilizado. Quieres ver la mayoría de la gente utilice la Opción#4. Porque es más limpio en el plazo de código.

    • Hola Gaurav, gracias por responder. Pero, ¿puedes por favor aclarar a qué te refieres aquí: Para las clases Anónimas, usted tiene que tener cuidado para el manejo de las fugas de memoria. Cómo pérdidas de memoria venir aquí?
    • Sólo tienes que ser consciente de que: si crea una clase anónima dentro de un método que podría conseguir que llamar varias veces durante la vida útil de su aplicación no varias instancias de una clase se crea pero varias clases, incluyendo las instancias de ellos. Usted puede evitar esto mediante el uso regular de las clases internas y crear instancias de los oyentes como los campos de instancia. Trate de reducir las diferentes clases de oyentes, haciendo que el oyente estado de cuenta a través de argumentos de constructor. Regular de la clase interna le da el beneficio de la costumbre de constructores y otros métodos.
  9. 0

    También hay opciones disponibles en la forma de varias bibliotecas que pueden hacer que este proceso resulta muy familiar a las personas que han utilizado otros marcos de MVVM.

    https://developer.android.com/topic/libraries/data-binding/

    Muestra un ejemplo de un funcionario de la biblioteca, que permite enlazar los botones como este:

    <Button
        android:text="Start second activity"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="@{() -> presenter.showList()}"
    />
  10. 0

    Paso 1:Crear un Archivo XML:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
        <Button
            android:id="@+id/btnClickEvent"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Click Me" />
    </LinearLayout>

    Paso 2:Crear MainActivity:

    package com.scancode.acutesoft.telephonymanagerapp;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends Activity implements View.OnClickListener {
    
        Button btnClickEvent;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            btnClickEvent = (Button) findViewById(R.id.btnClickEvent);
            btnClickEvent.setOnClickListener(MainActivity.this);
    
        }
    
        @Override
        public void onClick(View v) {
            //Your Logic
        }
    }

    HappyCoding!

Dejar respuesta

Please enter your comment!
Please enter your name here