android - récupérer - Augmente continuellement la valeur entière lorsque le bouton est pressé




récupérer la partie décimale d un float (3)

Je suis nouveau sur Android alors désolé si la question est facile à répondre. J'ai deux boutons, un bouton de diminution et un bouton d'augmentation, et au milieu d'eux un TextView qui affiche une valeur.

Lorsque j'appuie sur le bouton Diminuer, la valeur du TextView diminue et augmente lorsque j'appuie sur le bouton Augmenter, cela ne pose aucun problème, mais le problème est que la valeur augmente / diminue de 1 en un seul clic. Ce que j'essaie de faire, c'est que lorsque j'appuie continuellement sur le bouton (le bouton d'augmentation par exemple), la valeur augmente continuellement et ne s'arrête que lorsque je relâche le bouton d'augmentation.

Est-ce possible? Si oui, pouvez-vous montrer un exemple de code ou des références sur la manière de le mettre en œuvre? Merci!

Voici mon 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>

et voici ma 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);
            }
        });

    }
}

Il semble qu'il n'y ait pas de solution parfaite à cette question et qu'il y aura toujours une certaine complexité.

Ceci est ma tentative, qui incorpore la réponse de Wiktor, mais donne une MainActivity complète que vous pouvez copier / coller.

Dans mon exemple, la partie complexe est le onLongClickListener, sa profondeur et le nombre de niveaux de classes anonymes.

Cependant, par contre, la simplicité est que tout est inclus dans une classe relativement courte (MainActivity), et qu’il n’existe qu’un seul bloc de code majeur - onLongClickListener - qui n’est défini qu’une seule fois et où le " action "code est:

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


}

Je suis en retard pour répondre à cette question, mais cela peut aider quiconque cherche une meilleure réponse.

J'ai créé une classe CounterHandler et sa simplicité d'utilisation pour atteindre la fonctionnalité de compteur continu mentionnée ci-dessus.

Vous pouvez trouver la classe en suivant un exemple avec un exemple d'utilisation. https://gist.github.com/nomanr/d142f4ccaf55ceba22e7f7122b55b9b6

Code exemple

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

C'est tout. :)


Pour que cela fonctionne, vous avez besoin d'un thread qui mettra à jour la valeur entière lorsque vous appuyez longuement sur un bouton.

Créez un gestionnaire dans votre activité:

private Handler repeatUpdateHandler = new Handler();

Et 2 vars qui indiqueront: est-ce incrémenter ou décrémenter? Un seul jeu à la fois.

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

Et la valeur actuelle

public int mValue;

Et une classe qui s'exécutera dans un autre thread:

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

Ajoutez un long écouteur à votre bouton:

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

Dans le cas ci-dessus, le bouton est l'incrément. Créez un autre bouton qui définira mAutoDecrement sur true.

Et decrement () sera une fonction, qui définira la variable int de votre instance comme ceci:

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

Vous calculez l'incrémentation. Oh et REP_DELAY est une variable int statique définie sur 50.

Je vois que ceci est un extrait de NumberPicker de source ouverte de Jeffrey Cole disponible à http://www.technologichron.net/ L'attribution correcte de l'auteur doit être ajoutée.







button