Comment définir les valeurs de seekbar min et max

je sais que la réponse est déjà choisi et je suis un peu en retard sur la réponse mais je voulais partager ma réponse.

vous ne pouvez pas définir le min valeur D'une SeekBar (toujours 0) et vous ne pouvez pas définir le step valeur D'un SeekBar (toujours 1).

Si vous souhaitez définir la valeur de 60 180 avec un pas de 1 c'est la façon de le faire :

int step = 1;
int max = 180;
int min = 60;

// Ex : 
// If you want values from 3 to 5 with a step of 0.1 (3, 3.1, 3.2, ..., 5)
// this means that you have 21 possible values in the seekbar.
// So the range of the seek bar will be [0 ; (5-3)/0.1 = 20].
seekbar.setMax( (max - min) / step );


seekbar.setOnSeekBarChangeListener(
    new OnSeekBarChangeListener()
    {
        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {}

        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {}

        @Override
        public void onProgressChanged(SeekBar seekBar, int progress, 
            boolean fromUser) 
        {
            // Ex :
            // And finally when you want to retrieve the value in the range you
            // wanted in the first place -> [3-5]
            //
            // if progress = 13 -> value = 3 + (13 * 0.1) = 4.3
            double value = min + (progress * step);

        }
    }
);

j'ai mis un autre exemple dans le code pour que vous compreniez mathématique.

Espoir aide

Vous pouvez définir la valeur maximale pour votre seekbar en utilisant ce code:

    sb1.setMax(100);

cela définira la valeur max pour votre seekbar.

Mais vous ne pouvez pas définir la valeur minimale, mais oui, vous pouvez faire un peu d'arithmétique pour régler la valeur. Utilisez l'arithmétique pour ajuster votre application-valeur requise.

par exemple, supposons que vous ayez des valeurs de données de -50 à 100 que vous voulez affichage sur le SeekBar. Réglez le maximum du SeekBar à 150 (100-(-50)), puis ajouter 50 à raw valeur pour obtenir le nombre que vous devriez utiliser lorsque vous définissez la position de la barre.

Vous pouvez obtenir plus d'infos via ce lien.

la façon la plus simple de définir une valeur min et max à une barre de recherche pour moi: si vous voulez des valeurs min=60 à max=180, ceci est égal à min=0 max=120. Ainsi, dans votre propriété seekbar xml set:

android:max="120"

min sera toujours 0.

Maintenant, vous n'avez plus qu'à faire ce que vous faites, ajouter le montant pour obtenir votre valeur traduite dans n'importe quel changement, dans ce cas +60.

    seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
        @Override
        public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
            int translatedProgress = progress + 60;
        }

        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {
        }

        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
        }
    });

soyez prudent avec la propriété seekbar android: progress, si vous changez la portée, vous devez recalculez votre progression initiale. Si vous voulez de 50%, max/2, dans mon exemple 120/2 = 60;

Seek Bar a des méthodes pour définir les valeurs max mais pas pour définir la valeur min ici j'écris un code pour définir la valeur minimale de la barre de recherche lorsque nous ajoutons ce code, alors vos valeurs de barre de recherche Pas Moins que la valeur mim essayez ceci son travail bien pour moi

/* Cette méthode permet d'appel après la barre de recherche de changement de valeur */

            public void onProgressChanged(SeekBar seekBar, int progress,
                boolean fromUser) {
            /* Check the current seekbar value is greather than min value*/
            if (progress < MIN_VALUE) {
                /* if seek bar value is lesser than min value then set min value to seek bar */
                seekBar.setProgress(MIN_VALUE);
            }

        }

une autre solution pour gérer ce cas est de créer un seekbar personnalisé, pour obtenir ride de convertir la valeur réelle et seekbar progression à chaque fois:

import android.content.Context
import android.util.AttributeSet
import android.widget.SeekBar

//
// Require SeekBar with range [Min, Max] and INCREMENT value,
// However, Android Seekbar starts from 0 and increment is 1 by default, Android supports min attr on API 26,
// To make a increment & range Seekbar, we can do the following conversion:
//
//     seekbar.setMax((Max - Min) / Increment)
//     seekbar.setProgress((actualValue - Min) / Increment)
//     seekbar.getProgress = Min + (progress * Increment)
//
// The RangeSeekBar is responsible for handling all these logic inside the class.

data class Range(val min: Int, val max: Int, private val defaultIncrement: Int) {
    val increment = if ((max - min) < defaultIncrement) 1 else defaultIncrement
}


internal fun Range.toSeekbarMaximum(): Int = (max - min) / increment


class RangeSeekBar: SeekBar, SeekBar.OnSeekBarChangeListener {

    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet) : super(context, attrs)

    var range: Range = Range(0, 100, 1)
        set(value) {
            field = value
            max = value.toSeekbarMaximum()
        }

    var value: Int = 0
        get() = range.min + progress * range.increment
        set(value) {
            progress = (value - range.min) / range.increment
            field = value
        }

    var onSeekBarChangeListenerDelegate: OnSeekBarChangeListener? = this

    override fun setOnSeekBarChangeListener(l: OnSeekBarChangeListener?) {
        onSeekBarChangeListenerDelegate = l
        super.setOnSeekBarChangeListener(this)
    }

    override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
        onSeekBarChangeListenerDelegate?.onProgressChanged(seekBar, value, fromUser)
    }

    override fun onStartTrackingTouch(seekBar: SeekBar?) {
        onSeekBarChangeListenerDelegate?.onStartTrackingTouch(seekBar)
    }

    override fun onStopTrackingTouch(seekBar: SeekBar?) {
        onSeekBarChangeListenerDelegate?.onStopTrackingTouch(seekBar)
    }
}

