it-swarm.com.de

Android RatingBar ändert die Sternfarben

Wie kann ich die Sternfarben ändern und wie kann ich die Größe der Sterne ändern?

132
d-man

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.

25
CommonsWare

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.

119
Alex

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);
90
Mirek Michalak

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"/>
59
Vishal Kumar

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

47
lgvalle

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

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.

30
superpuccio

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
25
dirkoneill

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.

23
box

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.

12
Dan Dar3

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" />
10
hidro

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"
9
Rahul

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.

7
letrounet

Der einfachste Weg:

Android:progressTint="@color/color"
5
Mehatab
<!--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

4
Sibasish

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"/>
4
4ndro1d

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.

4
splangi

Verwenden Sie dazu einfach die AppCompatRatingBar und ihre setProgressTintList -Methode dies Antwort als Referenz.

3
Kuldeep Sakhiya

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
3
Arbitur
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 ....

2
Vimesh Pk

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);
2
Hai Rom

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.

1
Hardik4560

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.

1
JDenais

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.

0
Martial Konvi

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;
        }
    }
}
0
androidseb

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

0
amit

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

0
Jatin Bansal

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"/>
0
Navadip Patel