2
\$\begingroup\$

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?
\$\endgroup\$
  • \$\begingroup\$ "Is this the right way to go or should I implement a Singleton?" Using a Singleton is rarely a good decision. \$\endgroup\$ – πάντα ῥεῖ Jan 26 '18 at 11:31
  • \$\begingroup\$ @πάνταῥεῖ: So, what is your suggestion? \$\endgroup\$ – MWB Jan 28 '18 at 15:20
  • \$\begingroup\$ Not to use a Singleton. \$\endgroup\$ – πάντα ῥεῖ Jan 28 '18 at 17:39
  • \$\begingroup\$ And leave it the way I am currently doing? Doesn't that impose risks, considering app lifecycles etc? \$\endgroup\$ – MWB Jan 28 '18 at 17:41
2
\$\begingroup\$

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
}
\$\endgroup\$
  • \$\begingroup\$ I think this is pretty much what I am trying to do. The main difference is that I have defined a constant to store the color, where you wrap it all in a method. The advantage of the method is that you don't have a singleton. The disadvantage, I guess is that using a constant is more efficient, right? \$\endgroup\$ – MWB Mar 11 '18 at 12:15
  • 1
    \$\begingroup\$ Well it's up to you - if your color is a constant then you should define a constant in your code... if your color is an attribute you should define it in your xml and access it via the methods - just as answered above... \$\endgroup\$ – Martin Frank Mar 11 '18 at 18:33

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.