example - onclick android studio

Aumente continuamente el valor entero a medida que se presiona el botón

Question

Soy nuevo en Android, lo siento mucho si la pregunta es fácil de responder. Tengo dos botones, un botón para disminuir y otro para aumentar, y en medio de ellos un TextView que muestra un valor.

Cuando presiono el botón de disminución, el valor en el TextView disminuye y aumenta cuando presiono el botón de aumento, no hay problema con eso, lo conseguí, pero el problema es que el valor solo aumenta / disminuye en 1 con un solo clic. Lo que intento lograr es que, al presionar continuamente el botón (el botón de aumento, por ejemplo), el valor también aumenta continuamente y solo se detiene cuando suelto el botón de aumento.

¿Es eso posible? Si es así, ¿puede mostrar algún código de muestra o referencias sobre cómo implementar eso? ¡Gracias!

Aquí está mi main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="center" >

    <RelativeLayout
        android:layout_width="fill_parent"
        android:layout_height="44dp"
        android:gravity="center_horizontal" >

        <Button android:id="@+id/button1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentLeft="true"
            android:layout_alignParentTop="true"
            android:text="&lt;" />

        <TextView android:id="@+id/textView1"
            android:layout_width="50dp"
            android:layout_height="fill_parent"
            android:layout_alignBottom="@+id/button1"
            android:layout_toRightOf="@+id/button1"
            android:gravity="center"
            android:text="45" />

        <Button android:id="@+id/button2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentTop="true"
            android:layout_toRightOf="@+id/textView1"
            android:text="&gt;" />

     </RelativeLayout>   

</RelativeLayout>

y aquí está mi Main.java

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class Main extends Activity {

    private Button _decrease;
    private Button _increase;
    private TextView _value;
    private static int _counter = 45;
    private String _stringVal;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        _decrease = (Button) findViewById(R.id.button1);
        _increase = (Button) findViewById(R.id.button2);
        _value = (TextView) findViewById(R.id.textView1);

        _decrease.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {

                Log.d("src", "Decreasing value...");
                _counter--;
                _stringVal = Integer.toString(_counter);
                _value.setText(_stringVal);
            }
        });

        _increase.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {

                Log.d("src", "Increasing value...");
                _counter++;
                _stringVal = Integer.toString(_counter);
                _value.setText(_stringVal);
            }
        });

    }
}

Answer 1

Llego tarde para responder esta pregunta, pero puede ayudar a cualquiera que esté buscando una mejor respuesta.

CounterHandler una clase CounterHandler y es increíblemente fácil de usar para lograr la funcionalidad de contador continuo mencionada anteriormente.

Puede encontrar la clase en la siguiente esencia con un ejemplo de "cómo usar". https://gist.github.com/nomanr/d142f4ccaf55ceba22e7f7122b55b9b6

Código de muestra

    new CounterHandler.Builder()
            .incrementalView(buttonPlus)
            .decrementalView(buttonMinus)
            .minRange(-50) // cant go any less than -50
            .maxRange(50) // cant go any further than 50
            .isCycle(true) // 49,50,-50,-49 and so on
            .counterDelay(200) // speed of counter
            .counterStep(2)  // steps e.g. 0,2,4,6...
            .listener(this) // to listen counter results and show them in app
            .build();

Eso es todo. :)

Answer 2

Mi forma de incrementar el valor en clics largos es utilizar el temporizador utilizado para verificar periódicamente si el botón aún está presionado y luego aumentar el valor, de lo contrario, cancelar el temporizador. Para actualizar UI use Handler.

vh.bttAdd.setOnLongClickListener(new View.OnLongClickListener() {
        @Override
        public boolean onLongClick(View v) {

            final Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                 if(vh.bttAdd.isPressed()) {
                     final int track = ((ChannelAudioTrack) channels.get(vh.getAdapterPosition())).goToNextTrack();
                  updateUI(vh,track);
                 }
                else
                timer.cancel();
            }
            },100,200);

            return true;
        }
    });

Entrenador de animales:

private void updateUI(final TrackViewHolder vh, final int track)
 {
new Handler(Looper.getMainLooper()).post(new Runnable() {
                        @Override
                        public void run() {
                                  vh.tvTrackNumber.setText(Integer.toString(track));
                        }
                    }) ;
}

Answer 3

Para que funcione, necesitas un hilo que actualice el valor entero cuando presionas un botón.

Crea un controlador en tu actividad:

private Handler repeatUpdateHandler = new Handler();

