Android RatingBar ändert die Sternfarben
Wie kann ich die Sternfarben ändern und wie kann ich die Größe der Sterne ändern?
Schritt 1: Erstellen Sie Ihren eigenen Stil, indem Sie einen der vorhandenen Stile (aus $Android_HOME/platforms/$SDK/data/res/values/styles.xml) klonen, in den styles.xml Ihres eigenen Projekts einfügen und darauf verweisen, wenn Sie das Widget einem Layout hinzufügen.
Schritt # 2: Erstellen Sie Ihre eigenen LayerDrawable XML-Ressourcen für die RatingBar, und zeigen Sie auf die für die Leiste geeigneten Bilder. Die Originalstile weisen Sie auf die vorhandenen Ressourcen hin, mit denen Sie vergleichen können. Passen Sie dann Ihren Stil an, um Ihre eigenen LayerDrawable-Ressourcen zu verwenden, anstatt die eingebauten.
Es ist ein wenig kompliziert in dem erwähnten Blog, ich habe einen ähnlichen, aber einfacheren Weg verwendet ... Sie benötigen 3-Sterne-Bilder (red_star_full.png, red_star_half.png und red_star_empty.png) und eine XML-Datei.
Setze diese 3 Bilder auf res/drawable.
Fügen Sie dort die folgende ratingbar_red.xml ein:
<?xml version="1.0" encoding="UTF-8"?>
<layer-list xmlns:Android="http://schemas.Android.com/apk/res/Android">
<item Android:id="@Android:id/background" Android:drawable="@drawable/red_star_empty" />
<item Android:id="@Android:id/secondaryProgress" Android:drawable="@drawable/red_star_half" />
<item Android:id="@Android:id/progress" Android:drawable="@drawable/red_star_full" />
</layer-list>
und schließlich sagen Sie Ihrer ratingbar-Definition, dies zu verwenden, d. h.
<RatingBar Android:progressDrawable="@drawable/ratingbar_red"/>
Das ist es.
Versuchen Sie dies, wenn Sie nur die Farbe ändern möchten:
RatingBar ratingBar = (RatingBar) findViewById(R.id.ratingBar);
LayerDrawable stars = (LayerDrawable) ratingBar.getProgressDrawable();
stars.getDrawable(2).setColorFilter(Color.YELLOW, PorterDuff.Mode.SRC_ATOP);
Der einfachste Weg, der für mich funktioniert hat ... wenn Sie AppCompat-Aktivität erweitern
Fügen Sie in Ihrem build.gradle die neueste appcompat-Bibliothek hinzu.
dependencies {
compile 'com.Android.support:appcompat-v7:X.X.X' // where X.X.X version
}
Machen Sie Ihre Aktivität erweitern Android.support.v7.app.AppCompatActivity
public class MainActivity extends AppCompatActivity {
...
}
Deklarieren Sie den benutzerdefinierten Stil in Ihrer Datei styles.xml.
<style name="RatingBar" parent="Theme.AppCompat">
<item name="colorControlNormal">@color/Indigo</item>
<item name="colorControlActivated">@color/pink</item>
</style>
Wenden Sie diesen Stil auf Ihre Rating-Leiste über das Attribut "Android:" an.
<RatingBar
Android:theme="@style/RatingBar"
Android:rating="3"
Android:stepSize="0.5"
Android:numStars="5"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"/>
2015 Update
Jetzt können Sie DrawableCompat verwenden, um alle Arten von Drawables zu tönen. Zum Beispiel:
Drawable progress = ratingBar.getProgressDrawable();
DrawableCompat.setTint(progress, Color.WHITE);
Dies ist abwärtskompatibel bis API 4
Wenn Sie die Farbe für alle Sterne ändern möchten, werden Sie von mir verwendet:
LayerDrawable stars = (LayerDrawable) ratingBar.getProgressDrawable();
stars.getDrawable(2).setColorFilter(getResources().getColor(R.color.starFullySelected), PorterDuff.Mode.SRC_ATOP);
stars.getDrawable(1).setColorFilter(getResources().getColor(R.color.starPartiallySelected), PorterDuff.Mode.SRC_ATOP);
stars.getDrawable(0).setColorFilter(getResources().getColor(R.color.starNotSelected), PorterDuff.Mode.SRC_ATOP);
Ab API 21 ist es sehr einfach, die Farbe der Sterne mit diesen drei Codezeilen zu ändern:
Android:progressTint="@Android:color/holo_red_dark"
Android:progressBackgroundTint="@Android:color/holo_red_dark"
Android:secondaryProgressTint="@Android:color/holo_red_dark"
Auf diese Weise ändern Sie die Hintergrundfarbe und die Randfarbe der Sterne.
Die von Alex und CommonsWares veröffentlichten Lösungen sind korrekt. Eine Sache, über die Android nie spricht, ist die richtige Pixelgröße für verschiedene Dichten. Hier sind die erforderlichen Abmessungen für jede Dichte basierend auf Halo-Licht.
Kleiner Stern
mdpi: 16px
hdpi: 24px
xhdpi: 32px
xxhdpi: 48px
Mittlerer Stern
mdpi: 24px
hdpi: 36px
xhdpi: 48px
xxhdpi: 72px
Großer Stern
mdpi: 35px
hdpi: 52px
xhdpi: 69px
xxhdpi: 105px
Ich habe also zwei Stunden lang mit diesem Problem zu kämpfen und habe eine funktionierende Lösung für alle API-Versionen gefunden, bei denen auch die Bewertung mit halben Sternen angezeigt wird.
private void setRatingStarColor(Drawable drawable, @ColorInt int color)
{
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Lollipop)
{
DrawableCompat.setTint(drawable, color);
}
else
{
drawable.setColorFilter(color, PorterDuff.Mode.SRC_IN);
}
}
Sie rufen die Methode mit dieser Reihenfolge von drawables auf:
LayerDrawable stars = (LayerDrawable) ratingBar.getProgressDrawable();
// Filled stars
setRatingStarColor(stars.getDrawable(2), ContextCompat.getColor(getContext(), R.color.foreground));
// Half filled stars
setRatingStarColor(stars.getDrawable(1), ContextCompat.getColor(getContext(), R.color.background));
// Empty stars
setRatingStarColor(stars.getDrawable(0), ContextCompat.getColor(getContext(), R.color.background));
HINWEIS: Außerdem müssen Sie in XML die Attribute "max" und "numStars" angeben. Andernfalls werden keine halben Sterne angezeigt.
Jetzt können Sie DrawableCompat ab AppCompat v22.1.0 verwenden, um alle Arten von Zeichenelementen dynamisch einzufärben. Dies ist nützlich, wenn Sie mehrere Designs mit einem einzigen Satz von Zeichenelementen unterstützen. Zum Beispiel:
LayerDrawable layerDrawable = (LayerDrawable) ratingBar.getProgressDrawable();
DrawableCompat.setTint(DrawableCompat.wrap(layerDrawable.getDrawable(0)), Color.RED); // Empty star
DrawableCompat.setTint(DrawableCompat.wrap(layerDrawable.getDrawable(1)), Color.GREEN); // Partial star
DrawableCompat.setTint(DrawableCompat.wrap(layerDrawable.getDrawable(2)), Color.BLUE); // Full star
Dies ist abwärtskompatibel bis API 4. Siehe auch Chris Banes 'Blogbeitrag in Support Libraries v22.1.0
Für die tatsächliche Größe und Form müssen Sie einen neuen Stil und Layer-Zeichnungsobjekte für die entsprechende Größe definieren, da andere bereits oben geantwortet haben.
Verwenden Sie das Android:theme-Attribut:
styles.xml
<style name="Theme.Rating" parent="Theme.AppCompat.Light">
<item name="colorAccent">@color/rating</item>
</style>
layout.xml
<Android.support.v7.widget.AppCompatRatingBar
Android:theme="@style/Theme.Rating"
Android:numStars="5"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content" />
Um nur die Farbe der Bewertungsleiste von xml zu ändern: -
Android:progressTint="@color/your_color"
Android:backgroundTint="@color/your_color"
Android:secondaryProgressTint="@color/your_color"
Um die Farbe zu ändern, müssen Sie lediglich den Parameter Android: progressTint einstellen
<RatingBar
Android:layout_width="wrap_content"
Android:layout_height="match_parent"
Android:layout_marginTop="15dp"
Android:numStars="5"
Android:rating="1"
Android:progressTint="@Android:/color/black"
Android:layout_gravity="center"
/>
Für die Größe die Stileigenschaft.
Der einfachste Weg:
Android:progressTint="@color/color"
<!--For rating bar -->
<style name="RatingBarfeed" parent="Theme.AppCompat">
<item name="colorControlNormal">@color/colorPrimary</item>
<item name="colorControlActivated">@color/colorPrimary</item>
</style>
verwenden Sie Ihre eigene Farbe
Ohne einen neuen Stil hinzuzufügen, können Sie die Tönungsfarbe in der RatingBar verwenden.
<RatingBar
Android:id="@+id/ratingBar"
style="@Android:style/Widget.Holo.RatingBar.Small"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:numStars="5"
Android:rating="4.5"
Android:stepSize="0.5"
Android:progressTint="@color/colorPrimary"/>
Antwort von Building @ lgvalle.
Update 2015
Jetzt können Sie DrawableCompat verwenden, um alle Arten von Zeichenelementen zu färben. Zum Beispiel:
Zeichenbarer Fortschritt = ratingBar.getProgressDrawable (); DrawableCompat.setTint (Fortschritt, Color.WHITE); Dies ist abwärtskompatibel bis API 4
LayerDrawable drawable = (LayerDrawable) getProgressDrawable();
Drawable progress = drawable.getDrawable(2);
DrawableCompat.setTint(progress, getResources().getColor(COLOR1));
progress = drawable.getDrawable(1);
DrawableCompat.setTintMode(progress, PorterDuff.Mode.DST_ATOP);
DrawableCompat.setTint(progress, getResources().getColor(COLOR1));
DrawableCompat.setTintMode(progress, PorterDuff.Mode.SRC_ATOP);
DrawableCompat.setTint(progress, getResources().getColor(COLOR2));
progress = drawable.getDrawable(0);
DrawableCompat.setTint(progress, getResources().getColor(COLOR2));
Dadurch bleiben die Farben der Fraktionsschritte erhalten.
Verwenden Sie dazu einfach die AppCompatRatingBar und ihre setProgressTintList -Methode dies Antwort als Referenz.
Funktioniert für Android unter und über Version 21
Nach einigen Nachforschungen bin ich auf diese Methode gekommen, um die Hintergrundfarbe, die Lückentönung (zB halber Stern) und die Sternfarbe einzustellen.
LayerDrawable layers = (LayerDrawable) ratingBar.getProgressDrawable();
DrawableCompat.setTint(layers.getDrawable(0), 0x33000000); // The background tint
DrawableCompat.setTint(layers.getDrawable(1), 0x00000000); // The gap tint (Transparent in this case so the gap doesnt seem darker than the background)
DrawableCompat.setTint(layers.getDrawable(2), 0xffFED80A); // The star tint
RatingBar mRating=(RatingBar)findViewById(R.id.rating);
LayerDrawable layerDrawable=(LayerDrawable)mRating.getProgressDrawable();
layerDrawable.getDrawable(2).setColorFilter(Color.parseColor
("#32CD32"), PorterDuff.Mode.SRC_ATOP);
für mich funktioniert es ....
Ich löse dieses Problem folgendermaßen:
LayerDrawable layerDrawable = (LayerDrawable) ratingBar.getProgressDrawable();
DrawableCompat.setTint(DrawableCompat.wrap(layerDrawable.getDrawable(0)),
Color.WHITE); // Empty star
DrawableCompat.setTint(DrawableCompat.wrap(layerDrawable.getDrawable(1)),
Color.YELLOW); // Partial star
DrawableCompat.setTint(DrawableCompat.wrap(layerDrawable.getDrawable(2)),
Color.YELLOW);
Ich habe eine einfache Lösung gefunden, um die Farbe des Sterns gemäß Ihrem Thema zu ändern.
Gehe zu dieser Site: http://Android-holo-colors.com/
Wählen Sie Ihre Themenfarbe und erstellen Sie Ihre Sternbilder.
Mit den obigen Antworten habe ich eine schnelle statische Methode erstellt, die einfach wiederverwendet werden kann. Es soll nur die Fortschrittsfarbe für die aktivierten Sterne eingefärbt werden. Die nicht aktivierten Sterne bleiben grau.
public static RatingBar tintRatingBar (RatingBar ratingBar, int progressColor)if (ratingBar.getProgressDrawable() instanceof LayerDrawable) {
LayerDrawable progressDrawable = (LayerDrawable) ratingBar.getProgressDrawable();
Drawable drawable = progressDrawable.getDrawable(2);
Drawable compat = DrawableCompat.wrap(drawable);
DrawableCompat.setTint(compat, progressColor);
Drawable[] drawables = new Drawable[3];
drawables[2] = compat;
drawables[0] = progressDrawable.getDrawable(0);
drawables[1] = progressDrawable.getDrawable(1);
LayerDrawable layerDrawable = new LayerDrawable(drawables);
ratingBar.setProgressDrawable(layerDrawable);
return ratingBar;
}
else {
Drawable progressDrawable = ratingBar.getProgressDrawable();
Drawable compat = DrawableCompat.wrap(progressDrawable);
DrawableCompat.setTint(compat, progressColor);
ratingBar.setProgressDrawable(compat);
return ratingBar;
}
}
Übergeben Sie einfach Ihre Bewertungsleiste und eine Farbe mit getResources().getColor(R.color.my_rating_color)
Wie Sie sehen, verwende ich DrawableCompat, damit es abwärtskompatibel ist.
BEARBEITEN: Diese Methode funktioniert nicht bei API21 (gehen Sie zur Abbildung). Beim Aufruf von setProgressBar erhalten Sie eine NullPointerException. Am Ende habe ich die gesamte Methode für API> = 21 deaktiviert.
Für API> = 21 verwende ich die SupperPuccio-Lösung.
Eine etwas späte Antwort, aber ich hoffe, es hilft einigen Leuten.
<RatingBar
Android:id="@+id/rating"
style="@style/Base.Widget.AppCompat.RatingBar.Small"
Android:theme="@style/WhiteRatingStar"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:layout_below="@+id/profil_name"
Android:layout_centerHorizontal="true"
Android:layout_marginLeft="@dimen/dimen_4"
Android:rating="3" />
Und so sieht der WhiteRatingStar aus
<style name="WhiteRatingStar" parent="Base.Widget.AppCompat.RatingBar.Small">
<item name="colorAccent">@Android:color/white</item>
</style>
Damit werden die Sterne beispielsweise weiß eingefärbt.
Ich war auf der Suche nach einer zuverlässigen Methode, um dies mindestens bis API 9 zu erreichen. Die Lösung "Casting to LayerDrawble" schien für mich eine riskante Lösung zu sein, und als ich sie auf einem Android-Telefon unter 2.3 getestet habe wurde erfolgreich gewirkt, aber der Aufruf von DrawableCompat.setTint (...) hatte keine Auswirkungen.
Die Notwendigkeit, verladbare Vermögenswerte zu laden, schien mir auch keine gute Lösung zu sein.
Ich entschied mich für meine eigene Lösung, die eine Klasse ist, die AppCompatRatingBar erweitert, und zwar mit einem benutzerdefinierten Drawable, der programmgesteuert die Sterne zeichnet. Es funktioniert perfekt für meine Bedürfnisse, ich werde es posten, falls es jemandem hilft:
https://Gist.github.com/androidseb/2b8044c90a07c7a52b4bbff3453c8460
Der Link ist einfacher, da Sie die vollständige Datei direkt abrufen können. Hier ist jedoch der vollständige Code für alle Fälle:
import Android.content.Context;
import Android.graphics.Canvas;
import Android.graphics.Color;
import Android.graphics.ColorFilter;
import Android.graphics.Paint;
import Android.graphics.Paint.Style;
import Android.graphics.Path;
import Android.graphics.PointF;
import Android.graphics.drawable.Drawable;
import Android.support.v7.widget.AppCompatRatingBar;
import Android.util.AttributeSet;
/**
* @author androidseb
* <p/>
* Extends AppCompatRatingBar with the ability to tint the drawn stars when selected, pressed and un-selected.
* Limitation: Only draws full stars.
*/
public class TintableRatingBar extends AppCompatRatingBar {
private TintableRatingBarProgressDrawable progressDrawable;
public TintableRatingBar(final Context context) {
super(context);
init();
}
public TintableRatingBar(final Context context, final AttributeSet attrs) {
super(context, attrs);
init();
}
public TintableRatingBar(final Context context, final AttributeSet attrs, final int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
private void init() {
progressDrawable = new TintableRatingBarProgressDrawable();
setProgressDrawable(progressDrawable);
}
public void setCustomTintColors(final int _uncheckedColor, final int _pressedColor, final int _checkedColor) {
progressDrawable.setRatingMaxLevelValue(getMax() * 1000);
progressDrawable.setUnCheckedColor(_uncheckedColor);
progressDrawable.setPressedColor(_pressedColor);
progressDrawable.setCheckedColor(_checkedColor);
invalidate();
}
public class TintableRatingBarProgressDrawable extends Drawable {
private static final int STAR_COUNT = 5;
private static final int STAR_BRANCHES_COUNT = 5;
/** Sets the max level value: if the level is at the max, then all stars are selected. */
private int ratingMaxLevelValue = 10000;
/** Color to be painted for unselected stars */
private int uncheckedColor = Color.GRAY;
/** Color to be painted for unselected stars when the ratingbar is pressed */
private int pressedColor = Color.CYAN;
/** Color to be painted for selected stars */
private int checkedColor = Color.BLUE;
@Override
public void setAlpha(final int _i) {
}
@Override
public void setColorFilter(final ColorFilter _colorFilter) {
}
@Override
public boolean isStateful() {
return true;
}
@Override
public boolean setState(final int[] stateSet) {
final boolean res = super.setState(stateSet);
invalidateSelf();
return res;
}
@Override
public int getOpacity() {
return 255;
}
public void setRatingMaxLevelValue(final int _ratingMaxLevelValue) {
ratingMaxLevelValue = _ratingMaxLevelValue;
}
public void setUnCheckedColor(final int _uncheckedColor) {
uncheckedColor = _uncheckedColor;
}
public void setPressedColor(final int _pressedColor) {
pressedColor = _pressedColor;
}
public void setCheckedColor(final int _checkedColor) {
checkedColor = _checkedColor;
}
@Override
public void draw(final Canvas _canvas) {
boolean pressed = false;
for (int i : getState()) {
if (i == Android.R.attr.state_pressed) {
pressed = true;
}
}
final int level = (int) Math.ceil(getLevel() / (double) ratingMaxLevelValue * STAR_COUNT);
final int starRadius = Math.min(getBounds().bottom / 2, getBounds().right / STAR_COUNT / 2);
for (int i = 0; i < STAR_COUNT; i++) {
final int usedColor;
if (level >= i + 1) {
usedColor = checkedColor;
} else if (pressed) {
usedColor = pressedColor;
} else {
usedColor = uncheckedColor;
}
drawStar(_canvas, usedColor, (i * 2 + 1) * starRadius, getBounds().bottom / 2, starRadius,
STAR_BRANCHES_COUNT);
}
}
private void drawStar(final Canvas _canvas, final int _color, final float _centerX, final float _centerY,
final float _radius, final int _branchesCount) {
final double rotationAngle = Math.PI * 2 / _branchesCount;
final double rotationAngleComplement = Math.PI / 2 - rotationAngle;
//Calculating how much space is left between the bottom of the star and the bottom of the circle
//In order to be able to center the star visually relatively to the square when drawn
final float bottomOffset = (float) (_radius - _radius * Math.sin(rotationAngle / 2) / Math.tan(
rotationAngle / 2));
final float actualCenterY = _centerY + (bottomOffset / 2);
final Paint paint = new Paint();
Paint.setColor(_color);
Paint.setStyle(Style.FILL);
final Path path = new Path();
final float relativeY = (float) (_radius - _radius * (1 - Math.sin(rotationAngleComplement)));
final float relativeX = (float) (Math.tan(rotationAngle / 2) * relativeY);
final PointF a = new PointF(-relativeX, -relativeY);
final PointF b = new PointF(0, -_radius);
final PointF c = new PointF(relativeX, -relativeY);
path.moveTo(_centerX + a.x, actualCenterY + a.y);
_canvas.save();
for (int i = 0; i < _branchesCount; i++) {
path.lineTo(_centerX + b.x, actualCenterY + b.y);
path.lineTo(_centerX + c.x, actualCenterY + c.y);
rotationToCenter(b, rotationAngle);
rotationToCenter(c, rotationAngle);
}
_canvas.drawPath(path, Paint);
_canvas.restore();
}
private void rotationToCenter(final PointF _point, final double _angleRadian) {
final float x = (float) (_point.x * Math.cos(_angleRadian) - _point.y * Math.sin(_angleRadian));
final float y = (float) (_point.x * Math.sin(_angleRadian) + _point.y * Math.cos(_angleRadian));
_point.x = x;
_point.y = y;
}
}
}
1) erkläre diese xml
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:layout_alignParentBottom="true"
Android:orientation="horizontal"
Android:paddingLeft="20dp"
Android:paddingRight="20dp"
Android:layout_marginBottom="20dp"
Android:background="#323232"
Android:gravity="center_horizontal">
<com.example.Android.custom_ratingbar.CustomRatingBar
Android:id="@+id/coloredRatingBar5"
style="@style/coloredRatingBarStyleSmall"
Android:layout_width="wrap_content"
Android:layout_height="match_parent"
/>
</LinearLayout>
2) in style.xml
<style name="coloredRatingBarStyleSmall">
<item name="indicator">false</item>
<item name="type">small</item>
</style>
3)
import Android.content.Context;
import Android.content.res.Resources;
import Android.content.res.TypedArray;
import Android.graphics.Bitmap;
import Android.graphics.BitmapFactory;
import Android.graphics.Canvas;
import Android.graphics.Color;
import Android.graphics.Paint;
import Android.util.AttributeSet;
import Android.view.MotionEvent;
import Android.view.View;
public class CustomRatingBar extends View{
private static final String TAG="ColoredRatingBar";
private static final int NORMAL = 0;
private static final int SMALL = 1;
Bitmap[] drawables;
Bitmap progressBackground;
Context mContext;
private int mNumStars =9;
private float mRating =0;
private boolean mIndicator;
private float slidePosition;
private int mType;
/**
* A callback that notifies clients when the rating has been changed. This
* includes changes that were initiated by the user through a touch gesture
* or arrow key/trackball as well as changes that were initiated
* programmatically.
*/
public interface OnRatingBarChangeListener {
/**
* Notification that the rating has changed. Clients can use the
* fromUser parameter to distinguish user-initiated changes from those
* that occurred programmatically. This will not be called continuously
* while the user is dragging, only when the user finalizes a rating by
* lifting the touch.
*
* @param ratingBar The RatingBar whose rating has changed.
* @param rating The current rating. This will be in the range
* 0..numStars.
* @param fromUser True if the rating change was initiated by a user's
* touch gesture or arrow key/horizontal trackbell movement.
*/
void onRatingChanged(CustomRatingBar ratingBar, float rating, boolean fromUser);
}
private OnRatingBarChangeListener mOnRatingBarChangeListener;
public CustomRatingBar(Context context) {
this(context, null);
}
public CustomRatingBar(Context context, AttributeSet attrs) {
this(context, attrs,0);//R.attr.coloredRatingBarStyle
}
public CustomRatingBar(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CustomRatingBar,defStyle, 0);
final boolean indicator = a.getBoolean(R.styleable.CustomRatingBar_indicator, false);
final float rating = a.getFloat(R.styleable.CustomRatingBar_setrating, -1);
final int type = a.getInt(R.styleable.CustomRatingBar_type, 0);
a.recycle();
setIndicator(indicator);
setRating(rating);
setType(type);
init(context);
}
public int getType() {
return mType;
}
public void setType(int type) {
this.mType = type;
}
private void init(Context context) {
mContext = context;
Resources res = getResources();
if(mType==SMALL){
drawables = new Bitmap[]{BitmapFactory.decodeResource(res, R.drawable.rating_inactive),BitmapFactory.decodeResource(res, R.drawable.rating_active)};
progressBackground = BitmapFactory.decodeResource(res, R.drawable.rating_inactive);
}else{
drawables = new Bitmap[]{BitmapFactory.decodeResource(res, R.drawable.rating_inactive),BitmapFactory.decodeResource(res, R.drawable.rating_active)};
progressBackground = BitmapFactory.decodeResource(res, R.drawable.rating_inactive);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
//draw empty stars bg
for(int i=0;i< mNumStars;i++){
drawStar(canvas,i);
}
}
private void drawStar(Canvas canvas, int position) {
float fraction = mRating -(position);
Bitmap ratedStar1 = getRatedStar();
Paint paint=getPaint(position);
int division=getSize();
Bitmap ratedStar=null;
Bitmap emptyStar=null;
if(!isInEditMode()){
ratedStar=Bitmap.createScaledBitmap(ratedStar1, division, division, false);
emptyStar=Bitmap.createScaledBitmap(progressBackground, division, division, false);
}
if((position)< mRating){
if(!isInEditMode()){
canvas.drawBitmap(ratedStar,(position* division),0,Paint);
}
} else{
if(!isInEditMode()){
canvas.drawBitmap(emptyStar,(position*division),0,null);
}
}
}
private int getSize(){
return (getWidth()/mNumStars);
}
private Bitmap getRatedStar() {
if(mRating==0){
return drawables[0];
}
else{
return drawables[1];
}
}
private Paint getPaint(int position){
int value=(255*(position+1))/mNumStars;
String hexString=Integer.toHexString(value).equals("0")?"00":Integer.toHexString(value);
String hexvalue="#"+hexString+"000000";//FEE98E
//Log.e("TAG", position+"/"+value+"/"+hexvalue);
Paint paint=new Paint();
Paint.setColor(Color.parseColor(hexvalue));
return Paint;
}
public int getNumStars() {
return mNumStars;
}
public void setNumStars(int numStars) {
this.mNumStars = numStars;
}
public float getRating() {
return mRating;
}
public void setRating(float rating) {
setRating(rating,false);
}
void setRating(float rating,boolean fromUser) {
if(rating>mNumStars){
this.mRating = mNumStars;
}
this.mRating = rating;
invalidate();
dispatchRatingChange(fromUser);
}
public boolean isIndicator() {
return mIndicator;
}
public void setIndicator(boolean indicator) {
this.mIndicator = indicator;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
if (progressBackground != null) {
final int width = progressBackground.getWidth() * mNumStars;
final int height = progressBackground.getHeight();
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
Bitmap emptyStar=Bitmap.createScaledBitmap(progressBackground, widthSize/mNumStars, widthSize/mNumStars, false);
int heightSize = emptyStar.getHeight();
setMeasuredDimension(resolveSizeAndState(widthSize, widthMeasureSpec, 0),
resolveSizeAndState(heightSize, heightMeasureSpec, 0));
}
else{
int desiredWidth = 100;
int desiredHeight = 50;
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
int width;
int height;
//Measure Width
if (widthMode == MeasureSpec.EXACTLY) {
//Must be this size
width = widthSize;
} else if (widthMode == MeasureSpec.AT_MOST) {
//Can't be bigger than...
width = Math.min(desiredWidth, widthSize);
} else {
//Be whatever you want
width = desiredWidth;
}
//Measure Height
if (heightMode == MeasureSpec.EXACTLY) {
//Must be this size
height = heightSize;
} else if (heightMode == MeasureSpec.AT_MOST) {
//Can't be bigger than...
height = Math.min(desiredHeight, heightSize);
} else {
//Be whatever you want
height = desiredHeight;
}
//MUST CALL THIS
setMeasuredDimension(resolveSizeAndState(width, widthMeasureSpec, 0),resolveSizeAndState(height, heightMeasureSpec, 0));
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if(mIndicator){
return false;
}
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
break;
case MotionEvent.ACTION_MOVE:
case MotionEvent.ACTION_UP:
slidePosition = getRelativePosition(event.getX());
int newRating = (int)(slidePosition>0?slidePosition+1:0) ;
if(newRating>mNumStars){
newRating=mNumStars;
}
// Log.e("TAG", ""+newRating);
if (newRating != mRating) {
setRating(newRating,true);
}
break;
case MotionEvent.ACTION_CANCEL:
break;
default:
break;
}
return true;
}
private float getRelativePosition(float x) {
Bitmap emptyStar=Bitmap.createScaledBitmap(progressBackground, getWidth()/mNumStars, getWidth()/mNumStars, false);
int widthSize = emptyStar.getWidth();
// Log.e("TAG", widthSize+"/"+x);
float position = x / widthSize;
position = Math.max(position, 0);
return Math.min(position, mNumStars);
}
/**
* Sets the listener to be called when the rating changes.
*
* @param listener The listener.
*/
public void setOnRatingBarChangeListener(OnRatingBarChangeListener listener) {
mOnRatingBarChangeListener = listener;
}
/**
* @return The listener (may be null) that is listening for rating change
* events.
*/
public OnRatingBarChangeListener getOnRatingBarChangeListener() {
return mOnRatingBarChangeListener;
}
void dispatchRatingChange(boolean fromUser) {
if (mOnRatingBarChangeListener != null) {
mOnRatingBarChangeListener.onRatingChanged(this, getRating(),
fromUser);
}
}
}
5) then in calling activity---
CustomRatingBar coloredRatingBar5=(CustomRatingBar)findViewById(R.id.coloredRatingBar5);
coloredRatingBar5.setOnRatingBarChangeListener(new OnRatingBarChangeListener() {
@Override
public void onRatingChanged(CustomRatingBar ratingBar, float rating,boolean fromUser) {
// TODO Auto-generated method stub
Log.e("RATING", ""+rating);
}
});
6) Bewertung aktiv --- Nehmen Sie ein Bild mit dunkler Farbe, es wird als Farbtransparenz für unterschiedliche Bewertungen verwendet
rating_inactive - Nehmen Sie ein beliebiges Bild derselben Größe wie das obige Bild mit hellem Hintergrund auf .. es wird verwendet, wenn keine Bewertung ausgewählt ist
Die Umrandungsfarbe der Sterne kann sehr einfach mit dem XML-Parameter geändert werden:
Android:progressBackgroundTint=""
in der ratingbar-Ansicht. Der Wert sollte ein Hexadezimalcode für eine Farbe sein.
Diesen Link verwenden
Android RatingBar Sternfarben ändern
setzen Sie Ihren Stil innerhalb des Werts/Stils (v-21);
Die Bewertungsleiste wird zur Laufzeit automatisch verwendet, um die Farbe des Berührungssterns zu ändern.
Fügen Sie zunächst den Stil in der Datei app\src\main\res\values \ styles.xml hinzu:
<style name="RatingBar" parent="Theme.AppCompat">
<item name="colorControlNormal">@Android:color/darker_gray</item>
<item name="colorControlActivated">@color/com_facebook_blue</item>
</style>
Dann fügen Sie Ihrer Bewertungsleiste ein Thema hinzu:
<RatingBar
Android:id="@+id/rating"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:numStars="5"
Android:stepSize="1"
Android:theme="@style/RatingBar"/>