Static class for constants with reference to java resources I want to store the colors I use in the colors.xml file. In addition to using them in an xml-layout, I also want to use these colors in my Java code, when drawing things to the Canvas.

The thing is, I am not always using the colors in a class that extends Application. For example, I have classes for objects that get drawn to the Canvas.

The thing is, I don't want to store the context in each class that needs access to my resources file.

My current solution is the following:

colors.xml

&lt;?xml version="1.0" encoding="utf-8"?&gt;
&lt;resources&gt;
    &lt;color name="colorOne"&gt;#123456&lt;/color&gt;
&lt;/resources&gt;


A static class called Attributes for constants, including colors:

public class Attributes {
    private static final Resources RESOURCES = MainActivity.getContext().getResources();

    public static final int ONE_COLOR = RESOURCES.getColor(R.color.colorOne);
    public static final int SOME_OTHER_CONSTANT = 1;
}


MainActivity:

public class MainActivity extends Activity {

    private static Context context;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.context = getApplicationContext();

    @Override
    protected void onPause() {
        super.onPause();
    }

    @Override
    protected void onResume() {
        super.onResume();
    }

    public static Context getContext() {
        return context;
    }
}


And, finally in my object class:

public class ScreenArea {
    private Rect area;
    private Paint paint;

    public ScreenArea(Rect area) {
        this.area = area;
        paint = new Paint();
        paint.setColor(Attributes.COLOR_ONE);
    }

    public void draw(Canvas canvas) {
        canvas.drawRect(area, paint);
    }
}


Okay, so first of all, this works. But, I am wondering if this is the right way to go. I have been reading about the Singleton class, but most examples are very basic an not focusing on storing constants, like I am doing right now. 

So my questions:


Is this the right way to go or should I implement a Singleton? 
If so, who can point me in the right direction?
well as pointed out using singletons is considered bad practice and using global constants in an object-orientatd world is bad practice as well...

So, what is your suggestion? 



Consider the purpose of the attribute

you want to define a app-specific attribute (color), an attribute you want to configure - this is the very reason why you use ressources, right. Or do you want to define a constant?

 1. it's a constant

if you don't want to specify a configurable attribute you should define a constant in your app

private static final int COLOR_ONE = 0x123456;


 2. it's an attribute

but if you want to specify a configurable attribute you simply define it as such in your app:

int colorOne = MainActivity.getContext().getResources().getColor(R.color.colorOne); 


you are right, this might be a bit intricately so it would be just as simple to wrap this call in a method

private int getColorFromRessource(int colorId){
    return MainActivity.getContext().getResources().getColor(colorId); 
}


this would be applied in your setup of the Paint in an quite easy way:

public ScreenArea(Rect area) {
    this.area = area;
    paint = new Paint();
    paint.setColor(getColorFromRessource(R.color.colorOne)); //obvious
  //paint.setColor(Attributes.COLOR_ONE);  far less obvious
}