change color when int is changed in other class

I have IndicationBar class that should draw rectangle with logo inside and on int value case change rectangle color. I am new to java and android so im learning everyday. At this moment the value of int is changing in other class and i call it BluetoothChat.statusSviesos. its public static int. Do i need to create interface Listener or how can i run private void Sviesos() every time int is changed? It runs only once in start.

public class IndicationBar extends View {


    private static final String TAG = IndicationBar.class.getSimpleName();

    // drawing tools
    private RectF Rect;
    private Paint rectPaint;
    private Paint rimCirclePaint;

    private RectF faceRect;
    private Bitmap faceTexture;
    private Paint facePaint;
    private Paint rimShadowPaint;
    private Paint titlePaint;   
    private Path titlePath;

    private Paint logoPaint;
    private Bitmap logo;
    private Matrix logoMatrix;
    private float logoScale;

    private Paint backgroundPaint; 
    // end drawing tools

    private Bitmap background; // holds the cached static part



    public IndicationBar(Context context) {
        super(context);
        init();
    }

    public IndicationBar(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public IndicationBar(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }


    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        Bundle bundle = (Bundle) state;
        Parcelable superState = bundle.getParcelable("superState");
        super.onRestoreInstanceState(superState);

    }

    private void init() {
        initDrawingTools();
    }

//  private String getTitle() {
//      return "DANCER";
//  }

    private void Sviesos(){
        //Rect = new RectF(0.1f, 0.1f, 0.9f, 0.9f);
        //rectPaint = new Paint();
        //valueSviesos = BluetoothChat.statusSviesos;
        switch(BluetoothChat.statusSviesos){
        case 0 : rectPaint.setColor(Color.parseColor("#1BA1E2"));
        break;
        case 1 : rectPaint.setColor(Color.parseColor("#A05000"));
        break;
        case 2 : rectPaint.setColor(Color.parseColor("#E671B8"));
        break;
        case 3 : rectPaint.setColor(Color.parseColor("#F09609"));
        break;
        case 4 : rectPaint.setColor(Color.parseColor("#1BA1E2"));
        break;
        }
        //rectPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
    }


    private void initDrawingTools() {
        Rect = new RectF(0.1f, 0.1f, 0.9f, 0.9f);
        rectPaint = new Paint();    
        rectPaint.setColor(Color.parseColor("#8CBF26"));
        rectPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
        Sviesos();

        rimCirclePaint = new Paint();
        rimCirclePaint.setAntiAlias(true);
        rimCirclePaint.setStyle(Paint.Style.STROKE);
        rimCirclePaint.setColor(Color.argb(0x4f, 0x33, 0x36, 0x33));
        rimCirclePaint.setStrokeWidth(0.005f);

        float rimSize = 0.02f;
        faceRect = new RectF();
        faceRect.set(Rect.left + rimSize, Rect.top + rimSize, 
                Rect.right - rimSize, Rect.bottom - rimSize);       

        faceTexture = BitmapFactory.decodeResource(getContext().getResources(), 
                   R.drawable.plastic);
        BitmapShader paperShader = new BitmapShader(faceTexture, 
                                                    Shader.TileMode.MIRROR, 
                                                    Shader.TileMode.MIRROR);
        Matrix paperMatrix = new Matrix();
        facePaint = new Paint();
        facePaint.setFilterBitmap(true);
        paperMatrix.setScale(1.0f / faceTexture.getWidth(), 
                             1.0f / faceTexture.getHeight());
        paperShader.setLocalMatrix(paperMatrix);
        facePaint.setStyle(Paint.Style.FILL);
        facePaint.setShader(paperShader);

        rimShadowPaint = new Paint();
        rimShadowPaint.setShader(new RadialGradient(0.5f, 0.5f, faceRect.width() / 2.0f, 
                   new int[] { 0x00000000, 0x00000500, 0x50000500 },
                   new float[] { 0.96f, 0.96f, 0.99f },
                   Shader.TileMode.MIRROR));
        rimShadowPaint.setStyle(Paint.Style.FILL);

        titlePaint = new Paint();
        titlePaint.setColor(Color.parseColor("#1BA1E2"));
        titlePaint.setAntiAlias(true);
        titlePaint.setTypeface(Typeface.DEFAULT_BOLD);
        titlePaint.setTextAlign(Paint.Align.CENTER);
        titlePaint.setTextSize(0.09f);
        titlePaint.setTextScaleX(0.9f);

        titlePath = new Path();
        titlePath.addArc(new RectF(0.24f, 0.24f, 0.76f, 0.76f), -180.0f, -180.0f);

        logoPaint = new Paint();
        logoPaint.setFilterBitmap(true);
        logo = BitmapFactory.decodeResource(getContext().getResources(), R.drawable.sviesos);
        logoMatrix = new Matrix();
        logoScale = (1.0f / logo.getWidth()) * 0.3f;;
        logoMatrix.setScale(logoScale, logoScale);

        backgroundPaint = new Paint();
        backgroundPaint.setFilterBitmap(true);
    }



    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        Log.d(TAG, "Width spec: " + MeasureSpec.toString(widthMeasureSpec));
        Log.d(TAG, "Height spec: " + MeasureSpec.toString(heightMeasureSpec));

        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);

        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        int chosenWidth = chooseDimension(widthMode, widthSize);
        int chosenHeight = chooseDimension(heightMode, heightSize);

        int chosenDimension = Math.min(chosenWidth, chosenHeight);

        setMeasuredDimension(chosenDimension, chosenDimension);
    }

    private int chooseDimension(int mode, int size) {
        if (mode == MeasureSpec.AT_MOST || mode == MeasureSpec.EXACTLY) {
            return size;
        } else { // (mode == MeasureSpec.UNSPECIFIED)
            return getPreferredSize();
        } 
    }

    // in case there is no size specified
    private int getPreferredSize() {
        return 300;
    }

    private void drawRect(Canvas canvas) {
        // first, draw the metallic body

        canvas.drawRect(Rect, rectPaint);
        // now the outer rim circle
        //canvas.drawOval(rimRect, rimCirclePaint);
    }

