Постоянно увеличивайте целочисленное значение при нажатии кнопки

Question

Я новичок в Android, так что извините, если на вопрос легко ответить. У меня есть две кнопки, кнопка уменьшения и увеличения, и в середине из них TextView, который отображает значение.

Когда я нажимаю кнопку уменьшения, значение в TextView уменьшается и увеличивается, когда я нажимаю кнопку увеличения, нет проблем с этим, я понял, что это работает, но проблема в том, что значение увеличивается / уменьшается только на 1 за один клик , Я пытаюсь добиться того, чтобы при постоянном нажатии кнопки (например, кнопки увеличения) значение также постоянно увеличивалось и прекращалось только после отпускания кнопки увеличения.

Это возможно? Если да, можете ли вы показать пример кода или ссылки о том, как это реализовать? Спасибо!

Вот мой 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>

и вот мой 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

Чтобы это работало, вам нужен поток, который будет обновлять целочисленное значение при длительном нажатии на кнопку.

Создайте обработчик в вашей активности:

private Handler repeatUpdateHandler = new Handler();

И 2Вары, которые будут утверждать: это увеличение или уменьшение?Только один набор за раз.

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

И текущее числовое значение

public int mValue;

И класс, который будет работать в другом потоке:

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 );
        }
    }
}

Добавитьдлительное нажатие на слушателя вашей кнопки:

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;
        }
    });  

В приведенном выше случае кнопка является инкрементной.Создайте еще одну кнопку, которая установит для mAutoDecrement значение true.

И decment () будет функцией, которая установит переменную вашего экземпляра int следующим образом:

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

Вы вычисляете приращение.Да, и REP_DELAY - это статическая переменная int, установленная на 50.

Я вижу, что это отрывок из NumberPicker с открытым исходным кодом Джеффри Коула, доступный по http://www.technologichron.net/ Должна быть добавлена ​​правильная авторская атрибуция.

Answer 2

Мой способ увеличить значение при длинном щелчке - использовать таймер, используемый для периодической проверки, если кнопка все еще нажата, и увеличения значения, в противном случае отменить таймер.Для обновления пользовательского интерфейса используйте Обработчик.

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;
        }
    });

Обработчик:

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

Я опоздал, чтобы ответить на этот вопрос, но он может помочь любому, кто ищет лучший ответ.

Я создал класс CounterHandler и его невероятно простой в использовании для достижения вышеупомянутой непрерывной функциональности счетчика.

Вы можете найти класс в следующем разделе с примером "как использовать". https://gist.github.com/nomanr/d142f4ccaf55ceba22e7f7122b55b9b6

Пример кода

    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();

Вот и все. :)

Answer 4

Кажется, что нет идеального решения этого вопроса, и всегда будут некоторые сложности.

Это моя попытка, которая включает в себя ответ Wiktor, но дает целую MainActivity, которую вы можете вырезать / вставить.

В моем примере сложная часть - это onLongClickListener, и как далеко он идет и сколько уровней анонимных классов.

Однако, с другой стороны, простота состоит в том, что все включено в один относительно короткий класс (MainActivity), и существует только один основной блок кода - onLongClickListener - который определяется только один раз иочень ясно, где код "действия":

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());
    }


}

Answer 5

Просто хочу поделиться своим собственным решением, которое отлично сработало для меня.

Сначала создайте обработчик в своей деятельности

private Handler mHandler = new Handler();

Затем создайте исполняемые файлы, которые будут увеличиваться / уменьшатьсяи отобразите свой номер.Здесь мы проверим, находится ли ваша кнопка все еще в нажатом состоянии, и затем увеличим ее, затем повторно запустим исполняемый файл, если он есть.

private Runnable incrementRunnable = new Runnable() {
    @Override
    public void run() {
        mHandler.removeCallbacks(incrementRunnable); // remove our old runnable, though I'm not really sure if this is necessary
        if(IncrementButton.isPressed()) { // check if the button is still in its pressed state
            // increment the counter
            // display the updated value here, if necessary
            mHandler.postDelayed(incrementRunnable, 100); // call for a delayed re-check of the button's state through our handler. The delay of 100ms can be changed as needed.
        }
    }
}

Наконец, используйте его в onLongClickListener нашей кнопки

IncrementButton.setOnLongClickListener(new View.OnLongClickListener() {
    @Override
    public boolean onLongClick(View view) {
        mHandler.postDelayed(incrementRunnable, 0); // initial call for our handler.
        return true;
    }
});

Вот и все!

---

Еще один способ сделать это - объявить как обработчик, так и работоспособный внутри самого OnLongClickListener, хотя я сам не уверен, что это хорошая практика.

IncrementButton.setOnLongClickListener(new View.OnLongClickListener() {
    private Handler mHandler = Handler();
    private Runnable incrementRunnable = new Runnable() {
        @Override
        public void run() {
            mHandler.removeCallbacks(incrementRunnable);
            if(IncrementButton.isPressed()) {
                // increment the counter
                // display the updated value here, if necessary
                mHandler.postDelayed(incrementRunnable, 100);
            }
        }
    };

    @Override
    public boolean onLongClick(View view) {
        mHandler.postDelayed(incrementRunnable, 0);
        return true;
    }
});

---

При выполнении этого непрерывного приращения я бы предложил увеличить значение приращения после определенного времени / числа приращений. Например, если число созданных number_of_increment меньше 10, мы увеличиваем на 1. В противном случае мы увеличиваем на 3.