Android RatingBar cambia colores estrella

¿Cómo puedo cambiar los colores de las estrellas y cómo puedo cambiar el tamaño de las estrellas?

Paso # 1: Crea tu propio estilo, clonando uno de los estilos existentes (desde $ANDROID_HOME/platforms/$SDK/data/res/values/styles.xml ), colocándolo en el propio styles.xml tu proyecto y haciendo referencia a él cuando agrega el widget a un diseño.

Paso # 2: Crea tus propios recursos XML LayerDrawable para la RatingBar , apuntando a las imágenes apropiadas para usar en la barra. Los estilos originales lo dirigirán a los recursos existentes con los que puede comparar. Luego, ajuste su estilo para usar sus propios recursos LayerDrawable , en lugar de los integrados.

Es un poco complicado en el blog mencionado, he usado una manera similar pero más simple. Necesitas imágenes de 3 estrellas (red_star_full.png, red_star_half.png y red_star_empty.png) y un xml, eso es todo.

Pon estas 3 imágenes en res / dibujables.

Coloque allí el siguiente ratingbar_red.xml:

       

y, finalmente, diga a su definición de la barra de calificación que use esto, es decir,

  

Eso es.

Intenta esto, si solo quieres cambiar el color:

 RatingBar ratingBar = (RatingBar) findViewById(R.id.ratingBar); LayerDrawable stars = (LayerDrawable) ratingBar.getProgressDrawable(); stars.getDrawable(2).setColorFilter(Color.YELLOW, PorterDuff.Mode.SRC_ATOP); 

La forma más fácil que funcionó para mí … si estás ampliando la actividad de AppCompat

En su build.gradle, agregue la última biblioteca de appcompat.

 dependencies { compile 'com.android.support:appcompat-v7:XXX' // where XXX version } 

Amplíe su actividad android.support.v7.app.AppCompatActivity

 public class MainActivity extends AppCompatActivity { ... } 

Declara estilo personalizado en tu archivo styles.xml.

  

Aplica este estilo a tu RatingBar mediante el atributo android: theme.

  

Actualización 2015

Ahora puedes usar DrawableCompat para teñir todo tipo de objetos arrastrables . Por ejemplo:

 Drawable progress = ratingBar.getProgressDrawable(); DrawableCompat.setTint(progress, Color.WHITE); 

Esto es compatible con versiones anteriores hasta API 4

Si desea cambiar el color de todas las estrellas, indique mi uso:

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

Desde la API 21 es muy fácil cambiar el color de las estrellas con estas tres líneas:

 android:progressTint="@android:color/holo_red_dark" android:progressBackgroundTint="@android:color/holo_red_dark" android:secondaryProgressTint="@android:color/holo_red_dark" 

Al hacerlo, cambia el color de fondo y el color del borde de las estrellas.

Las soluciones que Alex y CommonsWares publicaron son correctas. Sin embargo, una cosa que el Android nunca menciona es el tamaño de píxel adecuado para diferentes densidades. Aquí están las dimensiones requeridas para cada densidad en función de la luz halo.

Pequeña estrella

 mdpi: 16px hdpi: 24px xhdpi: 32px xxhdpi: 48px 

Estrella mediana

 mdpi: 24px hdpi: 36px xhdpi: 48px xxhdpi: 72px 

Estrella grande

 mdpi: 35px hdpi: 52px xhdpi: 69px xxhdpi: 105px 

Así que he estado luchando con este problema durante dos horas y he encontrado una solución de trabajo para todas las versiones de API, donde también se muestran las calificaciones de estrellas.

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

Llame al método con este orden de dibujables:

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

NOTA: También debe especificar los atributos “max” y “numStars” en XML; de lo contrario, no se mostrarán las medias estrellas.

Ahora puede usar DrawableCompat desde AppCompat v22.1.0 en adelante para aplicar tintes dynamics a todo tipo de elementos dibujables, útil cuando admite varios temas con un único conjunto de elementos dibujables. Por ejemplo:

 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 

Esto es compatible con versiones anteriores hasta API 4. También vea la publicación de blog de Chris Banes en Support Libraries v22.1.0

Para el tamaño y la forma reales, deberá definir un nuevo estilo y una lista de capas para el tamaño apropiado, ya que otros ya han respondido anteriormente.

Solo por cambiar el color de la barra de calificación de xml: –

 android:progressTint="@color/your_color" android:backgroundTint="@color/your_color" android:secondaryProgressTint="@color/your_color" 

Use android:theme atributo de android:theme :

styles.xml

  

layout.xml

  

Para cambiar el color solo tienes que poner el parámetro android: progressTint

   

Para el tamaño de la propiedad de estilo.

La respuesta de Building @ lgvalle.

Actualización 2015

Ahora puedes usar DrawableCompat para teñir todo tipo de objetos arrastrables. Por ejemplo:

Avance Drawable = ratingBar.getProgressDrawable (); DrawableCompat.setTint (progress, Color.WHITE); Esto es compatible con versiones anteriores hasta 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)); 