Y 2 vars que indicarán: ¿es incremento o decremento? Solo un juego a la vez.

private boolean mAutoIncrement = false;
private boolean mAutoDecrement = false;

Y el valor numérico actual

public int mValue;

Y una clase que se ejecutará en otro hilo:

class RptUpdater implements Runnable {
    public void run() {
        if( mAutoIncrement ){
            increment();
            repeatUpdateHandler.postDelayed( new RptUpdater(), REP_DELAY );
        } else if( mAutoDecrement ){
            decrement();
            repeatUpdateHandler.postDelayed( new RptUpdater(), REP_DELAY );
        }
    }
}

Agregue un oyente de pulsación larga a su botón:

mBTIncrement.setOnLongClickListener( 
            new View.OnLongClickListener(){
                public boolean onLongClick(View arg0) {
                    mAutoIncrement = true;
                    repeatUpdateHandler.post( new RptUpdater() );
                    return false;
                }
            }
    );   

mBTIncrement.setOnTouchListener( new View.OnTouchListener() {
        public boolean onTouch(View v, MotionEvent event) {
            if( (event.getAction()==MotionEvent.ACTION_UP || event.getAction()==MotionEvent.ACTION_CANCEL) 
                    && mAutoIncrement ){
                mAutoIncrement = false;
            }
            return false;
        }
    });  

En el caso anterior, el botón es el incremento uno. Crea otro botón que establecerá mAutoDecrement en verdadero.

Y decrement () será una función, que establecerá su instancia int variable de esta manera:

public void decrement(){
    mValue--;
    _value.setText( ""+mValue );
}

Calcula el incremento. Oh y REP_DELAY es una variable int estática establecida en 50.

Veo que este es un extracto de la fuente abierta NumberPicker de Jeffrey Cole disponible en http://www.technologichron.net/ Debe agregarse la atribución del autor apropiado.

Answer 4

Parece que no hay una solución perfecta para esta pregunta y siempre habrá cierta complejidad involucrada.

Este es mi intento, que incorpora la respuesta de Wiktor, pero ofrece una actividad principal completa que puedes cortar / pegar.

En mi ejemplo, la parte compleja es onLongClickListener, y qué tan profundo va y cuántos niveles de clases anónimas hay.

Sin embargo, por otro lado, la simplicidad es que todo está incluido en una clase relativamente corta (MainActivity), y solo hay un bloque principal de código, el onLongClickListener, que se define solo una vez y está muy claro dónde está el " acción "código es:

package com.example.boober.aalongclickoptimizationunit;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends AppCompatActivity {

    TextView valueDisplay;
    Button minusButton;
    Button plusButton;
    Button[] arrayOfControlButtons;

    Integer currentDisplayValue = 500;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        valueDisplay = findViewById(R.id.value);
        minusButton = findViewById(R.id.minusButton);
        plusButton = findViewById(R.id.plusButton);

        arrayOfControlButtons = new Button[]{plusButton, minusButton}; // this could be a large set of buttons

        updateDisplay(); // initial setting of display

        for (Button b : arrayOfControlButtons) {

            b.setOnLongClickListener(new View.OnLongClickListener() {
                @Override
                public boolean onLongClick(final View v) {

                    final Timer timer = new Timer();
                    timer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            if (v.isPressed()) { // important: checking if button still pressed
                                runOnUiThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        // --------------------------------------------------
                                        // this is code that runs each time the
                                        // long-click timer "goes off."
                                        switch (v.getId()) {

                                            // which button was pressed?
                                            case R.id.plusButton: {
                                                currentDisplayValue = currentDisplayValue + 10;
                                                break;
                                            }

                                            case R.id.minusButton: {
                                                currentDisplayValue = currentDisplayValue - 10;
                                                break;
                                            }
                                        }
                                        updateDisplay();
                                        // --------------------------------------------------
                                    }
                                });
                            } else
                                timer.cancel();
                        }
                    }, 100, 200);
                    // if set to false, then long clicks will propagate into single-clicks
                    // also, and we don''t want that.
                    return true;
                }
            });

        }


    }

    // ON-CLICKS (referred to from XML)

    public void minusButtonPressed(View ignored) {
        currentDisplayValue--;
        updateDisplay();
    }

    public void plusButtonPressed(View ignored) {
        currentDisplayValue++;
        updateDisplay();
    }

    // INTERNAL

    private void updateDisplay() {
        valueDisplay.setText(currentDisplayValue.toString());
    }


}