trjhtr

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

<?xml version="1.0" encoding="utf-8"?>
<resources>
 <color name="colorOne">#123456</color>
</resources>

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