From 349c67f0937c9970a0a7c874b20584670aed22a3 Mon Sep 17 00:00:00 2001 From: Alexander Doerflinger Date: Tue, 8 Aug 2017 12:56:44 +0200 Subject: [PATCH] Added basic SQLite functionality NOT FUNCTIONAL YET Unfortunately the Databse connection is not functional yet as we seem to have some general problems with the db handling. --- .idea/misc.xml | 2 +- .idea/vcs.xml | 6 + app/build.gradle | 4 +- .../main/assets/mario_kart_circuit_selector | Bin 0 -> 39936 bytes .../mariokartcircuitselector/Constants.java | 13 +- .../DatabaseHandler.java | 329 ++++++++++++++++++ .../GameSelection.java | 25 ++ .../res/layout/activity_game_selection.xml | 26 +- 8 files changed, 394 insertions(+), 11 deletions(-) create mode 100644 .idea/vcs.xml create mode 100644 app/src/main/assets/mario_kart_circuit_selector create mode 100644 app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/DatabaseHandler.java diff --git a/.idea/misc.xml b/.idea/misc.xml index 738edfe..406ac20 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -56,7 +56,7 @@ - + diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/build.gradle b/app/build.gradle index f58a768..e0915b0 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -7,8 +7,8 @@ android { applicationId "com.de.aldo_apps.aldo.mariokartcircuitselector" minSdkVersion 16 targetSdkVersion 25 - versionCode 3 - versionName "0.3" + versionCode 4 + versionName "0.4" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } buildTypes { diff --git a/app/src/main/assets/mario_kart_circuit_selector b/app/src/main/assets/mario_kart_circuit_selector new file mode 100644 index 0000000000000000000000000000000000000000..a978ba1f8be22afdee81de5263bb79edb639abac GIT binary patch literal 39936 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 X$ZT&L#R!&dy@sLsa9daro#Foh?@Kd> literal 0 HcmV?d00001 diff --git a/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/Constants.java b/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/Constants.java index 9681f6a..f26048c 100644 --- a/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/Constants.java +++ b/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/Constants.java @@ -6,6 +6,11 @@ package com.de.aldo_apps.aldo.mariokartcircuitselector; public class Constants { + /** + * The Version Code of the Database. + */ + public static final Integer DATABASE_VERSION = 1; + /** * As SQLite does not have a native boolean value, we use integers to represent true and false. * This is the value for a true statement. @@ -18,10 +23,16 @@ public class Constants { */ public final static Integer FALSE = 0; + /** + * The Path to the Database + */ + public static final String DATABASE_PATH + = "/data/data/com.de.aldo_apps.aldo.mariokartcircuitselector/databases/"; + /** * The Name of the complete database. */ - public static final String DATABASE_NAME = "mario_kart_circuit_selector.db"; + public static final String DATABASE_NAME = "mario_kart_circuit_selector"; /** * The name of the table containing all information according accessories. diff --git a/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/DatabaseHandler.java b/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/DatabaseHandler.java new file mode 100644 index 0000000..0c5d2ad --- /dev/null +++ b/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/DatabaseHandler.java @@ -0,0 +1,329 @@ +package com.de.aldo_apps.aldo.mariokartcircuitselector; + +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteException; +import android.database.sqlite.SQLiteOpenHelper; +import android.util.Log; + +import com.de.aldo_apps.aldo.mariokartcircuitselector.database_models.Accessory; +import com.de.aldo_apps.aldo.mariokartcircuitselector.database_models.Character; +import com.de.aldo_apps.aldo.mariokartcircuitselector.database_models.Kart; +import com.de.aldo_apps.aldo.mariokartcircuitselector.database_models.Track; +import com.de.aldo_apps.aldo.mariokartcircuitselector.database_models.Wheels; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +import static com.de.aldo_apps.aldo.mariokartcircuitselector.Constants.KEY_AVAILABLE; +import static com.de.aldo_apps.aldo.mariokartcircuitselector.Constants.KEY_GAME; +import static com.de.aldo_apps.aldo.mariokartcircuitselector.Constants.KEY_ID; +import static com.de.aldo_apps.aldo.mariokartcircuitselector.Constants.KEY_NAME; +import static com.de.aldo_apps.aldo.mariokartcircuitselector.Constants.TABLE_TRACK; +import static com.de.aldo_apps.aldo.mariokartcircuitselector.Constants.TABLE_WHEELS; + +/** + * The Database Handler class which opens/closes connection and handles all CRUD Operations + * on the Database. + * + * @author aldo7224 + * @version 0.1 + * @since 08.08.2017 + */ +public class DatabaseHandler extends SQLiteOpenHelper { + + /** + * Tag for debugging output. + */ + private static final String TAG = "DatabaseHandler"; + + private final Context mContext; + + private SQLiteDatabase mDatabase; + + public DatabaseHandler(final Context context) { + super(context, Constants.DATABASE_NAME, null, Constants.DATABASE_VERSION); + mContext = context; + } + + @Override + public void onCreate(final SQLiteDatabase sqLiteDatabase) { + + mDatabase = sqLiteDatabase; + + Log.d(TAG, "onCreate: Is new database opened? [" + mDatabase.isOpen() + "]"); + + if (!checkDataBase()) { + // Maybe the DB already exists but we need to upgrade. + Log.d(TAG, "onCreate: Dropping all Tables (in case they already exist)."); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + Constants.TABLE_GAME); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + Constants.TABLE_ACCESSORY); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + Constants.TABLE_CHARACTER); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + Constants.TABLE_KART); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + Constants.TABLE_RULESET); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + Constants.TABLE_TRACK); + sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + TABLE_WHEELS); + + try { + Log.d(TAG, "onCreate: Copying the Database from Assets Folder to database path."); + copyDataBase(); + } catch (IOException exception) { + Log.d(TAG, "onCreate: Could not Copy Database. Exception [" + + exception.getMessage() + "]"); + } + + } + } + + @Override + public void onUpgrade(final SQLiteDatabase sqLiteDatabase, + final int oldVersion, + final int newVersion) { + // Dropping Tables and Creating them again. All handled by onCreate. + Log.d(TAG, "onUpgrade: Databse was upgraded. Performing upgrade."); + onCreate(sqLiteDatabase); + } + + /** + * Check if the database already exist to avoid re-copying the file each time you open the + * application. Also check if the Version Code of the Database changed, so maybe the data need + * to be copied again. + * @return true if it exists, false if it doesn't + */ + private boolean checkDataBase(){ + + Log.d(TAG, "checkDataBase: Checking Database availability."); + SQLiteDatabase checkDB = null; + + if (mDatabase != null && mDatabase.isOpen()) { + Log.d(TAG, "checkDataBase: Closing real database to prevent exception when " + + "opening test DB."); + checkDB = mDatabase; + } else { + try { + final String myPath = Constants.DATABASE_PATH + Constants.DATABASE_NAME; + Log.d(TAG, "checkDataBase: Opening Test-Database."); + checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY); + + } catch (final SQLiteException exception) { + //database does't exist yet. + Log.d(TAG, "checkDataBase: Opening of database throws Exception [" + + exception.getMessage() + "]. Database seems to not exist yet."); + } + } + // If Database exists we need to close the Database. + if (checkDB != null) { + Log.d(TAG, "checkDataBase: Database seems to exist already."); + // If the Version Code is Lower than the predefined value, we need to upgrade the DB. + if (checkDB.getVersion() < Constants.DATABASE_VERSION) { + Log.d(TAG, "checkDataBase: Database Version code from new and old one differ."); + checkDB.close(); + return false; + } + Log.d(TAG, "checkDataBase: Closing Database."); + checkDB.close(); + } + return checkDB != null; + } + + /** + * Copies your database from your local assets-folder to the just created empty database in the + * system folder, from where it can be accessed and handled. + * This is done by transfering bytestream. + * */ + private void copyDataBase() throws IOException { + + //Open your local db as the input stream + Log.d(TAG, "copyDataBase: Opening InputStream for DB in assets folder."); + final InputStream inputStream = mContext.getAssets().open(Constants.DATABASE_NAME); + + // Path to the just created empty db + final String outFileName = Constants.DATABASE_PATH + Constants.DATABASE_NAME; + + //Open the empty db as the output stream + Log.d(TAG, "copyDataBase: Opening Outputstream for DB on hard disk [" + outFileName + "]"); + final OutputStream outputStream = new FileOutputStream(outFileName); + + //transfer bytes from the inputfile to the outputfile + final byte[] buffer = new byte[1024]; + int length; + while ((length = inputStream.read(buffer)) > 0) { + Log.d(TAG, "copyDataBase: Writing single Chunk of DB from assets to hard disk."); + outputStream.write(buffer, 0, length); + } + + //Close the streams + Log.d(TAG, "copyDataBase: Flushing Stream."); + outputStream.flush(); + Log.d(TAG, "copyDataBase: Closing Output Stream."); + outputStream.close(); + Log.d(TAG, "copyDataBase: Closing Input Stream."); + inputStream.close(); + + } + + /** + * Helper method to update the availability status of a single track. + * + * @param track The track which should be marked as available/unavailable. + * @param isAvailable The status of availability to be set. + * + * @return The result code of the update function. + */ + public int changeTrackAvailability(final Track track, final boolean isAvailable) { + final SQLiteDatabase db = this.getWritableDatabase(); + + final ContentValues values = new ContentValues(); + values.put(Constants.KEY_GAME, track.getGame()); + values.put(KEY_NAME, track.getName()); + values.put(Constants.KEY_PACKAGE, track.getPackage()); + values.put(Constants.KEY_NUMBER, track.getmNumber()); + if (isAvailable) { + values.put(KEY_AVAILABLE, Constants.TRUE); + } else { + values.put(KEY_AVAILABLE, Constants.FALSE); + } + + return db.update(Constants.TABLE_TRACK, values, KEY_ID + " = ?", + new String[] {String.valueOf(track.getId()) }); + } + + /** + * Helper method to update the availability status of a single character. + * + * @param character The character which should be marked as available/unavailable. + * @param isAvailable The status of availability to be set. + * + * @return The result code of the update function. + */ + public int changeCharacterAvailability(final Character character, final boolean isAvailable) { + final SQLiteDatabase db = this.getWritableDatabase(); + + final ContentValues values = new ContentValues(); + values.put(Constants.KEY_GAME, character.getGame()); + values.put(KEY_NAME, character.getName()); + values.put(Constants.KEY_WEIGHT, character.getWeight()); + if (isAvailable) { + values.put(KEY_AVAILABLE, Constants.TRUE); + } else { + values.put(KEY_AVAILABLE, Constants.FALSE); + } + + return db.update(Constants.TABLE_CHARACTER, values, KEY_ID + " = ?", + new String[] {String.valueOf(character.getId()) }); + } + + /** + * Helper method to update the availability status of a single kart. + * + * @param kart The kart which should be marked as available/unavailable. + * @param isAvailable The status of availability to be set. + * + * @return The result code of the update function. + */ + public int changeKartAvailability(final Kart kart, final boolean isAvailable) { + final SQLiteDatabase db = this.getWritableDatabase(); + + final ContentValues values = new ContentValues(); + values.put(Constants.KEY_GAME, kart.getGame()); + values.put(KEY_NAME, kart.getName()); + values.put(Constants.KEY_WEIGHT, kart.getWeight()); + values.put(Constants.KEY_WHEELS, kart.getWheels()); + values.put(Constants.KEY_ACCESSORY, kart.getAccessory()); + values.put(Constants.KEY_DEDICATED_DRIVER, kart.getDedicatedDriver()); + values.put(Constants.KEY_FREE_FOR_ALL, kart.getFreeForAll()); + if (isAvailable) { + values.put(KEY_AVAILABLE, Constants.TRUE); + } else { + values.put(KEY_AVAILABLE, Constants.FALSE); + } + + return db.update(Constants.TABLE_KART, values, KEY_ID + " = ?", + new String[] {String.valueOf(kart.getId()) }); + } + + /** + * Helper method to update the availability status of a single accessory. + * + * @param accessory The accessory which should be marked as available/unavailable. + * @param isAvailable The status of availability to be set. + * + * @return The result code of the update function. + */ + public int changeAccessoryAvailability(final Accessory accessory, final boolean isAvailable) { + final SQLiteDatabase db = this.getWritableDatabase(); + + final ContentValues values = new ContentValues(); + values.put(Constants.KEY_GAME, accessory.getGame()); + values.put(KEY_NAME, accessory.getName()); + if (isAvailable) { + values.put(KEY_AVAILABLE, Constants.TRUE); + } else { + values.put(KEY_AVAILABLE, Constants.FALSE); + } + + return db.update(Constants.TABLE_ACCESSORY, values, KEY_ID + " = ?", + new String[] {String.valueOf(accessory.getId()) }); + } + + /** + * Helper method to update the availability status of a single wheels. + * + * @param wheels The wheels which should be marked as available/unavailable. + * @param isAvailable The status of availability to be set. + * + * @return The result code of the update function. + */ + public int changeWheelsAvailability(final Wheels wheels, final boolean isAvailable) { + final SQLiteDatabase db = this.getWritableDatabase(); + + final ContentValues values = new ContentValues(); + values.put(Constants.KEY_GAME, wheels.getGame()); + values.put(KEY_NAME, wheels.getGame()); + if (isAvailable) { + values.put(KEY_AVAILABLE, Constants.TRUE); + } else { + values.put(KEY_AVAILABLE, Constants.FALSE); + } + + return db.update(TABLE_WHEELS, values, KEY_ID + " = ?", + new String[] {String.valueOf(wheels.getId()) }); + } + + public Track testDBConnection(final int id) { + Log.d(TAG, "testDBConnection: Opening Readable Database."); + final SQLiteDatabase dbToUse; + if (mDatabase != null && mDatabase.isOpen()) { + dbToUse = mDatabase; + } else { + dbToUse = this.getReadableDatabase(); + } + + Log.d(TAG, "testDBConnection: Query a single track for id = [" + id + "]"); + Cursor cursor = dbToUse.query(TABLE_TRACK, new String[] { KEY_ID, + KEY_NAME, KEY_AVAILABLE }, KEY_ID + "=?", + new String[] { String.valueOf(id) }, null, null, null, null); + if (cursor != null) { + Log.d(TAG, "testDBConnection: Moving cursor to first."); + cursor.moveToFirst(); + } else { + Log.d(TAG, "testDBConnection: cursor is null"); + return null; + } + + Track track = new Track(); + track.setName(cursor.getString(cursor.getColumnIndex(KEY_NAME))); + track.setGame(cursor.getString(cursor.getColumnIndex(KEY_GAME))); + track.setId(Integer.parseInt(cursor.getString(cursor.getColumnIndex(KEY_ID)))); + track.setAvailable(Integer.parseInt(cursor.getString(cursor.getColumnIndex(KEY_AVAILABLE)))); + + dbToUse.close(); + + // return contact + return track; + } +} diff --git a/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/GameSelection.java b/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/GameSelection.java index 2737ef5..d38be24 100644 --- a/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/GameSelection.java +++ b/app/src/main/java/com/de/aldo_apps/aldo/mariokartcircuitselector/GameSelection.java @@ -2,6 +2,12 @@ package com.de.aldo_apps.aldo.mariokartcircuitselector; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; +import android.view.View; +import android.widget.Button; +import android.widget.EditText; +import android.widget.TextView; + +import com.de.aldo_apps.aldo.mariokartcircuitselector.database_models.Track; public class GameSelection extends AppCompatActivity { @@ -9,5 +15,24 @@ public class GameSelection extends AppCompatActivity { protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_game_selection); + + final DatabaseHandler handler = new DatabaseHandler(this); + + final EditText editText = (EditText) findViewById(R.id.id_input); + + final Button button = (Button) findViewById(R.id.ok_button); + + final TextView result = (TextView) findViewById(R.id.result_field); + + button.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + final int id = Integer.parseInt(editText.getText().toString()); + final Track track = handler.testDBConnection(id); + final String resultStr = track.getGame() + " - " + track.getName() + " - " + track.getAvailable() + " - "; + result.setText(resultStr); + } + }); + } } diff --git a/app/src/main/res/layout/activity_game_selection.xml b/app/src/main/res/layout/activity_game_selection.xml index d700bea..547d5ec 100644 --- a/app/src/main/res/layout/activity_game_selection.xml +++ b/app/src/main/res/layout/activity_game_selection.xml @@ -1,18 +1,30 @@ - + + +