Java tutorial
/* * Copyright (C) 2016 Google Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.google.android.apps.santatracker.doodles.tilt; import android.content.Context; import android.support.annotation.VisibleForTesting; import android.util.Log; import com.google.android.apps.santatracker.doodles.shared.Actor; import com.google.android.apps.santatracker.doodles.shared.ExternalStoragePermissions; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import java.util.List; /** * A helper class which handles the saving and loading of levels for the doodle games. * * The {@code LevelManager} stores levels in a simple JSON format. The {@code Actor} classes wishing * to be managed by a {@code LevelManager} should handle their own serialization and * deserialization. */ public abstract class LevelManager<T extends TiltModel> { public static final String TAG = LevelManager.class.getSimpleName(); private static final String ACTORS_KEY = "actors"; protected final Context context; private final ExternalStoragePermissions storagePermissions; public LevelManager(Context context) { this(context, new ExternalStoragePermissions()); } @VisibleForTesting LevelManager(Context context, ExternalStoragePermissions storagePermissions) { this.context = context; this.storagePermissions = storagePermissions; } /** * Saves a level to persistent storage. * * @param level The level to save. * @param filename The name of the level's file on disk. This file will be stored inside of a * preset directory, defined by the LevelManager implementation. */ public void saveLevel(T level, String filename) { File levelsDir = getLevelsDir(); if (!levelsDir.exists() && !levelsDir.mkdirs()) { // If we are unable to find or make the desired output directory, log a warning and fail. Log.w(TAG, "Unable to reach dir: " + levelsDir.getAbsolutePath()); return; } try { FileOutputStream outputStream = new FileOutputStream(new File(levelsDir, filename)); saveLevel(level, outputStream); } catch (FileNotFoundException e) { Log.w(TAG, "Unable to save file: " + filename); } } /** * Writes a level to the provided OutputStream. * * @param level The level to save. * @param outputStream The stream to which the level should be written. */ @VisibleForTesting void saveLevel(T level, OutputStream outputStream) { try { saveActors(level.getActors(), outputStream); } catch (JSONException e) { Log.w(TAG, "Unable to create level JSON."); } catch (IOException e) { Log.w(TAG, "Unable to write actors to output stream."); } } /** * Loads a level from persistent storage. * * <p>This loads first tries to load a level from assets, falling back to external storage if * necessary. If it still cannot load the level, the default level will be loaded.</p> * * @param filename The name of the file to load. This file should be stored in a preset directory, * specified by the LevelManager implementation. * @return The loaded level. */ public T loadLevel(String filename) { if (filename == null) { Log.w(TAG, "Couldn't load level with null filename, using default level instead."); return loadDefaultLevel(); } BufferedReader externalStorageReader = null; try { externalStorageReader = new BufferedReader( new InputStreamReader(new FileInputStream(new File(getLevelsDir(), filename)), "UTF-8")); } catch (IOException e) { Log.d(TAG, "Unable to load file from external storage: " + filename); } BufferedReader assetsReader = null; try { assetsReader = new BufferedReader(new InputStreamReader(context.getAssets().open(filename), "UTF-8")); } catch (IOException e) { Log.d(TAG, "Unable to load file from assets: " + filename); } T model = loadLevel(externalStorageReader, assetsReader); model.setLevelName(filename); return model; } /** * Loads a level from either assets, or from external storage. * * <p>This first tries to load a level from assets, falling back to external storage if * necessary. If it still cannot load the level, the default level will be loaded.</p> * * <p>This method should only be used for testing LevelManager. Real use cases should generally * use {@code loadLevel(String filename)}.</p> * * @param externalStorageReader * @param assetsInputReader * @return The loaded level. */ @VisibleForTesting T loadLevel(BufferedReader externalStorageReader, BufferedReader assetsInputReader) { JSONObject json = null; if (assetsInputReader != null) { json = readLevelJson(assetsInputReader); Log.d(TAG, "Loaded level from assets."); } if (json == null && externalStorageReader != null && storagePermissions.isExternalStorageReadable()) { json = readLevelJson(externalStorageReader); Log.d(TAG, "Loaded level from external storage."); } if (json == null) { Log.w(TAG, "Couldn't load level data, using default level instead."); return loadDefaultLevel(); } T model = getEmptyModel(); try { JSONArray actors = json.getJSONArray(ACTORS_KEY); for (int i = 0; i < actors.length(); i++) { Actor actor = loadActorFromJSON(actors.getJSONObject(i)); if (actor != null) { model.addActor(actor); } } } catch (JSONException e) { Log.w(TAG, "Couldn't load actors, using default level instead."); return loadDefaultLevel(); } return model; } /** * Initializes the default level and returns it. * * <p>In general, this should be an empty or minimal level.</p> * * @return the initialized default level. */ public abstract T loadDefaultLevel(); /** * Returns the external storage directory within which levels of this type should be saved. * * @return The base directory which should be used to save levels. */ protected abstract File getLevelsDir(); /** * Loads a single actor from JSON. * * @param json The JSON representation of the actor to be loaded * @return The loaded actor, or null if the actor could not be loaded. * @throws JSONException if the JSON is malformed, or fails to be parsed. */ @VisibleForTesting abstract Actor loadActorFromJSON(JSONObject json) throws JSONException; /** * Returns an empty, or minimal model of the appropriate type. Generally, this should be the same * as asking for a {@code new T()}. * * @return The empty model. */ protected abstract T getEmptyModel(); /** * Returns a JSONArray containing the JSON representation of the passed-in list of actors. * * <p>If a given actor does not provide a JSON representation, it will not appear in the returned * JSONArray.</p> * * @param actors The actors to convert into JSON. * @return The JSON representation of the list of actors. * @throws JSONException If the parsing of an actor into JSON fails. */ @VisibleForTesting JSONArray getActorsJson(List<Actor> actors) throws JSONException { JSONArray actorsJson = new JSONArray(); for (Actor actor : actors) { JSONObject json = actor.toJSON(); if (json != null) { actorsJson.put(json); } } return actorsJson; } /** * Writes a list of actors to an OutputStream. * * @param actors The actors to be written. * @param outputStream The OuputStream which should be used to write the list of actors. * @throws JSONException If the conversion of actors into JSON fails. * @throws IOException If we fail to write to the OutputStream. */ private void saveActors(List<Actor> actors, OutputStream outputStream) throws JSONException, IOException { JSONObject json = new JSONObject(); json.put(ACTORS_KEY, getActorsJson(actors)); Log.d(TAG, json.toString(2)); if (storagePermissions.isExternalStorageWritable()) { writeLevelJson(json, outputStream); } else { Log.w(TAG, "External storage is not writable"); } } /** * Writes a JSONObject to an OutputStream. * * @param json The object to be written. * @param outputStream The stream to be written to. * @throws IOException If we fail to write to the OutputStream. */ private void writeLevelJson(JSONObject json, OutputStream outputStream) throws IOException { outputStream.write(json.toString().getBytes()); outputStream.close(); } /** * Read a JSONObject from a BufferedReader. * * @param reader The BufferedReader which contains the JSON to be read. * @return A JSONObject parsed from the contents of the BufferedReader. */ private JSONObject readLevelJson(BufferedReader reader) { try { String levelData = ""; String line = reader.readLine(); while (line != null) { levelData += line; line = reader.readLine(); } reader.close(); return new JSONObject(levelData); } catch (IOException e) { Log.w(TAG, "readLevelJson: Couldn't read JSON."); } catch (JSONException e) { Log.w(TAG, "readLevelJson: Couldn't create JSON."); } return null; } }