Puis dans votre fragment,

    // init
    range_seekbar.range = Range(10, 110, 10)
    range_seekbar.value = 20

    // observe value changes
    range_seekbar.userChanges().skipInitialValue().subscribe {
        println("current value=$it")
    }

Définir seekbar max et min de la valeur

seekbar have method that setmax(int position) and setProgress(int position)

merci

copier cette classe et utiliser la barre de recherche personnalisée:

public class MinMaxSeekBar extends SeekBar implements SeekBar.OnSeekBarChangeListener {
private OnMinMaxSeekBarChangeListener onMinMaxSeekBarChangeListener = null;
private int intMaxValue = 100;
private int intPrgress = 0;
private int minPrgress = 0;


public int getIntMaxValue() {
    return intMaxValue;
}

public void setIntMaxValue(int intMaxValue) {
    this.intMaxValue = intMaxValue;
    int middle = getMiddle(intMaxValue, minPrgress);
    super.setMax(middle);
}

public int getIntPrgress() {
    return intPrgress;
}

public void setIntPrgress(int intPrgress) {
    this.intPrgress = intPrgress;
}

public int getMinPrgress() {
    return minPrgress;
}

public void setMinPrgress(int minPrgress) {
    this.minPrgress = minPrgress;
    int middle = getMiddle(intMaxValue, minPrgress);
    super.setMax(middle);
}

private int getMiddle(int floatMaxValue, int minPrgress) {
    int v = floatMaxValue - minPrgress;
    return v;
}

public MinMaxSeekBar(Context context, AttributeSet attrs) {
    super(context, attrs);
    this.setOnSeekBarChangeListener(this);
}

public MinMaxSeekBar(Context context) {
    super(context);
    this.setOnSeekBarChangeListener(this);
}

@Override
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
    intPrgress = minPrgress + i;
    onMinMaxSeekBarChangeListener.onMinMaxSeekProgressChanged(seekBar, intPrgress, b);
}

@Override
public void onStartTrackingTouch(SeekBar seekBar) {
    onMinMaxSeekBarChangeListener.onStartTrackingTouch(seekBar);

}

@Override
public void onStopTrackingTouch(SeekBar seekBar) {
    onMinMaxSeekBarChangeListener.onStopTrackingTouch(seekBar);
}

public static interface OnMinMaxSeekBarChangeListener {
    public void onMinMaxSeekProgressChanged(SeekBar seekBar, int i, boolean b);

    public void onStartTrackingTouch(SeekBar seekBar);

    public void onStopTrackingTouch(SeekBar seekBar);
}

public void setOnIntegerSeekBarChangeListener(OnMinMaxSeekBarChangeListener floatListener) {
    this.onMinMaxSeekBarChangeListener = floatListener;
}
}

Cette classe contin méthode public void setMin(int minPrgress) pour fixer la valeur minimale de Seek Bar Cette méthode de la classe contin public void setMax(int maxPrgress) pour définir la valeur maximale de la barre de recherche

Voir ma réponse ici

j'ai utilisé seulement listener pour SeekBar et cela fonctionne très bien.

Min-value va toujours commencer à zéro et il n'y a rien que vous puissiez faire. Mais vous pouvez changer sa valeur quand l'utilisateur commence à le faire défiler.

ici, je mets la valeur max à 64. Ces calculs sont simples: je veux que l'utilisateur choisisse un temps de 15min à 16 heures, et il choisit un de tous les 15min à 16 heures, clair? Je sais, très simple :)

    SeekBar seekBar = (SeekBar) dialog.findViewById(R.id.seekBar);
    seekBar.setMax(64);

    seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
        float b;

        @Override
        public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
            float des = (float) progress / 4;
            b = des;
            hours.setText(des + " hours");
        }

        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {


        }

        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
            hoursSelected = b;
        }
    });

    private static final int MIN_METERS = 100;
    private static final int JUMP_BY = 50;

    metersText.setText(meters+"");
    metersBar.setProgress((meters-MIN_METERS));
    metersBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
            // TODO Auto-generated method stub
        }
        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {
            // TODO Auto-generated method stub
        }
        @Override
        public void onProgressChanged(SeekBar seekBar, int progress,boolean fromUser) {
            progress = progress + MIN_METERS;
            progress = progress / JUMP_BY;
            progress = progress * JUMP_BY;
            metersText.setText((progress)+"");
        }
    });
}

Il n'y a pas d'option pour définir une valeur min ou max dans seekbar , donc vous pouvez utiliser une formule ici pour mettre à l'échelle votre valeur.

Desired_value = ( progress * ( Max_value - Min_value) / 100 ) + Min_value

j'ai testé cette formule dans de nombreux exemples. Dans votre exemple, si la barre de progression est au milieu (i.e. progress = 50 ) et que votre Min_val et Max_val sont respectivement 60 et 180, alors cette formule vous donnera la valeur désirée '120'.