Continuellement augmenter la valeur d'entier que le bouton est pressé

Pour que cela fonctionne, vous avez besoin d'un thread qui va mettre à jour la valeur de l'entier lorsque vous appuyez longuement sur un bouton.

Créer un gestionnaire dans votre activité:

private Handler repeatUpdateHandler = new Handler();

Et 2 vars qui va de l'état: est-il augmenter ou diminuer? Un seul jeu à la fois.

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

Et le présent numéro de valeur

public int mValue;

Et une classe qui sera exécuté 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 );
}
}
}

Ajouter une pression longue sur l'écouteur de 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 de un. Créer un bouton qui permettra de définir mAutoDecrement de vrai.

Et de décrémentation() sera une fonction, qui va définir votre instance int variable comme ceci:

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

Vous la figure de l'incrément de sortir. Oh, et REP_DELAY est un static int variable fixée à 50.

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

Je suis en retard pour répondre à cette question, mais il peut aider toute personne qui est à la recherche pour une meilleure réponse.

J'ai créé un CounterHandler classe et son incroyablement facile à utiliser pour atteindre le ci-dessus mentionné continue compteur de fonctionnalité.

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

Exemple de code

    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. 🙂

Veux juste faire part de ma propre solution qui a fonctionné pour moi vraiment bien.

Tout d'abord, créez un gestionnaire d'événements dans votre activité

private Handler mHandler = new Handler();

Ensuite, créez le runnables qui va incrémenter/décrémenter et d'affichage de votre numéro. Ici, nous allons vérifier si votre bouton est toujours dans son état activé et l'incrément puis exécutez l'exécutable, si il est.

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.
}
}
}

Enfin, l'utiliser dans notre bouton de onLongClickListener

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

Que c'est!

---

Une autre façon de le faire est de déclarer à la fois le gestionnaire et praticable à l'intérieur de la OnLongClickListener lui-même bien que je me suis pas sûr si c'est une bonne pratique.

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

---

Quand vous faites cela, continue de s'incrémenter, je suggère d'augmenter la valeur de l'incrément après un certain temps/nombre de tranches.
E. g. Si le number_of_increment est moins que 10, on incrémente de 1. Sinon, on incrémente par 3.