added sync data model changes;

use sqlite transactions to insert and update all sort of records;

src/de/tudarmstadt/informatik/hostage/Handler.java

@@ -208,7 +208,9 @@ public class Handler implements Runnable {
 	 */
 	protected AttackRecord createAttackRecord() {
 		AttackRecord record = new AttackRecord();
-		record.setAttack_id(attack_id);			
+		record.setAttack_id(attack_id);
+        record.setSync_id(attack_id);
+        //TODO SET CURRENT DEVICE UUID
 		record.setProtocol(protocol.toString());
 		record.setExternalIP(externalIP);
 		record.setLocalIP(client.getLocalAddress().getHostAddress());

src/de/tudarmstadt/informatik/hostage/Listener.java

@@ -270,7 +270,9 @@ public class Listener implements Runnable {
 		editor.commit();
 		
 		AttackRecord attackRecord = new AttackRecord();
-		attackRecord.setAttack_id(attack_id);			
+		attackRecord.setAttack_id(attack_id);
+        attackRecord.setSync_id(attack_id);
+        //TODO SET DEVICE UUID
 		attackRecord.setProtocol("PORTSCAN");
 		attackRecord.setExternalIP(connInfo.getString(service.getString(R.string.connection_info_external_ip), null));
 		attackRecord.setLocalIP(client.getLocalAddress().getHostAddress());

src/de/tudarmstadt/informatik/hostage/logging/AttackRecord.java

@@ -13,7 +13,9 @@ public class AttackRecord implements Parcelable, Serializable {
 	private static final long serialVersionUID = 6111024905373724227L;
 
 	private long attack_id;
+    private long sync_id;
 	private String bssid;
+    private String device;
 	private String protocol;
 	private String localIP;
 	private int localPort;
@@ -48,6 +50,8 @@ public class AttackRecord implements Parcelable, Serializable {
 		this.externalIP = source.readString();
 		this.wasInternalAttack = source.readInt();
 		this.bssid = source.readString();
+        this.device = source.readString();
+        this.sync_id = source.readLong();
 	}
 
 	@Override
@@ -66,6 +70,8 @@ public class AttackRecord implements Parcelable, Serializable {
 		dest.writeString(externalIP);
 		dest.writeInt(wasInternalAttack);
 		dest.writeString(bssid);
+        dest.writeString(device);
+        dest.writeLong(sync_id);
 	}
 
 	/**
@@ -165,6 +171,10 @@ public class AttackRecord implements Parcelable, Serializable {
 		return remotePort;
 	}
 
+    public long getSync_id(){return sync_id;}
+    public String getDevice(){return device;}
+    public void setDevice(String d){this.device = d;}
+    public void setSync_id(long i){this.sync_id = i;}
 	/**
 	 * @param remotePort
 	 *            the remotePort to set

src/de/tudarmstadt/informatik/hostage/logging/SyncDevice.java

@@ -0,0 +1,32 @@
+package de.tudarmstadt.informatik.hostage.logging;
+
+/**
+ * Created by Julien on 04.12.2014.
+ */
+public class SyncDevice {
+
+    private long highest_attack_id;
+
+    private String deviceID;
+    private long last_sync_timestamp;
+
+
+    public long getHighest_attack_id(){return this.highest_attack_id;}
+    public void setHighest_attack_id(long i){this.highest_attack_id = i;}
+
+    /**
+     * @return the deviceID
+     */
+    public String getDeviceID() {
+        return deviceID;
+    }
+    /**
+     * @param deviceID the deviceID to set
+     */
+    public void setDeviceID(String deviceID) {
+        this.deviceID = deviceID;
+    }
+
+    public void setLast_sync_timestamp(long t){this.last_sync_timestamp = t;}
+    public long getLast_sync_timestamp(){return this.last_sync_timestamp;}
+}

src/de/tudarmstadt/informatik/hostage/logging/SyncInfoRecord.java

@@ -14,7 +14,7 @@ public class SyncInfoRecord implements Serializable{
 	private String BSSID;
 	private long number_of_attacks;
 	private long number_of_portscans;
-	
+
 	/**
 	 * @return the deviceID
 	 */

src/de/tudarmstadt/informatik/hostage/persistence/HostageDBContract.java

@@ -31,6 +31,8 @@ public final class HostageDBContract {
 		public static final String COLUMN_NAME_REMOTE_IP = "remoteIP";
 		public static final String COLUMN_NAME_REMOTE_PORT = "remotePort";
 		public static final String COLUMN_NAME_BSSID = "_bssid";
+        public static final String COLUMN_NAME_DEVICE = "_device";
+        public static final String COLUMN_NAME_SYNC_ID = "_sync_id";
 		public static final String COLUMN_NAME_INTERNAL_ATTACK = "internalAttack";
 
 		public static final String KEY_ID = COLUMN_NAME_ATTACK_ID;
@@ -51,6 +53,7 @@ public final class HostageDBContract {
 		public static final String TABLE_NAME = "sync_devices";
 		public static final String COLUMN_NAME_DEVICE_ID = "_device_id";	
 		public static final String COLUMN_NAME_DEVICE_TIMESTAMP = "last_sync_timestamp";
+        public static final String COLUMN_NAME_HIGHEST_ATTACK_ID = "highest_attack_id";
 		
 		public static final String KEY_ID = COLUMN_NAME_DEVICE_ID;
 	}

src/de/tudarmstadt/informatik/hostage/persistence/HostageDBOpenHelper.java

@@ -38,7 +38,7 @@ import de.tudarmstadt.informatik.hostage.ui.model.PlotComparisonItem;
 public class HostageDBOpenHelper extends SQLiteOpenHelper {
 
 	private static final String DATABASE_NAME = "hostage.db";
-	private static final int DATABASE_VERSION = 2;
+	private static final int DATABASE_VERSION = 3;
 	private Context context;
 
 	static {
@@ -64,8 +64,12 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		attackSQLBuilder.append(AttackEntry.COLUMN_NAME_REMOTE_PORT).append(" INTEGER,");
 		attackSQLBuilder.append(AttackEntry.COLUMN_NAME_INTERNAL_ATTACK).append(" INTEGER,");
 		attackSQLBuilder.append(AttackEntry.COLUMN_NAME_BSSID).append(" TEXT,");
-		attackSQLBuilder.append(String.format("FOREIGN KEY(%s) REFERENCES %s(%s)", AttackEntry.COLUMN_NAME_BSSID, NetworkEntry.TABLE_NAME,
+		attackSQLBuilder.append(String.format("FOREIGN KEY(%s) REFERENCES %s(%s) ON DELETE CASCADE ON UPDATE CASCADE,", AttackEntry.COLUMN_NAME_BSSID, NetworkEntry.TABLE_NAME,
 				NetworkEntry.COLUMN_NAME_BSSID));
+        attackSQLBuilder.append(AttackEntry.COLUMN_NAME_SYNC_ID).append(" INTEGER,");
+        attackSQLBuilder.append(AttackEntry.COLUMN_NAME_DEVICE).append(" TEXT,");
+        attackSQLBuilder.append(String.format("FOREIGN KEY(%s) REFERENCES %s(%s) ON DELETE CASCADE ON UPDATE CASCADE", AttackEntry.COLUMN_NAME_DEVICE, SyncDeviceEntry.TABLE_NAME,
+                SyncDeviceEntry.COLUMN_NAME_DEVICE_ID));
 		attackSQLBuilder.append(")");
 		SQL_CREATE_ATTACK_ENTRIES = attackSQLBuilder.toString();
 
@@ -86,7 +90,8 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		StringBuilder syncDevicesSQLBuilder = new StringBuilder("CREATE TABLE ").append(SyncDeviceEntry.TABLE_NAME).append("(");
 		syncDevicesSQLBuilder.append(SyncDeviceEntry.COLUMN_NAME_DEVICE_ID).append(" TEXT PRIMARY KEY,");
 		syncDevicesSQLBuilder.append(SyncDeviceEntry.COLUMN_NAME_DEVICE_TIMESTAMP).append(" INTEGER");
-		syncDevicesSQLBuilder.append(")");
+        syncDevicesSQLBuilder.append(SyncDeviceEntry.COLUMN_NAME_HIGHEST_ATTACK_ID).append(" INTEGER");
+        syncDevicesSQLBuilder.append(")");
 		SQL_CREATE_SYNC_DEVICES_ENTRIES = syncDevicesSQLBuilder.toString();
 
         // SyncInfoEntry
@@ -177,7 +182,7 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	
 	/**
 	 * Adds a given {@link AttackRecord} to the database.
-	 * 
+	 *
 	 * @param record
 	 *            The added {@link AttackRecord} .
 	 */
@@ -201,6 +206,42 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		db.insertWithOnConflict(AttackEntry.TABLE_NAME, null, attackValues, SQLiteDatabase.CONFLICT_REPLACE);
 		db.close(); // Closing database connection
 	}
+
+    /**
+     * Adds a given {@link AttackRecord}s to the database.
+     *
+     * @param List<AttackRecord>
+     *            The added {@link AttackRecord}s .
+     */
+    public void insertAttackRecords(List<AttackRecord> records) {
+
+
+        //Log.i("DBHelper", "Add Attack Record with id: " + record.getAttack_id());
+        SQLiteDatabase db = this.getWritableDatabase();
+        db.beginTransaction();
+
+        try {
+            for (AttackRecord record : records){
+                ContentValues attackValues = new ContentValues();
+                attackValues.put(AttackEntry.COLUMN_NAME_ATTACK_ID, record.getAttack_id()); // Log Attack ID
+                attackValues.put(AttackEntry.COLUMN_NAME_PROTOCOL, record.getProtocol().toString());
+                attackValues.put(AttackEntry.COLUMN_NAME_EXTERNAL_IP, record.getExternalIP());
+                attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_IP, record.getLocalIP()); // Log Local IP
+                attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_PORT, record.getLocalPort());
+                attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_IP, record.getRemoteIP()); // Log Remote IP
+                attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_PORT, record.getRemotePort()); // Log Remote Port
+                attackValues.put(AttackEntry.COLUMN_NAME_INTERNAL_ATTACK, record.getWasInternalAttack());
+                attackValues.put(AttackEntry.COLUMN_NAME_BSSID, record.getBssid());
+
+                // Inserting Rows
+                db.insertWithOnConflict(AttackEntry.TABLE_NAME, null, attackValues, SQLiteDatabase.CONFLICT_REPLACE);
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+        db.close(); // Closing database connection
+    }
 	
 	public void updateSyncAttackCounter(AttackRecord record){
 		
@@ -677,9 +718,32 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	 * @see  {@link HostageDBOpenHelper#updateNetworkInformation(NetworkRecord record)}
 	 */
 	public void updateNetworkInformation(ArrayList<NetworkRecord> networkInformation) {
-		for (NetworkRecord record : networkInformation) {
-			updateNetworkInformation(record);
-		}
+        SQLiteDatabase db = this.getReadableDatabase();
+
+        db.beginTransaction();
+        try {
+            for (NetworkRecord record : networkInformation) {
+                String bssid = record.getBssid();
+                String bssidQuery = "SELECT  * FROM " +  NetworkEntry.TABLE_NAME + " WHERE " +  NetworkEntry.COLUMN_NAME_BSSID + " = ?";
+                Cursor cursor = db.rawQuery(bssidQuery, new String[] {bssid});
+                if (!cursor.moveToFirst() || cursor.getLong(5) < record.getTimestampLocation()){
+                    ContentValues bssidValues = new ContentValues();
+                    bssidValues.put(NetworkEntry.COLUMN_NAME_BSSID, bssid);
+                    bssidValues.put(NetworkEntry.COLUMN_NAME_SSID, record.getSsid());
+                    bssidValues.put(NetworkEntry.COLUMN_NAME_LATITUDE, record.getLatitude());
+                    bssidValues.put(NetworkEntry.COLUMN_NAME_LONGITUDE, record.getLongitude());
+                    bssidValues.put(NetworkEntry.COLUMN_NAME_ACCURACY, record.getAccuracy());
+                    bssidValues.put(NetworkEntry.COLUMN_NAME_GEO_TIMESTAMP, record.getTimestampLocation());
+                    db.insertWithOnConflict(NetworkEntry.TABLE_NAME, null, bssidValues, SQLiteDatabase.CONFLICT_REPLACE);
+                }
+                cursor.close();
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
+        db.close();
 	}
 
 	/**
@@ -728,13 +792,21 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	 * @param devices HashMap of device ids and their synchronization timestamps.
 	 */
 	public void updateSyncDevices(HashMap<String, Long> devices){
-		SQLiteDatabase db = this.getReadableDatabase();		
-		for(String key : devices.keySet()){
-			ContentValues deviceValues = new ContentValues();
-			deviceValues.put(SyncDeviceEntry.COLUMN_NAME_DEVICE_ID, key);
-			deviceValues.put(SyncDeviceEntry.COLUMN_NAME_DEVICE_TIMESTAMP, devices.get(key));
-			db.insertWithOnConflict(SyncDeviceEntry.TABLE_NAME, null, deviceValues, SQLiteDatabase.CONFLICT_REPLACE);
-		}
+		SQLiteDatabase db = this.getReadableDatabase();
+        db.beginTransaction();
+
+        try {
+            for(String key : devices.keySet()){
+                ContentValues deviceValues = new ContentValues();
+                deviceValues.put(SyncDeviceEntry.COLUMN_NAME_DEVICE_ID, key);
+                deviceValues.put(SyncDeviceEntry.COLUMN_NAME_DEVICE_TIMESTAMP, devices.get(key));
+                db.insertWithOnConflict(SyncDeviceEntry.TABLE_NAME, null, deviceValues, SQLiteDatabase.CONFLICT_REPLACE);
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
 		db.close();
 	}
 	
@@ -792,10 +864,26 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	 * @param syncInfo ArrayList of {@link SyncInfoRecord SyncInfoRecords}
 	 * @see  {@link HostageDBOpenHelper#updateSyncInfo(SyncInfoRecord syncInfo)}
 	 */
-	public synchronized void updateSyncInfo(ArrayList<SyncInfoRecord> syncInfo){
-		for(SyncInfoRecord info : syncInfo){
-			updateSyncInfo(info);
-		}
+	public synchronized void updateSyncInfo(ArrayList<SyncInfoRecord> syncInfos){
+        SQLiteDatabase db = this.getReadableDatabase();
+        db.beginTransaction();
+
+        try {
+            for(SyncInfoRecord syncInfo : syncInfos){
+                ContentValues syncValues = new ContentValues();
+                syncValues.put(SyncInfoEntry.COLUMN_NAME_BSSID, syncInfo.getBSSID());
+                syncValues.put(SyncInfoEntry.COLUMN_NAME_DEVICE_ID, syncInfo.getDeviceID());
+                syncValues.put(SyncInfoEntry.COLUMN_NAME_NUMBER_ATTACKS, syncInfo.getNumber_of_attacks());
+                syncValues.put(SyncInfoEntry.COLUMN_NAME_NUMBER_PORTSCANS, syncInfo.getNumber_of_portscans());
+                db.insertWithOnConflict(SyncInfoEntry.TABLE_NAME, null, syncValues, SQLiteDatabase.CONFLICT_REPLACE);
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
+        db.close();
+
 	}
 	
 	/**
@@ -911,7 +999,8 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		record.setRemotePort(Integer.parseInt(cursor.getString(6)));
 		record.setWasInternalAttack(cursor.getInt(7) == 1);
 		record.setBssid(cursor.getString(8));
-
+        record.setSync_id(cursor.getLong(9));
+        record.setDevice(cursor.getString(10));
 		return record;
 	}
 	

src/de/tudarmstadt/informatik/hostage/ui/fragment/RecordOverviewFragment.java

@@ -36,6 +36,7 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Random;
 
+import de.tudarmstadt.informatik.hostage.Hostage;
 import de.tudarmstadt.informatik.hostage.R;
 import de.tudarmstadt.informatik.hostage.logging.AttackRecord;
 import de.tudarmstadt.informatik.hostage.logging.LogExport;
@@ -78,6 +79,8 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
     static final int DEFAULT_GROUPING_KEY_INDEX = 0;
 
+    private Hostage service;
+
     private boolean wasBelowTimePicker;
 
     private LogFilter filter;
@@ -1338,6 +1341,11 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
         int attackId = 0;
 
+
+        ArrayList<NetworkRecord> networkRecords = new ArrayList<NetworkRecord>();
+        ArrayList<AttackRecord> attackRecords = new ArrayList<AttackRecord>();
+
+
         for (int numOfNetworks = 0; numOfNetworks < createNetworks; numOfNetworks++){
             String ssidName = "WiFi" + ((numOfNetworks) + 1);
             String bssidName = "127.0.0." + ((numOfNetworks) + 1);
@@ -1362,7 +1370,8 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
             network.setLatitude(latitude);
             network.setAccuracy(0.f);
 
-            dbh.updateNetworkInformation(network);
+            //dbh.updateNetworkInformation(network);
+            networkRecords.add(network);
 
             // ATTACKS PER NETWORK
             for (int attackNumber = 0; attackNumber < numOfAttackPerNetwork; attackNumber++) {
@@ -1373,7 +1382,14 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
                 /* ADD A ATTACK*/
                 AttackRecord attack = new AttackRecord();
-                attack.setAttack_id(attackId);
+
+                SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(MainActivity.getContext());
+
+                SharedPreferences.Editor editor = pref.edit();
+                int attack_id = pref.getInt("ATTACK_ID_COUNTER", 0);
+                editor.putInt("ATTACK_ID_COUNTER", attack_id + 1);
+                editor.commit();
+                //attack.setAttack_id(attackId);
 
                 attack.setBssid(bssidName);
 
@@ -1381,7 +1397,8 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
                 attack.setLocalIP(bssidName);
 
 
-                dbh.addAttackRecord(attack);
+                //dbh.addAttackRecord(attack);
+                attackRecords.add(attack);
 
                 // MESSAGE PER ATTACK
                 for (int messageID = attackId; messageID < attackId + numRecordsPerAttack; messageID++) {
@@ -1408,6 +1425,9 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
         }
 
+        dbh.updateNetworkInformation(networkRecords);
+        dbh.insertAttackRecords(attackRecords);
+
 //        int countAllLogs = dbh.getAllRecords().size();
 //        int countRecords = dbh.getRecordCount();
 //        int countAttacks = dbh.getAttackCount();