Android: determining if code should be in activity or user view

Question

As I am familiar with working with actions and user views, I constantly had to decide where the code should go, which is related to both the view and the parent action. Add to the user objects that should be accessible by both, and the options for how to structure the code are endless. Here are the features of my problem:

Relevant classes / files:
GameActivity extends Activity: The layout used contains some custom views.

MapView extends View: this is contained in the layout used by GameActivity

World: a custom class that defines a custom World object

Expected Result:
GameActivity pulls out a layout using MapView. The onDraw () function of MapView draws a map on the canvas using information from the World object.

Problem:
The World object that MapView requires is loaded from a previously saved file. I can get this object in MapView in different ways, and that is where I get hesitant. I went through the following iterations. (Note that they all work. What I'm looking for is reasons to use one path over another.)

Version1:
GameActivity: all he does is setContentLayout (layout_with_mapview_in_it.xml)

MapView: has all the code to load a World object from a file and uses it to reference the necessary drawing options

World: a simple custom w / 3 parameter class in its constructor

Then I decided that loading the World object from the file should be a method of the World class itself, and not what was done in the onCreate () method of MapView. Since loading a world file is something that you will never get around without a World object, it makes sense that it should be a class method. So I created the loadWorld (String world_name) method in the World class. Now the files looked like this:

Version2:
GameActivity: all he does is setContentLayout (layout_with_mapview_in_it.xml)

MapView: creates a new World object using the constructor, then calls its loadWorld () method to update it with the file information

World: a simple custom class with w / 3 parameters in it constructor and loadWorld () method

Finally, I decided that there should only be drawing in MapView. The whole point of having a World object is to skip it, right? So I moved World Construction / loading from View and to Activity. This led to the need to create the setter method in MapView in order to be able to pass the World object from the parent activity where it is created.

Version3:
GameActivity: sets the layout, creates a World object, and calls its loadWorld () to load it from the file. MapView references by identifier, then calls the setWorld () method of MapView to pass an instance of the World object over

MapView: The World object is set externally. Draws a map using information about this object.

World: a simple custom class with w / 3 parameters in it constructor and loadWorld () method.

Alright, so where am I now. My problem is that, although I like the conventions that I have chosen in terms of the fact that the views contain only code related to the drawing, and storing the methods associated with the classes in their classes - it seems when I switch to this method, I I suddenly create temporary objects more often and transferring objects from activity to activity for viewing and the like. This seems a lot more overhead, but at the same time, what is the whole point of abstraction right? Select the class to then instantiate the object and pass it. But for some reason, it seems to me that the more I abstract things, the more difficult the objects are to process.

I guess I'm trying to ask here, am I making things harder by simply not loading World from a file into MapView myself? Am I just stubborn not wanting to have code that involves reading an object from a file in the View class? Is it better to have it in your class or in the Office? What do I need to consider when making these decisions? Is there a solution to my dilemma that I don’t even suspect?

I think that the answer will be a personal preference, but I want to get an idea of ​​whether there are conventions there to do this anyway, or if there are good reasons why to structure a certain path. I tried to find the answers to this question, but I think that I am using the wrong search terms. I continue to work on material that describes how to structure the structure of the activity / presentation, but contains nothing code inside. When there is code, inevitably someone teaches how to transfer data between actions or between activity and presentation, etc. I know all these methods. I just don't know which one to use.

Some of the links I looked at are:
Multiple Views Android App - Best Practices?
Android - Actions against views
Android Actions and Views
Android: which is better - a few actions or switching views manually?

EDIT: more detailed information on application structure and code samples is included

GameActivity:

/*IMPORT STATEMENTS REMOVED*/ public class GameActivity extends Activity implements OnTouchListener { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.game); Log.d("LOGCAT", "GameActivity Started"); //get the world_name from MenuActivity Intent intent = getIntent(); String world_name = intent.getStringExtra(MenuActivity.EXTRA_MESSAGE); //load the world World world = loadWorld(world_name); //create a tilemap and get the tile translator array from it //need to convert this to a static Map TileMap tileMap = new TileMap(this); Map<Integer,Bitmap> tileTranslator = tileMap.getTileTranslator(); //Create a reference to the MapView object and set the translator MapView mapView = (MapView) findViewById(R.id.map_view); mapView.setArgs(world, tileTranslator); //implement the OnTouchSwipeListener mapView.setOnTouchListener(new OnSwipeTouchListener() { /*CODE REMOVED*/ }); } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case android.R.id.home: NavUtils.navigateUpFromSameTask(this); return true; } return super.onOptionsItemSelected(item); } public World loadWorld(String world_name) { //Create a dummy world to load into - why?! World dummy_world = new World(); //load the world Log.d("LOGCAT", "Loading the World"); try { World world = dummy_world.loadWorld(this, world_name); return world; } catch (IOException e) { //do nothing! } catch (ClassNotFoundException f) { //do nothing! } return dummy_world; //if world load fails, send back the default world // NOTE: it not saved!!! } } 

MapView:

 /*IMPORT STATEMENTS REMOVED*/ public class MapView extends View implements OnClickListener { protected Context context; public World world; public Map<Integer,Bitmap> tileTranslator; //hardcoded variables for testing private int tile_width = 50; private int tile_height = 50; public int screen_width = 12; public int screen_height = 6; public int playerX = 4; public int playerY = 7; public MapView(Context context, AttributeSet attrs) { super(context, attrs); this.context = context; Log.d("LOGCAT", "MapView created"); setOnClickListener(this); } @Override public void onDraw(Canvas canvas) { /*CODE REMOVED*/ } //ugly method, need to break it out into individual setters public void setArgs(World world, Map<Integer,Bitmap> tileTranslator){ this.world = world; this.tileTranslator = tileTranslator; } } 

World:

 /*IMPORT STATEMENTS REMOVED*/ public class World implements Serializable { public String world_name; public int world_width; public int world_height; public int[][] world_map; public World() { //default world - I don't even want this constructor here! world_name = "default_world"; world_width = 1; world_height = 1; world_map = createWorld(world_width, world_height); } public World(String world_name, int world_width, int world_height) { //set the world attributes this.world_name = world_name; this.world_width = world_width; this.world_height = world_height; //generate the map world_map = createWorld(world_width, world_height); } private int[][] createWorld(int world_width, int world_height) { //create a local tile map int[][] world_map = new int[world_width][world_height]; //get a randomizer to fill the array with - {temporary solution} Random rand = new Random(); //fill the tile map array with random numbers between 0 and 2 for(int row = 0; row < world_map.length; row++) { for (int col = 0; col < world_map[row].length; col++) { world_map[row][col] = rand.nextInt(3); //static number, needs variable! //3 is the number of tile types } } return world_map; } public void saveWorld(Context context, String world_name, World world) throws IOException { FileOutputStream fos = context.openFileOutput(world_name, Context.MODE_PRIVATE); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(world); oos.close(); } public World loadWorld(Context context, String world_name) throws IOException, ClassNotFoundException { FileInputStream fis = context.openFileInput(world_name); ObjectInputStream ois = new ObjectInputStream(fis); World world = (World)ois.readObject(); /*this.world_name = world.world_name; this.world_width = world.world_width; this.world_height = world.world_height; this.world_map = world.world_map;*/ //why doesn't this work? return world; } } 

Some codes have been removed to save space. Let me know if any of the deleted codes or other activities will be helpful.

More on what's going on behind the scenes:

The application starts with a MenuActivity, in which there are two buttons, each of which leads to a different action: WorldGenerationActivity or WorldSelectionActivity.

In WorldGenerationActivity, the user is shown a TextEdit screen and a button. They enter parameters for the world they want to generate (world_name, world_width, world_height). As soon as they click the button, a World object is created and saved in the file, using the name world_name as the file name. The file is saved using the saveWorld (String world_name) method, available in the World class. An instance of the newly created World object has a saveWorld () method called, the file is saved, and the user returns to the parent MenuActivity element through a call to complete ().

In WorldSelectionActivity, the user is shown a ListView that is connected to an ArrayAdapter. An array of file names is created from the files contained in the world save folder, and the adapter allows listview to display these file names in a list. The user selects one, and the selection is sent back to parentMenuActivity as a string through aim.putExtra (). WorldSelectionActivity is started for the result, so it ends, and we return to MenuActivity.

When MenuActivity returns a result from WorldSelectionActivity, it stores the putExtra () message in the parameter, and then calls GameActivity. It sends a message to GameActivity through another putExtra ().

GameActivity receives the message and saves it in the world_name variable. Then it creates a World object and passes the world_name string to the loadWorld (String world_name) method of the World class, which loads the specific world requested by the user earlier from the previous file save. I seemed to be silent about how this is handled in my previous explanation. Since I need a World object to load the world, I have to first create a dummy World object in GameActivity, and then call its loadWorld method and pass the result to another newly created World object. This led to the fact that I had to include a parameterless constructor in the World Class, which I did not need there. I am not sure why I could not get it to work without creating a mannequin in the world. I tried to put the logic of reading the file into the constructor without parameters, but that didn't work either. I think I missed something, but this is not my biggest problem at this point.

MapView is one of the views contained in GameView. Entering your onDraw () method requires information from a World object. Previously, I had all the loading and construction in the world, and then I only needed to create the world once and do everything that I wanted with it. As soon as I moved the loadWorld () method from MapView to the World class itself, and also transferred the call to this method from MapView and GameActivity, it seemed like I was suddenly creating temporary World objects everywhere. I am wondering if there is a cleaner way to do this and still keep things in classes that make sense.

Answer 1

I think your version 3 is really better than the other two: your model (i.e. World ) is independent of your view ( MapView ) and your controller ( GameActivity ) linking them together.

I think that you can improve the way you create a World object using the Builder template so that the task of creating it is in a separate class. Let me show you what I mean:

 public class WorldBuilder { private File worldFile; private String name = "default_world"; private int width = 1; private int height = 1; public static WorldBuilder fromFile(File worldFile){ WorldBuilder worldBuilder = new WorldBuilder(); worldBuilder.worldFile = worldFile; return worldBuilder; } public WorldBuilder withName(String name){ this.name= name; return this; } public WorldBuilder withWidth(int width){ this.parameter2 = param2; return this; } public WorldBuilder withHeight(int height){ this.height = height; return this; } public World build(){ World world = new World(name,width,height); if(worldFile!=null) world.loadWorld(worldFile); return world; } } 

In GameActivity, you can create a world with a single line of code:

 World world = WorldBuilder.fromFile(worldFile) .withName(p1) .withWidth(p2) .withHeight(p3) .build(); 

And if you need to create a world with default parameters, you can simply write:

 World world = WorldBuilder.fromFile(null).build(); 

EDIT

Where to write the code?

All computational code that relies only on World data can be written in the World class. Never pass MapView as an argument to the World method (keep the model independent of the view).

As much as possible, try to organize your code in such a way that MapView not performed in MapView . MapView should contain only code directly related to the display.

Answer 2

Make your world a singleton class with several static methods that will receive the necessary information.

Here's a crazy example:

 public class World { private Rect mWorldAABB; private static World sInstance = null; private World() { // Put your code to read whatever you want from file }; private static World getInstance() { if (sInstance == null) { sInstance = new World(); } return sInstance; } private Rect getWorldRect() { return mWorldAABB; } public static Rect getWorldDimensions() { return getInstance().getWorldRect(); } 

In this implementation, you can access your "world" from Activity and View through static calls to the a-la World.getWorldDimensions () methods. The world instance is private and static. In addition, due to lazy initialization, it will be created and initialized only the first time you ask for something about the "world". In this example, as soon as you call World.getWorldDimensions (), the getInstance () method will create an object of the World class, and any subsequent call to getWorldDimensions will reuse the object. So basically, you can use this skeleton and add as many “public static” modes as you want.