Esto mantendrá la fracción de pasos de colores.

   

usa tu propio color

Sin agregar un nuevo estilo, puede usar el color del tinte dentro de la RatingBar

   

Funciona para Android por debajo y por encima de la versión 21

Después de algunas investigaciones, se me ocurrió este método para establecer el tinte de fondo, el tinte del espacio (por ejemplo, media estrella) y el color del tinte de la estrella.

 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 

Resuelvo este problema de la siguiente manera:

 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); 
 RatingBar mRating=(RatingBar)findViewById(R.id.rating); LayerDrawable layerDrawable=(LayerDrawable)mRating.getProgressDrawable(); layerDrawable.getDrawable(2).setColorFilter(Color.parseColor ("#32CD32"), PorterDuff.Mode.SRC_ATOP); 

para mí funciona …

La manera más simple:

 android:progressTint="@color/color" 

Encontré una solución simple para cambiar el color de la estrella de acuerdo con su tema.

Vaya a este sitio: http://android-holo-colors.com/

Elige el color de tu tema y crea tus imágenes estrella.

Utilizando las respuestas anteriores, creé un método rápido y estático que se puede reutilizar fácilmente. Solo tiene como objective teñir el color de progreso de las estrellas activadas. Las estrellas que no están activadas permanecen grises.

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

Solo pase su barra de clasificación y un Color usando getResources().getColor(R.color.my_rating_color)

Como puede ver, uso DrawableCompat por lo que es compatible con versiones anteriores.

EDITAR: Este método no funciona en API21 (entérate por qué). Usted termina con una NullPointerException al llamar a setProgressBar. Terminé deshabilitando todo el método en API> = 21.

Para API> = 21, uso la solución SupperPuccio.

1) declara este xml

    

2) en style.xml

  

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) rating active — tome cualquier imagen con color oscuro porque se usará como transparencia de color para diferentes clasificaciones

rating_inactive – toma cualquier imagen del mismo tamaño de la imagen de arriba con fondo claro .. se usará cuando no se seleccione ninguna calificación

Una forma muy fácil de cambiar el color del borde de las estrellas es usar el parámetro xml:

 android:progressBackgroundTint="" 

en la vista de calificación de barra. El valor debe ser un código hexadecimal para un color.

Estaba buscando un método confiable para hacer esto hasta API 9 al menos. La solución de “conversión a LayerDrawble” me pareció una solución arriesgada, y cuando la probé en un teléfono con Android en 2.3, funcionó correctamente, pero la llamada a DrawableCompat.setTint (…) no tuvo ningún efecto.

La necesidad de cargar activos dibujables tampoco me pareció una buena solución.

Decidí codificar mi propia solución, que es una clase que amplía AppCompatRatingBar, utilizando un Drawable personalizado que se ocupa de dibujar las estrellas programáticamente. Funciona perfectamente para mis necesidades, lo publicaré en caso de que ayude a alguien:

https://gist.github.com/androidseb/2b8044c90a07c7a52b4bbff3453c8460

El enlace es más fácil porque puede obtener el archivo completo directamente, pero aquí está el código completo por si acaso:

 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 * 

* 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 + ax, actualCenterY + ay); _canvas.save(); for (int i = 0; i < _branchesCount; i++) { path.lineTo(_centerX + bx, actualCenterY + by); path.lineTo(_centerX + cx, actualCenterY + cy); 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; } } }

A bit late answer but i hope it will help some folks.

  

And here is what the WhiteRatingStar looks like

  

With this the stars will be coloured in white for example.

Just edit or add

 #3b71c7 

in your resource value folder

Use this link

Android RatingBar change star colors

set your style inside value/style(v-21);

Simple solution, use AppCompatRatingBar and its setProgressTintList method to achieve this, see this answer for reference.

As the previous answer implies, it is not easy to change the color of the ratingbar. The stars are not programmatically drawn, they are images with fixed size and specific color gradients. To change the color you have to create your own star images with different colors then proceed to create your own drawable XML resource and pass it to the ratingsBar class using setProgressDrawable(Drawable d) or XML attribute android:progressDrawable.