example - onclick android studio
Aumente continuamente el valor entero a medida que se presiona el botón (4)
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="<" />
<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=">" />
</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);
}
});
}
}
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. :)
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));
}
}) ;
}
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.
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());
}
}