diff options
Diffstat (limited to 'src/org/happysanta/gd/Storage')
-rw-r--r-- | src/org/happysanta/gd/Storage/HighScores.java | 152 | ||||
-rw-r--r-- | src/org/happysanta/gd/Storage/Level.java | 300 | ||||
-rw-r--r-- | src/org/happysanta/gd/Storage/LevelsDataSource.java | 293 | ||||
-rw-r--r-- | src/org/happysanta/gd/Storage/LevelsManager.java | 503 | ||||
-rw-r--r-- | src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java | 141 |
5 files changed, 1389 insertions, 0 deletions
diff --git a/src/org/happysanta/gd/Storage/HighScores.java b/src/org/happysanta/gd/Storage/HighScores.java new file mode 100644 index 0000000..e3678c9 --- /dev/null +++ b/src/org/happysanta/gd/Storage/HighScores.java @@ -0,0 +1,152 @@ +package org.happysanta.gd.Storage; + +import org.happysanta.gd.Settings; + +public class HighScores { + + private static final long MAX_TIME = 0xffff28L; + + private long id; + private long levelId = 0; + private int level = 0; + private int track = 0; + private long[][] times = new long[4][3]; + private String[][] names = new String[4][3]; + + public HighScores() { + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public long getLevelId() { + return levelId; + } + + public void setLevelId(long levelId) { + this.levelId = levelId; + } + + public int getLevel() { + return level; + } + + public void setLevel(int level) { + this.level = level; + } + + public long getTrack() { + return track; + } + + public void setTrack(int track) { + this.track = track; + } + + public long getTime(int league, int place) { + return times[league][place]; + } + + public void setTime(int league, int place, long value) { + times[league][place] = value; + } + + public String getName(int league, int place) { + return names[league][place]; + } + + public void setName(int league, int place, String value) { + names[league][place] = value; + } + + public String[] getScores(int league) { + String[] scores = new String[3]; + for (int places = 0; places < 3; places++) { + if (times[league][places] != 0L) { + int k = (int) times[league][places] / 100; + int l = (int) times[league][places] % 100; + scores[places] = names[league][places] + " "; + if (k / 60 < 10) + scores[places] += " 0" + k / 60; + else + scores[places] += " " + k / 60; + if (k % 60 < 10) + scores[places] += ":0" + k % 60; + else + scores[places] += ":" + k % 60; + if (l < 10) + scores[places] += ".0" + l; + else + scores[places] += "." + l; + } else { + scores[places] = null; + } + } + + return scores; + } + + public int getPlace(int league, long time) { + for (int place = 0; place < 3; place++) + if (times[league][place] > time || times[league][place] == 0L) + return place; + + return 3; + } + + private void clearTimes() { + for (int leagues = 0; leagues < 4; leagues++) { + for (int places = 0; places < 3; places++) + times[leagues][places] = 0L; + } + } + + public void saveHighScore(int league, String name, long time) { + name = trimName(name); + int place; + if ((place = getPlace(league, time)) != 3) { + if (time > MAX_TIME) + time = MAX_TIME; + moveScoreEntries(league, place); + + times[league][place] = time; + names[league][place] = name; + } + } + + private void moveScoreEntries(int league, int i) { + for (int place = 2; place > i; place--) { + times[league][place] = times[league][place - 1]; + names[league][place] = names[league][place - 1]; + } + } + + private static String trimName(String name) { + if (name.length() > 3) + name = name.substring(0, 3); + else if (name.length() < 3) + name = Settings.NAME_DEFAULT; + + return name.toUpperCase(); + } + + @Override + public String toString() { + StringBuilder s = new StringBuilder(); + s.append("Storage.HighScores {"); + + s.append("id: " + id + ", "); + s.append("level_id: " + levelId + ", "); + s.append("level: " + level + ", "); + s.append("track: " + track); + + s.append("}"); + return s.toString(); + } + +} diff --git a/src/org/happysanta/gd/Storage/Level.java b/src/org/happysanta/gd/Storage/Level.java new file mode 100644 index 0000000..3030b7b --- /dev/null +++ b/src/org/happysanta/gd/Storage/Level.java @@ -0,0 +1,300 @@ +package org.happysanta.gd.Storage; + +import android.text.format.DateUtils; + +import static org.happysanta.gd.Helpers.getGDActivity; + +public class Level { + + private long id = 0; + private String name; + private String author; + private int[] count; + private int size = 0; + private long addedTs = 0; + private long installedTs = 0; + private boolean _isDefault = false; + private long apiId = 0; + private int[] unlocked; + private int selectedTrack = 0; + private int selectedLevel = 0; + private int selectedLeague = 0; + private int unlockedLevels = 0; + private int unlockedLeagues = 0; + + public Level() { + count = new int[3]; + unlocked = new int[3]; + } + + public Level(long id, String name, String author, int countEasy, int countMedium, int countHard, int addedTs, int size, long apiId) { + this(id, name, author, countEasy, countMedium, countHard, addedTs, size, apiId, 0, 0, 0); + } + + public Level(long id, String name, String author, int countEasy, int countMedium, int countHard, int addedTs, int size, long apiId, int unlockedEasy, int unlockedMedium, int unlockedHard) { + this.id = id; + this.name = name; + this.author = author; + this.count = new int[]{ + countEasy, countMedium, countHard + }; + this.addedTs = addedTs; + this.size = size; + this.apiId = apiId; + this.unlocked = new int[]{ + unlockedEasy, unlockedMedium, unlockedHard + }; + } + + public long getId() { + return id; + } + + public long getAnyId() { + return id > 0 ? id : apiId; + } + + public void setId(long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getAuthor() { + return author; + } + + public void setAuthor(String author) { + this.author = author; + } + + public int getCountEasy() { + return this.count[0]; + } + + public int getCountMedium() { + return this.count[1]; + } + + public int getCountHard() { + return this.count[2]; + } + + public int getCount(int level) { + return this.count[level]; + } + + public void setCountEasy(int count) { + this.count[0] = count; + } + + public void setCountMedium(int count) { + this.count[1] = count; + } + + public void setCountHard(int count) { + this.count[2] = count; + } + + public void setCount(int easy, int medium, int hard) { + setCountEasy(easy); + setCountMedium(medium); + setCountHard(hard); + } + + public long getAddedTs() { + return addedTs; + } + + public void setAddedTs(long ts) { + addedTs = ts; + } + + public long getInstalledTs() { + return installedTs; + } + + public void setInstalledTs(long ts) { + installedTs = ts; + } + + public void setIsDefault(boolean isDefault) { + this._isDefault = isDefault; + } + + public boolean isDefault() { + return _isDefault; + } + + public long getApiId() { + return apiId; + } + + public void setApiId(long apiId) { + this.apiId = apiId; + } + + public int getSize() { + return size; + } + + public void setSize(int size) { + this.size = size; + } + + public boolean isInstalled() { + return id > 0; + } + + public String getSizeKb() { + return String.valueOf(Math.round((size / 1024f) * 100f) / 100f); + } + + public String getShortAddedDate() { + return getShortDate(addedTs); + } + + public String getFullAddedDate() { + return getFullDate(addedTs); + } + + public String getShortInstalledDate() { + return getShortDate(installedTs); + } + + public String getFullInstalledDate() { + return getFullDate(installedTs); + } + + public int getUnlockedEasy() { + return this.unlocked[0]; + } + + public int getUnlockedMedium() { + return this.unlocked[1]; + } + + public int getUnlockedHard() { + return this.unlocked[2]; + } + + public int getUnlocked(int level) { + //if (level < 3) + return unlocked[level]; + + //logDebug("Level.getUnlocked: level = " + level + ", out of bounds"); + //return 0; + } + + public int[] getUnlockedAll() { + return unlocked; + } + + public void setUnlockedEasy(int unlocked) { + this.unlocked[0] = unlocked; + } + + public void setUnlockedMedium(int unlocked) { + this.unlocked[1] = unlocked; + } + + public void setUnlockedHard(int unlocked) { + this.unlocked[2] = unlocked; + } + + public void setUnlocked(int easy, int medium, int hard) { + setUnlockedEasy(easy); + setUnlockedMedium(medium); + setUnlockedHard(hard); + } + + public void setUnlocked(int level, int value) { + unlocked[level] = value; + } + + public int getSelectedTrack() { + return selectedTrack; + } + + public int getSelectedLevel() { + return selectedLevel; + } + + public int getSelectedLeague() { + return selectedLeague; + } + + public void setSelectedTrack(int selectedTrack) { + this.selectedTrack = selectedTrack; + } + + public void setSelectedLevel(int selectedLevel) { + this.selectedLevel = selectedLevel; + } + + public void setSelectedLeague(int selectedLeague) { + this.selectedLeague = selectedLeague; + } + + public int getUnlockedLevels() { + return unlockedLevels; + } + + public int getUnlockedLeagues() { + return unlockedLeagues; + } + + public void setUnlockedLevels(int unlockedLevels) { + this.unlockedLevels = unlockedLevels; + } + + public void setUnlockedLeagues(int unlockedLeagues) { + this.unlockedLeagues = unlockedLeagues; + } + + public boolean isSettingsClear() { + return unlockedLevels == 0 + && unlocked[0] == 0 + && unlocked[1] == 0 + && unlocked[2] == 0; + } + + @Override + public String toString() { + StringBuilder s = new StringBuilder(); + s.append("Storage.Level {"); + + s.append("id: " + id + ", "); + s.append("name: \"" + name + "\", "); + s.append("author: \"" + author + "\", "); + s.append("count: " + count[0] + "/" + count[1] + "/" + count[2] + ", "); + s.append("added_ts: " + addedTs + ", "); + s.append("installed_ts: " + installedTs + ", "); + s.append("default: " + (_isDefault ? 1 : 0) + ", "); + s.append("api_id: " + apiId + ", "); + s.append("unlocked: " + unlocked[0] + "/" + unlocked[1] + "/" + unlocked[2] + ", "); + s.append("selected_track: " + selectedTrack + ", "); + s.append("selected_level: " + selectedLevel + ", "); + s.append("selected_league: " + selectedLeague + ", "); + s.append("unlocked_levels: " + unlockedLevels + ", "); + s.append("unlocked_leagues: " + unlockedLeagues); + + s.append("}"); + return s.toString(); + } + + private static String getShortDate(long date) { + return DateUtils.formatDateTime(getGDActivity(), date * 1000L, DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_ABBREV_MONTH); + } + + private static String getFullDate(long date) { + return DateUtils.formatDateTime(getGDActivity(), date * 1000L, DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR); + } + +} diff --git a/src/org/happysanta/gd/Storage/LevelsDataSource.java b/src/org/happysanta/gd/Storage/LevelsDataSource.java new file mode 100644 index 0000000..40e7f14 --- /dev/null +++ b/src/org/happysanta/gd/Storage/LevelsDataSource.java @@ -0,0 +1,293 @@ +package org.happysanta.gd.Storage; + +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; + +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import static org.happysanta.gd.Helpers.logDebug; + +public class LevelsDataSource { + + private SQLiteDatabase db; + private LevelsSQLiteOpenHelper dbHelper; + + public LevelsDataSource(Context context) { + dbHelper = new LevelsSQLiteOpenHelper(context); + } + + public synchronized void open() throws SQLException { + db = dbHelper.getWritableDatabase(); + } + + public synchronized void close() { + dbHelper.close(); + } + + public synchronized Level createLevel(String name, String author, int countEasy, int countMedium, int countHard, long addedTs, long installedTs, boolean isDefault, long apiId) { + ContentValues values = new ContentValues(); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_NAME, name); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_AUTHOR, author); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_EASY, countEasy); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_MEDIUM, countMedium); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_HARD, countHard); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_ADDED, addedTs); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_INSTALLED, installedTs); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_IS_DEFAULT, isDefault ? 1 : 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID, apiId); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES, 0); + + long insertId = db.insert(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, values); + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, + LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + insertId, + null, null, null, null); + + cursor.moveToFirst(); + + Level level = cursorToLevel(cursor); + cursor.close(); + return level; + } + + public synchronized void deleteLevel(Level level) { + long id = level.getId(); + db.delete(LevelsSQLiteOpenHelper.TABLE_LEVELS, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + id, null); + db.delete(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID + " = " + id, null); + } + + // This will also reset auto increment counter + public synchronized void deleteAllLevels() { + db.delete(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, null); + db.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" + LevelsSQLiteOpenHelper.TABLE_LEVELS + "'"); + } + + public synchronized void resetAllLevelsSettings() { + ContentValues values = new ContentValues(); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES, 0); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS, 0); + + int result = db.update(LevelsSQLiteOpenHelper.TABLE_LEVELS, values, null, null); + logDebug("LevelsDataSource.resetAllLevelsSettings: result = " + result); + } + + public synchronized void updateLevel(Level level) { + ContentValues values = new ContentValues(); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY, level.getUnlockedEasy()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM, level.getUnlockedMedium()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD, level.getUnlockedHard()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE, level.getSelectedLeague()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL, level.getSelectedLevel()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK, level.getSelectedTrack()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES, level.getUnlockedLeagues()); + values.put(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS, level.getUnlockedLevels()); + + // logDebug("LevelsDataSource.updateLevel selectedLeague: " + level.getSelectedLeague()); + + db.update(LevelsSQLiteOpenHelper.TABLE_LEVELS, values, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + level.getId(), null); + } + + public synchronized HashMap<Long, Long> findInstalledLevels(ArrayList<Long> apiIds) { + HashMap<Long, Long> installed = new HashMap<>(); + + String[] apiIdsArray = new String[apiIds.size()]; + for (int i = 0; i < apiIdsArray.length; i++) { + apiIdsArray[i] = apiIds.get(i).toString(); + } + + Cursor cursor = db.rawQuery("SELECT " + LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID + ", " + LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " FROM " + LevelsSQLiteOpenHelper.TABLE_LEVELS + " WHERE " + LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID + " IN (" + makePlaceholders(apiIdsArray.length) + ")", apiIdsArray); + cursor.moveToFirst(); + + while (!cursor.isAfterLast()) { + long apiId = cursor.getLong(0), + id = cursor.getLong(1); + installed.put(apiId, id); + cursor.moveToNext(); + } + cursor.close(); + + return installed; + } + + public synchronized List<Level> getAllLevels() { + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, null, null, null, null, null); + + List<Level> levels = levelsFromCursor(cursor); + cursor.close(); + + return levels; + } + + public synchronized List<Level> getLevels(int offset, int count) { + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, null, null, null, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " ASC", offset + ", " + count); + + List<Level> levels = levelsFromCursor(cursor); + cursor.close(); + + return levels; + } + + public synchronized Level getLevel(long id) { + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, null, LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID + " = " + id, null, null, null, null); + cursor.moveToFirst(); + + Level level = null; + if (cursor.getCount() > 0) { + level = cursorToLevel(cursor); + } + + cursor.close(); + return level; + } + + public List<Level> levelsFromCursor(Cursor cursor) { + cursor.moveToFirst(); + List<Level> levels = new ArrayList<>(); + while (!cursor.isAfterLast()) { + Level level = cursorToLevel(cursor); + levels.add(level); + cursor.moveToNext(); + } + return levels; + } + + public synchronized boolean isDefaultLevelCreated() { + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, new String[]{LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID}, LevelsSQLiteOpenHelper.LEVELS_COLUMN_IS_DEFAULT + " = 1", null, null, null, null); + boolean created = cursor.getCount() > 0; + cursor.close(); + return created; + } + + public synchronized boolean isApiIdInstalled(long apiId) { + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_LEVELS, new String[]{LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID}, LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID + " = " + apiId, null, null, null, null); + boolean installed = cursor.getCount() > 0; + cursor.close(); + return installed; + } + + public synchronized HighScores getHighScores(long levelId, int level, int track) { + Cursor cursor = db.query(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, null, + LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID + " = " + levelId + " AND " + LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL + " = " + level + " AND " + LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_TRACK + " = " + track, + null, null, null, null); + cursor.moveToFirst(); + + HighScores highScores = new HighScores(); + highScores.setLevelId(levelId); + highScores.setLevel(level); + highScores.setTrack(track); + if (cursor.getCount() > 0) + fillHighScoresFromCursor(cursor, highScores); + else { + long id = createEmptyHighScore(levelId, level, track); + highScores.setId(id); + } + + cursor.close(); + return highScores; + } + + private synchronized long createEmptyHighScore(long levelId, int level, int track) { + ContentValues values = new ContentValues(); + values.put(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID, levelId); + values.put(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL, level); + values.put(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_TRACK, track); + for (int league = 0; league < 4; league++) { + for (int place = 0; place < 3; place++) { + values.put(LevelsSQLiteOpenHelper.getHighscoresTimeColumn(league, place), 0); + values.put(LevelsSQLiteOpenHelper.getHighscoresNameColumn(league, place), 0); + } + } + + long insertId = db.insert(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, null, values); + return insertId; + } + + public synchronized void updateHighScores(HighScores scores) { + ContentValues values = new ContentValues(); + for (int league = 0; league < 4; league++) { + for (int place = 0; place < 3; place++) { + values.put(LevelsSQLiteOpenHelper.getHighscoresTimeColumn(league, place), scores.getTime(league, place)); + values.put(LevelsSQLiteOpenHelper.getHighscoresNameColumn(league, place), scores.getName(league, place)); + } + } + + db.update(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, values, LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_ID + " = " + scores.getId(), null); + } + + public synchronized void clearHighScores(long levelId) { + db.delete(LevelsSQLiteOpenHelper.TABLE_HIGHSCORES, + levelId > 0 ? LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_LEVEL_ID + " = " + levelId : null, + null); + if (levelId == 0) { + db.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" + LevelsSQLiteOpenHelper.TABLE_HIGHSCORES + "'"); + } + } + + private Level cursorToLevel(Cursor cursor) { + Level level = new Level(); + level.setId(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_ID))); + level.setName(cursor.getString(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_NAME))); + level.setAuthor(cursor.getString(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_AUTHOR))); + level.setCount( + cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_EASY)), + cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_MEDIUM)), + cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_COUNT_HARD))); + level.setAddedTs(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_ADDED))); + level.setInstalledTs(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_INSTALLED))); + level.setIsDefault(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_IS_DEFAULT)) == 1); + level.setApiId(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_API_ID))); + level.setUnlocked( + cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_EASY)), + cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_MEDIUM)), + cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_HARD))); + level.setSelectedLevel(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEVEL))); + level.setSelectedTrack(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_TRACK))); + level.setSelectedLeague(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_SELECTED_LEAGUE))); + level.setUnlockedLevels(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEVELS))); + level.setUnlockedLeagues(cursor.getInt(cursor.getColumnIndex(LevelsSQLiteOpenHelper.LEVELS_COLUMN_UNLOCKED_LEAGUES))); + + return level; + } + + private void fillHighScoresFromCursor(Cursor cursor, HighScores highScores) { + highScores.setId(cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.HIGHSCORES_COLUMN_ID))); + + for (int league = 0; league < 4; league++) { + for (int place = 0; place < 3; place++) { + highScores.setTime(league, place, cursor.getLong(cursor.getColumnIndex(LevelsSQLiteOpenHelper.getHighscoresTimeColumn(league, place)))); + highScores.setName(league, place, cursor.getString(cursor.getColumnIndex(LevelsSQLiteOpenHelper.getHighscoresNameColumn(league, place)))); + } + } + } + + private String makePlaceholders(int len) { + if (len < 1) { + throw new RuntimeException("No placeholders"); + } else { + StringBuilder sb = new StringBuilder(len * 2 - 1); + sb.append("?"); + for (int i = 1; i < len; i++) { + sb.append(",?"); + } + return sb.toString(); + } + } + +} diff --git a/src/org/happysanta/gd/Storage/LevelsManager.java b/src/org/happysanta/gd/Storage/LevelsManager.java new file mode 100644 index 0000000..697c9ff --- /dev/null +++ b/src/org/happysanta/gd/Storage/LevelsManager.java @@ -0,0 +1,503 @@ +package org.happysanta.gd.Storage; + +import android.app.AlertDialog; +import android.app.ProgressDialog; +import android.content.DialogInterface; +import android.os.AsyncTask; +import android.os.Environment; +import android.os.StatFs; +import org.happysanta.gd.API.API; +import org.happysanta.gd.API.DownloadFile; +import org.happysanta.gd.API.DownloadHandler; +import org.happysanta.gd.Callback; +import org.happysanta.gd.DoubleCallback; +import org.happysanta.gd.GDActivity; +import org.happysanta.gd.Global; +import org.happysanta.gd.Levels.LevelHeader; +import org.happysanta.gd.Levels.Reader; +import org.happysanta.gd.Menu.Menu; +import org.happysanta.gd.Menu.MenuScreen; +import org.happysanta.gd.R; +import org.happysanta.gd.Settings; +import org.acra.ACRA; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; + +import static org.happysanta.gd.Helpers.getGDActivity; +import static org.happysanta.gd.Helpers.getGameMenu; +import static org.happysanta.gd.Helpers.getString; +import static org.happysanta.gd.Helpers.getTimestamp; +import static org.happysanta.gd.Helpers.isOnline; +import static org.happysanta.gd.Helpers.logDebug; +import static org.happysanta.gd.Helpers.showAlert; + +public class LevelsManager { + + private LevelsDataSource dataSource; + private boolean dbOK = false; + private Level currentLevel; + + public LevelsManager() { + GDActivity gd = getGDActivity(); + dataSource = new LevelsDataSource(gd); + + try { + dataSource.open(); + + if (!dataSource.isDefaultLevelCreated()) { + Level level = dataSource.createLevel("GDTR original", "Codebrew Software", 10, 10, 10, 0, 0, true, 1); + logDebug("LevelsManager: Default level created!"); + logDebug(level); + } + } catch (SQLException e) { + e.printStackTrace(); + logDebug("LevelsManager: db feels bad :("); + // return; + } + + logDebug("LevelsManager: db feels OK :)"); + + // Shared prefs + // SharedPreferences settings = getSharedPreferences(); + // long levelId = settings.getLong(PREFS_LEVEL_ID, 0); + long levelId = Settings.getLevelId(); + if (levelId < 1 || !mrgIsAvailable(levelId)) { + logDebug("LevelsManager: levelId = " + levelId + ", < 1 or mrg is not available; now: reset id"); + /*SharedPreferences.Editor editor = settings.edit(); + editor.putLong(PREFS_LEVEL_ID, 1); + editor.commit();*/ + resetId(); + } + + reload(); + dbOK = true; + } + + public void resetId() { + Settings.setLevelId(1); + } + + public void reload() { + long id = Settings.getLevelId(); + currentLevel = dataSource.getLevel(id); + + if (currentLevel == null) { + logDebug("LevelsManager: failed to load currentLevel; currentId = " + id); + } else { + logDebug("LevelsManager: level = " + currentLevel); + } + + if (Global.ACRA_ENABLED) { + ACRA.getErrorReporter().putCustomData("level_api_id:", String.valueOf(currentLevel.getApiId())); + } + } + + public void closeDataSource() { + dataSource.close(); + } + + public long getCurrentId() { + return currentLevel.getId(); + } + + public void setCurrentId(long id) { + // currentId = id; + Settings.setLevelId(id); + /*SharedPreferences settings = getSharedPreferences(); + SharedPreferences.Editor edit = settings.edit(); + edit.putLong(PREFS_LEVEL_ID, id); + edit.commit();*/ + } + + public Level getCurrentLevel() { + return currentLevel; + } + + public File getCurrentLevelsFile() { + if (currentLevel.getId() > 1) + return getMrgFileById(currentLevel.getId()); + + return null; + } + + private boolean mrgIsAvailable(long id) { + if (id == 1) // This is default built-in levels.mrg + return true; + + File file = getMrgFileById(id); + return isExternalStorageReadable() && file.exists(); + } + + public boolean isDbOK() { + return dbOK; + } + + public long install(File file, String name, String author, long apiId) throws Exception { + if (!isSpaceAvailable(file.length())) { + throw new Exception(getString(R.string.e_no_space_left)); + } + + InputStream inputStream = new FileInputStream(file); + LevelHeader header = Reader.readHeader(inputStream); + try { + inputStream.close(); + } catch (IOException e) { + } + + if (!header.isCountsOk()) { + throw new IOException(file.getName() + " is not valid"); + } + + Level level = dataSource.createLevel(name, author, header.getCount(0), header.getCount(1), header.getCount(2), 0, getTimestamp(), false, apiId); + long id = level.getId(); + if (id < 1) { + throw new Exception(getString(R.string.e_cannot_save_level)); + } + + File newFile = getMrgFileById(id); + copy(file, newFile); + + return id; + } + + public void installAsync(File file, String name, String author, long apiId, final DoubleCallback callback) { + GDActivity gd = getGDActivity(); + final ProgressDialog progressDialog = ProgressDialog.show(gd, getString(R.string.install), getString(R.string.installing), true); + + new AsyncInstallLevel() { + @Override + protected void onPostExecute(Object result) { + progressDialog.dismiss(); + + if (result instanceof Throwable) { + Throwable throwable = (Throwable) result; + throwable.printStackTrace(); + showAlert(getString(R.string.error), throwable.getMessage(), null); + if (callback != null) + callback.onFail(); + return; + } + + if (callback != null) + callback.onDone((long) result); + } + }.execute(file, name, author, apiId); + } + + public void load(Level level) throws RuntimeException { + /*File file = getMrgFileById(level.getId()); + if (!mrgIsAvailable(level.getId())) { + throw new RuntimeException("Unable to load levels \"" +level.getName() + "\""); + }*/ + + // Loader loader = getLevelLoader(); + // Menu menu = getGameMenu(); + + // loader.setLevelsFile(file); + // menu.reloadLevels(); + + setCurrentId(level.getId()); + getGDActivity().restartApp(); + } + + public boolean isApiIdInstalled(long apiId) { + return dataSource.isApiIdInstalled(apiId); + } + + public Level[] getInstalledLevels(int offset, int count) { + return dataSource.getLevels(offset, count).toArray(new Level[0]); + } + + public Level getLeveL(long id) { + return dataSource.getLevel(id); + } + + public Level[] getAllInstalledLevels() { + return dataSource.getAllLevels().toArray(new Level[0]); + } + + public synchronized HashMap<String, Double> getLevelsStat() { + Level[] levels = getAllInstalledLevels(); + HashMap<String, Double> stat = new HashMap<>(); + if (levels.length > 0) { + for (Level level : levels) { + int[] completed = level.getUnlockedAll(); + int completedCount = 0; + for (int i = 0; i < completed.length; i++) { + if (completed[i] < 0) completed[i] = 0; + completedCount += completed[i]; + } + + double totalCount = level.getCountEasy() + level.getCountMedium() + level.getCountHard(); + double per = completedCount / totalCount * 100; + + stat.put(String.valueOf(level.getApiId()), per); + } + } + return stat; + } + + public void delete(Level level) { + dataSource.deleteLevel(level); + File file = getMrgFileById(level.getId()); + try { + if (file.exists()) { + file.delete(); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void deleteAsync(Level level, final Runnable callback) { + GDActivity gd = getGDActivity(); + final ProgressDialog progressDialog = ProgressDialog.show(gd, getString(R.string.delete), getString(R.string.deleting), true); + + new AsyncDeleteLevel() { + @Override + protected void onPostExecute(Void v) { + progressDialog.dismiss(); + if (callback != null) + callback.run(); + } + }.execute(level); + } + + public void updateLevelSettings() { + dataSource.updateLevel(currentLevel); + } + + public void downloadLevel(final Level level, final Callback successCallback) { + final GDActivity gd = getGDActivity(); + File outputDir = gd.getCacheDir(); + + try { + boolean readable = isExternalStorageReadable(); + if (!readable) { + throw new Exception(getString(R.string.e_external_storage_is_not_readable)); + } + + if (!isOnline()) { + throw new Exception(getString(R.string.e_no_network_connection)); + } + + if (!isSpaceAvailable(level.getSize())) { + throw new Exception(getString(R.string.e_no_space_left)); + } + + final File outputFile = File.createTempFile("levels" + level.getApiId(), "mrg", outputDir); + FileOutputStream out = new FileOutputStream(outputFile); + + // logDebug("downloadLevel: 4"); + // final API api = new API(); + final ProgressDialog progress; + final DownloadFile downloadFile = new DownloadFile(API.getMrgURL(level.getApiId()), out); + + progress = new ProgressDialog(gd); + progress.setMessage(getString(R.string.downloading)); + progress.setIndeterminate(true); + progress.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); + progress.setCancelable(true); + + final DownloadHandler handler = new DownloadHandler() { + @Override + public void onFinish(Throwable error) { + progress.dismiss(); + + if (error != null) { + // error.printStackTrace(); + error.printStackTrace(); + showAlert(getString(R.string.error), error.getMessage(), null); + + outputFile.delete(); + return; + } + + // Install + installAsync(outputFile, level.getName(), level.getAuthor(), level.getApiId(), new DoubleCallback() { + @Override + public void onDone(Object... objects) { + long id = (long) objects[0]; + outputFile.delete(); + + if (successCallback != null) + successCallback.onDone(id); + } + + @Override + public void onFail() { + outputFile.delete(); + } + }); + } + + @Override + public void onStart() { + progress.show(); + } + + @Override + public void onProgress(int pr) { + progress.setIndeterminate(false); + progress.setMax(100); + progress.setProgress(pr); + } + }; + progress.setOnCancelListener(new DialogInterface.OnCancelListener() { + @Override + public void onCancel(DialogInterface dialog) { + downloadFile.cancel(); + handler.onFinish(new InterruptedException(getString(R.string.e_downloading_was_interrupted))); + } + }); + + downloadFile.setDownloadHandler(handler); + downloadFile.start(); + } catch (Exception e) { + showAlert(getString(R.string.error), e.getMessage(), null); + } + } + + public void showSuccessfullyInstalledDialog() { + GDActivity gd = getGDActivity(); + AlertDialog success = new AlertDialog.Builder(gd) + .setTitle(getString(R.string.installed)) + .setMessage(getString(R.string.successfully_installed)) + .setPositiveButton(getString(R.string.ok), null) + .setNegativeButton(getString(R.string.open_installed), new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + Menu menu = getGameMenu(); + MenuScreen currentMenu = getGameMenu().getCurrentMenu(), + newMenu = menu.managerInstalledScreen; + + if (currentMenu == menu.managerDownloadScreen || currentMenu.getNavTarget() == menu.managerDownloadScreen) { + menu.managerDownloadScreen.onHide(menu.managerScreen); + } + + menu.setCurrentMenu(newMenu, false); + } + }) + .create(); + success.show(); + } + + public HashMap<Long, Long> findInstalledLevels(ArrayList<Long> apiIds) { + return dataSource.findInstalledLevels(apiIds); + } + + public HighScores getHighScores(int level, int track) { + HighScores scores = dataSource.getHighScores(currentLevel.getId(), level, track); + // logDebug("LevelsManager.getHighScores: " + scores); + return scores; + } + + public void saveHighScores(HighScores scores) { + dataSource.updateHighScores(scores); + } + + public void clearHighScores() { + dataSource.clearHighScores(currentLevel.getId()); + } + + public void clearAllHighScores() { + dataSource.clearHighScores(0); + } + + public void resetAllLevelsSettings() { + dataSource.resetAllLevelsSettings(); + + logDebug("All levels now: " + dataSource.getAllLevels()); + logDebug("Level#1: " + dataSource.getLevel(1)); + } + + public static boolean isExternalStorageWritable() { + String state = Environment.getExternalStorageState(); + if (Environment.MEDIA_MOUNTED.equals(state)) { + return true; + } + return false; + } + + public static boolean isExternalStorageReadable() { + String state = Environment.getExternalStorageState(); + if (Environment.MEDIA_MOUNTED.equals(state) || + Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) { + return true; + } + return false; + } + + public static File getLevelsDirectory() { + File file = new File(Environment.getExternalStorageDirectory(), "GDLevels"); + if (!file.mkdirs()) { + logDebug("LevelsManager.getLevelsDirectory: directory not created"); + } + return file; + } + + public static String getMrgFileNameById(long id) { + return getLevelsDirectory().getAbsolutePath() + "/" + id + ".mrg"; + } + + public static File getMrgFileById(long id) { + if (id == 1) return null; + return new File(getMrgFileNameById(id)); + } + + public static void copy(File src, File dst) throws IOException { + InputStream in = new FileInputStream(src); + OutputStream out = new FileOutputStream(dst); + + byte[] buf = new byte[1024]; + int len; + while ((len = in.read(buf)) > 0) { + out.write(buf, 0, len); + } + + in.close(); + out.close(); + } + + public static boolean isSpaceAvailable(long bytes) { + StatFs stat = new StatFs(getLevelsDirectory().getPath()); + long bytesAvailable = (long) stat.getBlockSize() * (long) stat.getAvailableBlocks(); + return bytesAvailable >= bytes; + } + + private class AsyncDeleteLevel extends AsyncTask<Level, Void, Void> { + @Override + protected Void doInBackground(Level... levels) { + delete(levels[0]); + return null; + } + } + + private class AsyncInstallLevel extends AsyncTask<Object, Void, Object> { + @Override + protected Object doInBackground(Object... objects) { + File file = (File) objects[0]; + String name = (String) objects[1]; + String author = (String) objects[2]; + long apiId = (long) objects[3]; + + long id = 0; + try { + id = install(file, name, author, apiId); + } catch (Throwable e) { + return e; + } + + return id; + } + } + +} diff --git a/src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java b/src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java new file mode 100644 index 0000000..024a17f --- /dev/null +++ b/src/org/happysanta/gd/Storage/LevelsSQLiteOpenHelper.java @@ -0,0 +1,141 @@ +package org.happysanta.gd.Storage; + +import android.content.Context; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; + +public class LevelsSQLiteOpenHelper extends SQLiteOpenHelper { + + private static final int DATABASE_VERSION = 1; + private static final String DATABASE_NAME = "levels.db"; + + public static final String TABLE_LEVELS = "levels"; + public static final String TABLE_HIGHSCORES = "highscores"; + + public static final String LEVELS_COLUMN_ID = "_id"; + public static final String LEVELS_COLUMN_NAME = "name"; + public static final String LEVELS_COLUMN_AUTHOR = "author"; + public static final String LEVELS_COLUMN_COUNT_EASY = "count_easy"; + public static final String LEVELS_COLUMN_COUNT_MEDIUM = "count_medium"; + public static final String LEVELS_COLUMN_COUNT_HARD = "count_hard"; + public static final String LEVELS_COLUMN_ADDED = "added_ts"; + public static final String LEVELS_COLUMN_INSTALLED = "installed_ts"; + public static final String LEVELS_COLUMN_IS_DEFAULT = "is_default"; + public static final String LEVELS_COLUMN_API_ID = "api_id"; + public static final String LEVELS_COLUMN_UNLOCKED_EASY = "unlocked_easy"; + public static final String LEVELS_COLUMN_UNLOCKED_MEDIUM = "unlocked_medium"; + public static final String LEVELS_COLUMN_UNLOCKED_HARD = "unlocked_hard"; + public static final String LEVELS_COLUMN_SELECTED_LEVEL = "selected_level"; + public static final String LEVELS_COLUMN_SELECTED_TRACK = "selected_track"; + public static final String LEVELS_COLUMN_SELECTED_LEAGUE = "selected_league"; + public static final String LEVELS_COLUMN_UNLOCKED_LEVELS = "unlocked_levels"; + public static final String LEVELS_COLUMN_UNLOCKED_LEAGUES = "unlocked_leagues"; + + public static final String HIGHSCORES_COLUMN_ID = "_id"; + public static final String HIGHSCORES_COLUMN_LEVEL_ID = "level_id"; + public static final String HIGHSCORES_COLUMN_LEVEL = "level"; + public static final String HIGHSCORES_COLUMN_TRACK = "track"; + + private static final String TABLE_LEVELS_CREATE = "CREATE TABLE " + + TABLE_LEVELS + "(" + + LEVELS_COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + + LEVELS_COLUMN_NAME + " TEXT NOT NULL, " + + LEVELS_COLUMN_AUTHOR + " TEXT NOT NULL, " + + LEVELS_COLUMN_COUNT_EASY + " INTEGER NOT NULL, " + + LEVELS_COLUMN_COUNT_MEDIUM + " INTEGER NOT NULL, " + + LEVELS_COLUMN_COUNT_HARD + " INTEGER NOT NULL, " + + LEVELS_COLUMN_ADDED + " INTEGER NOT NULL, " + + LEVELS_COLUMN_INSTALLED + " INTEGER NOT NULL, " + + LEVELS_COLUMN_IS_DEFAULT + " INTEGER NOT NULL, " + + LEVELS_COLUMN_API_ID + " INTEGER NOT NULL, " + + LEVELS_COLUMN_UNLOCKED_EASY + " INTEGER NOT NULL, " + + LEVELS_COLUMN_UNLOCKED_MEDIUM + " INTEGER NOT NULL, " + + LEVELS_COLUMN_UNLOCKED_HARD + " INTEGER NOT NULL, " + + LEVELS_COLUMN_SELECTED_LEVEL + " INTEGER NOT NULL, " + + LEVELS_COLUMN_SELECTED_TRACK + " INTEGER NOT NULL, " + + LEVELS_COLUMN_SELECTED_LEAGUE + " INTEGER NOT NULL, " + + LEVELS_COLUMN_UNLOCKED_LEVELS + " INTEGER NOT NULL, " + + LEVELS_COLUMN_UNLOCKED_LEAGUES + " INTEGER NOT NULL" + + ");"; + + private static final String TABLE_HIGHSCORES_CREATE = " CREATE TABLE " + + TABLE_HIGHSCORES + "(" + + HIGHSCORES_COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " + + HIGHSCORES_COLUMN_LEVEL_ID + " INTEGER NOT NULL, " + + HIGHSCORES_COLUMN_LEVEL + " INTEGER NOT NULL, " + + HIGHSCORES_COLUMN_TRACK + " INTEGER NOT NULL, " + + // 100cc + + getHighscoresTimeColumn(0, 0) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(0, 0) + " TEXT, " + + getHighscoresTimeColumn(0, 1) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(0, 1) + " TEXT, " + + getHighscoresTimeColumn(0, 2) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(0, 2) + " TEXT, " + + // 175cc + + getHighscoresTimeColumn(1, 0) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(1, 0) + " TEXT, " + + getHighscoresTimeColumn(1, 1) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(1, 1) + " TEXT, " + + getHighscoresTimeColumn(1, 2) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(1, 2) + " TEXT, " + + // 220cc + + getHighscoresTimeColumn(2, 0) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(2, 0) + " TEXT, " + + getHighscoresTimeColumn(2, 1) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(2, 1) + " TEXT, " + + getHighscoresTimeColumn(2, 2) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(2, 2) + " TEXT, " + + // 325cc + + getHighscoresTimeColumn(3, 0) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(3, 0) + " TEXT, " + + getHighscoresTimeColumn(3, 1) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(3, 1) + " TEXT, " + + getHighscoresTimeColumn(3, 2) + " INTEGER NOT NULL, " + + getHighscoresNameColumn(3, 2) + " TEXT" + + + ")"; + + LevelsSQLiteOpenHelper(Context context) { + super(context, DATABASE_NAME, null, DATABASE_VERSION); + } + + @Override + public void onCreate(SQLiteDatabase db) { + db.execSQL(TABLE_LEVELS_CREATE); + createLevelsIndexes(db); + + db.execSQL(TABLE_HIGHSCORES_CREATE); + createHighscoresIndexes(db); + } + + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + + } + + private void createLevelsIndexes(SQLiteDatabase db) { + db.execSQL("CREATE INDEX " + LEVELS_COLUMN_API_ID + "_index ON " + TABLE_LEVELS + "(" + LEVELS_COLUMN_API_ID + ")"); + db.execSQL("CREATE INDEX " + LEVELS_COLUMN_IS_DEFAULT + "_index ON " + TABLE_LEVELS + "(" + LEVELS_COLUMN_IS_DEFAULT + ")"); + } + + private void createHighscoresIndexes(SQLiteDatabase db) { + db.execSQL("CREATE INDEX level_id_level_track_index ON " + TABLE_HIGHSCORES + "(" + + HIGHSCORES_COLUMN_LEVEL_ID + ", " + + HIGHSCORES_COLUMN_LEVEL + ", " + + HIGHSCORES_COLUMN_TRACK + + ")"); + } + + public static String getHighscoresTimeColumn(int league, int place) { + return "l" + league + "_p" + place + "_time"; + } + + public static String getHighscoresNameColumn(int league, int place) { + return "l" + league + "_p" + place + "_name"; + } + +} |