//  private void drawFace(Canvas canvas) {      
//      canvas.drawOval(faceRect, facePaint);
//      // draw the inner rim circle
//      canvas.drawOval(faceRect, rimCirclePaint);
//      // draw the rim shadow inside the face
//      canvas.drawOval(faceRect, rimShadowPaint);
//  }

    private void drawBackground(Canvas canvas) {
        if (background == null) {
            Log.w(TAG, "Background not created");
        } else {
            canvas.drawBitmap(background, 0, 0, backgroundPaint);
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        drawBackground(canvas);

        float scale = (float) getWidth();       
        canvas.save(Canvas.MATRIX_SAVE_FLAG);
        canvas.scale(scale, scale);

        drawLogo(canvas);

        canvas.restore();
    }

    private void drawLogo(Canvas canvas) {
        canvas.save(Canvas.MATRIX_SAVE_FLAG);
        canvas.translate(0.5f - logo.getWidth() * logoScale / 2.0f, 
                         0.5f - logo.getHeight() * logoScale / 2.0f);
        canvas.drawBitmap(logo, logoMatrix, logoPaint);
        canvas.restore();       
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        Log.d(TAG, "Size changed to " + w + "x" + h);

        regenerateBackground();
    }

    private void regenerateBackground() {
        // free the old bitmap
        Sviesos();
        if (background != null) {
            background.recycle();
        }

        background = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
        Canvas backgroundCanvas = new Canvas(background);
        float scale = (float) getWidth();       
        backgroundCanvas.scale(scale, scale);

        drawRect(backgroundCanvas);     
    }


}

Use the Observer pattern for this. Change the BluetoothChat

public class BluetoothChat {

  private static int statusSviesos;

  //the list of observers
  private static List<Observer> observerList;

  //adds an observer to observe statusSciesos
  public static void addStatusSviesosObserver(Observer observer) {
      observerList.add(observer);
  }

  //getter function returns the value
  public static int getStatusSviesos(){
      return statusSviesos;
  }

  //setter function sets the value and notifies observer
  public static void setStatusSviesos(int statusSviesos){
      BluetoothChat.statusSviesos=statusSviesos;
      for(Observer current: observerList){
          current.notifyChange(statusSviesos);
      }
  }

  public static interface Observer {
      public void notifyChange(int newStatus);
  }
...

Then create an Observer in the IndicationBar and add it to the BluetoothChat:

Observer observer = new Observer() {
     @Override
     public void notifyChange(int newStatus) {
         Sviesos();
     }
};
BluetoothChat.addStatusSviesosObserver(observer);

This is a raw implementation of the Observer pattern. There should be a removeObserver-method too and it is not thread-safe. There is a default implementations ready in Java (Observer-class and Observable-class) and there are alternative implementations like PropertyChangeObserver. But for your current use case this should do the job. Also read Wikipedia and Vogellas tutorial

General tips:

• Does BluetoothChat's attribute really has to be static? I recommend you to use static as less as possible. Better create an Object once and pass it around instead. You can search for "global state" and why to avoid it for further information.
• You could create an array of Colors (or Color-strings like "#F09609") and access it with the int you get to get rid of the switch-statement.
• Try to apply code style conventions everywhere, method names and variables should always start with a small letter (except constants which are ALL_BIG) and should be descriptive.