full implemented filter view with time picker

res/layout/date_time_dialog.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/DateTimePicker"
+    android:layout_width="wrap_content"
+    android:layout_height="fill_parent"
+    android:gravity="center"
+    android:orientation="vertical"
+    android:padding="5dip" >
+
+    <DatePicker
+        android:id="@+id/DatePicker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginRight="40dp" />
+
+    <TimePicker
+        android:id="@+id/TimePicker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content" />
+
+</LinearLayout>

res/layout/fragment_record_list.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <ListView
+        android:id="@+id/loglistview"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentTop="true" >
+
+    </ListView>
+
+</RelativeLayout>

res/values/strings.xml

@@ -44,4 +44,7 @@
     <string name="drawer_profile_manager">Profile Manager</string>
     <string name="drawer_app_info">Application info</string>
 
+        <string name="button_title_apply">Apply</string>
+            <string name="button_title_cancel">Cancel</string>
+        
 </resources>

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

@@ -362,6 +362,57 @@ public class DatabaseHandler extends SQLiteOpenHelper {
         return recordList;
     }
     
+    
+	/**
+	 * Gets all non duplicate Records For the key BSSID.
+	 * @return A ArrayList with received Records.
+	 */
+    public ArrayList<String> getUniqueBSSIDRecords(){
+    	return this.getUniqueDataEntryForKeyType(KEY_BSSID, TABLE_BSSIDS);
+    }
+	/**
+	 * Gets all non duplicate Records For the key ESSID.
+	 * @return A ArrayList with received Records.
+	 */
+    public ArrayList<String> getUniqueESSIDRecords(){
+    	return this.getUniqueDataEntryForKeyType(KEY_SSID, TABLE_BSSIDS);
+    }
+	/**
+	 * Gets all non duplicate Records For the key protocol.
+	 * @return A ArrayList with received Records.
+	 */
+    public ArrayList<String> getUniqueProtocolRecords(){
+    	return this.getUniqueDataEntryForKeyType(KEY_PROTOCOL, TABLE_PORTS);
+    }
+	/**
+	 * Gets all non duplicate Data Entry For a specific KeyType ( e.g. BSSIDs).
+	 * @return A ArrayList with received Records.
+	 */
+    public ArrayList<String> getUniqueDataEntryForKeyType(String keyType, String table) {
+    	ArrayList<String> recordList = new ArrayList<String>();
+        //String selectQuery = "SELECT  * FROM " + TABLE_RECORDS + " NATURAL JOIN " + TABLE_ATTACK_INFO + " NATURAL JOIN " + TABLE_BSSIDS + " NATURAL JOIN " + TABLE_PORTS;
+        String selectQuery = "SELECT DISTINCT " + keyType + " FROM " + table + " ORDER BY " + keyType; // " NATURAL JOIN " + TABLE_ATTACK_INFO + " NATURAL JOIN " + TABLE_BSSIDS + " NATURAL JOIN " + TABLE_PORTS +
+
+        
+        // ORDERED BY TIME
+        System.out.println(selectQuery);
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.rawQuery(selectQuery, null);
+		
+        // looping through all rows and adding to list
+		if (cursor.moveToFirst()) {
+			do {
+				String record = cursor.getString(0);
+				recordList.add(record);
+			} while (cursor.moveToNext());
+		}       
+        cursor.close();
+ 
+        // return record list
+        db.close();
+        return recordList;
+    }
+    
 	/**
 	 * Gets a representative {@link Record} for every attack identified by its attack id.
 	 * @return A ArrayList with one {@link Record Records} for each attack id in the Database.

src/de/tudarmstadt/informatik/hostage/ui/LogFilter.java

@@ -184,14 +184,17 @@ public class LogFilter implements Parcelable{
 	public String convertArrayListToQueryString(ArrayList<String> list, String key){
 		String statement = "";
 		if (list == null) return statement;
-		
+		statement = " ( ";
+
 		int i = 0, max = list.size();
 		for (String element : list){
 			i++;
-			statement = statement + "key" + " LIKE " + "'%" + element + "%'";
+			statement = statement + key + " = " + "'" + element + "'";
 			if (i == max) continue;
 			statement = statement +" OR ";
 		}
+		statement = statement + " ) ";
+
 		return statement;
 	}
 	

src/de/tudarmstadt/informatik/hostage/ui2/activity/MainActivity.java

@@ -1,10 +1,13 @@
 package de.tudarmstadt.informatik.hostage.ui2.activity;
 
+import java.util.ArrayList;
+
 import android.app.ActionBar;
 import android.app.Activity;
 import android.app.Fragment;
 import android.app.FragmentManager;
 import android.content.Context;
+import android.content.Intent;
 import android.content.res.Configuration;
 import android.os.Bundle;
 import android.support.v4.app.ActionBarDrawerToggle;
@@ -13,13 +16,13 @@ import android.view.MenuItem;
 import android.view.View;
 import android.widget.AdapterView;
 import android.widget.ListView;
-
-import java.util.ArrayList;
-
 import de.tudarmstadt.informatik.hostage.R;
+import de.tudarmstadt.informatik.hostage.ui.LogFilter;
+import de.tudarmstadt.informatik.hostage.ui.ViewLogTable;
 import de.tudarmstadt.informatik.hostage.ui2.adapter.DrawerListAdapter;
 import de.tudarmstadt.informatik.hostage.ui2.fragment.HomeFragment;
 import de.tudarmstadt.informatik.hostage.ui2.fragment.ProfileManagerFragment;
+import de.tudarmstadt.informatik.hostage.ui2.fragment.RecordOverviewFragment;
 import de.tudarmstadt.informatik.hostage.ui2.fragment.opengl.ThreatIndicatorGLRenderer;
 import de.tudarmstadt.informatik.hostage.ui2.model.DrawerListItem;
 
@@ -34,6 +37,8 @@ public class MainActivity extends Activity {
 
     private CharSequence mDrawerTitle;
     private CharSequence mTitle;
+    
+    public Fragment displayedFragment;
 
     private ArrayList<DrawerListItem> drawerItems;
 
@@ -143,6 +148,13 @@ public class MainActivity extends Activity {
             case 0:
                 fragment = new HomeFragment();
                 break;
+            case 2:
+            	//LogFilter filter = new LogFilter();
+        		Intent intent = this.getIntent(); //new Intent(this, ViewLogTable.class);
+        		intent.removeExtra(LogFilter.LOG_FILTER_INTENT_KEY);
+        		//intent.putExtra(LogFilter.LOG_FILTER_INTENT_KEY, null);
+                fragment = new RecordOverviewFragment();
+                break;
             case 4:
                 fragment = new ProfileManagerFragment();
                 break;
@@ -151,6 +163,7 @@ public class MainActivity extends Activity {
         }
 
         if (fragment != null) {
+        	this.displayedFragment = fragment;
             FragmentManager fragmentManager = getFragmentManager();
             fragmentManager.beginTransaction()
                     .replace(R.id.content_frame, fragment).commit();
@@ -168,4 +181,8 @@ public class MainActivity extends Activity {
             displayView(position);
         }
     }
+    
+    public Fragment getDisplayedFragment(){
+    	return this.displayedFragment;
+    }
 }

src/de/tudarmstadt/informatik/hostage/ui2/dialog/ChecklistDialog.java

@@ -0,0 +1,154 @@
+package de.tudarmstadt.informatik.hostage.ui2.dialog;
+
+import java.util.ArrayList;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import de.tudarmstadt.informatik.hostage.R;
+import de.tudarmstadt.informatik.hostage.ui2.activity.MainActivity;
+
+public class ChecklistDialog extends DialogFragment {
+	
+	private ArrayList<Integer> mSelectedItems;
+	private ArrayList<String> itemTitles;
+    private ChecklistDialogListener mListener;
+    
+    private boolean isMultipleChoice;
+    
+    public String title;
+
+	static public final String DIALOG_TITLE_KEY = "DIALOG_TITLE_KEY";
+	static public final String DIALOG_IS_MULTIPLECHOICE_KEY = "DIALOG_IS_MULTIPLECHOICE_KEY";
+	static public final String DIALOG_SELECTED_INDEX_KEY = "DIALOG_SELECTED_INDEX_KEY";
+
+	static public final String DIALOG_TITLE_ARRAY_KEY = "DIALOG_TITLE_ARRAY_KEY";
+	static public final String DIALOG_MULTIPLECHOICE_SELECTED_KEY = "DIALOG_MULTIPLECHOICE_SELECTED_KEY";
+	
+	
+    public interface ChecklistDialogListener {
+        public void onDialogPositiveClick(ChecklistDialog dialog);
+        public void onDialogNegativeClick(ChecklistDialog dialog);
+    }
+    
+    public String getTitle(){
+    	return this.title;
+    }
+    
+    public boolean isMultipleChoice(){
+    	return this.isMultipleChoice;
+    }
+    
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        try {
+            
+            if (activity.getClass().equals(MainActivity.class)){
+            	mListener = (ChecklistDialogListener) (((MainActivity)activity).getDisplayedFragment());
+            } else {
+            	mListener = (ChecklistDialogListener) activity;
+            }
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement ChecklistDialogListener");
+        }
+    }
+    
+    public ArrayList<String> getSelectedItemTitles(){
+    	ArrayList<String> list = new ArrayList<String>();
+    	for(Integer i : this.mSelectedItems){
+    		list.add(this.itemTitles.get(i.intValue()));
+    	}
+    	return list;
+    }
+	
+	@Override
+	public Dialog onCreateDialog(Bundle savedInstanceState) {
+	    mSelectedItems = new ArrayList<Integer>();
+	    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+	    
+	    Intent intent = this.getActivity().getIntent();
+	    String title = intent.getStringExtra(DIALOG_TITLE_KEY);
+	    this.isMultipleChoice = intent.getBooleanExtra(DIALOG_IS_MULTIPLECHOICE_KEY, true);
+
+	    this.title = title;
+	    
+	    this.itemTitles =  intent.getStringArrayListExtra(DIALOG_TITLE_ARRAY_KEY);
+	    CharSequence[] titles = this.itemTitles.toArray(new CharSequence[this.itemTitles.size()]);
+
+	    ArrayList<String> selectedTitles = null;
+	    
+	    int selectedIndex = 0;
+	    
+	    boolean[] selectedArray = new boolean[this.itemTitles.size()];
+
+	    if(this.isMultipleChoice){
+	    	selectedTitles = intent.getStringArrayListExtra(DIALOG_MULTIPLECHOICE_SELECTED_KEY);
+	        int i = 0;
+		    for(String t : this.itemTitles){
+		    	boolean isSelected = selectedTitles.contains(t);
+		    	selectedArray[i] = isSelected;
+		    	if(isSelected) this.mSelectedItems.add(i);
+		    	i++;
+		    }
+	    } else {
+	    	 selectedIndex = intent.getIntExtra(DIALOG_SELECTED_INDEX_KEY,selectedIndex); 
+	    }
+	    
+	
+	    
+	    if(this.isMultipleChoice){
+	        builder.setTitle(title).setMultiChoiceItems(titles, selectedArray,
+                    new DialogInterface.OnMultiChoiceClickListener() {
+             public void onClick(DialogInterface dialog, int which,
+                     boolean isChecked) {
+          		   if (isChecked) {
+                     	mSelectedItems.add(which);
+                 	} else if (mSelectedItems.contains(which)) {
+                     	mSelectedItems.remove(Integer.valueOf(which));
+                 	}
+             }
+         }).setPositiveButton(R.string.button_title_apply, new DialogInterface.OnClickListener() {
+             public void onClick(DialogInterface dialog, int id) {
+                 mListener.onDialogPositiveClick(ChecklistDialog.this);
+             }
+         })
+         .setNegativeButton(R.string.button_title_cancel, new DialogInterface.OnClickListener() {
+             public void onClick(DialogInterface dialog, int id) {
+                 mListener.onDialogNegativeClick(ChecklistDialog.this);
+             }
+         });
+	        
+	    } else {
+	    	
+	    	 builder.setTitle(title).setSingleChoiceItems(titles, selectedIndex, 
+	    			 new DialogInterface.OnClickListener() {
+	             public void onClick(DialogInterface dialog, int id) {
+	                 mSelectedItems.clear();
+	            	 mSelectedItems.add(id);
+	             }
+	         })
+	         .setPositiveButton(R.string.button_title_apply, new DialogInterface.OnClickListener() {
+             public void onClick(DialogInterface dialog, int id) {
+                 mListener.onDialogPositiveClick(ChecklistDialog.this);
+             }
+	         })
+	         .setNegativeButton(R.string.button_title_cancel, new DialogInterface.OnClickListener() {
+	             public void onClick(DialogInterface dialog, int id) {
+	                 mListener.onDialogNegativeClick(ChecklistDialog.this);
+	             }
+	         });
+	    }
+	    
+	
+
+	    return builder.create();
+	}
+}
+
+

src/de/tudarmstadt/informatik/hostage/ui2/dialog/DateTimeDialogFragment.java

@@ -0,0 +1,203 @@
+package de.tudarmstadt.informatik.hostage.ui2.dialog;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Locale;
+
+import de.tudarmstadt.informatik.hostage.R;
+import de.tudarmstadt.informatik.hostage.ui2.activity.MainActivity;
+import de.tudarmstadt.informatik.hostage.ui2.dialog.ChecklistDialog.ChecklistDialogListener;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.AlertDialog.Builder;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.DatePicker;
+import android.widget.DatePicker.OnDateChangedListener;
+import android.widget.TimePicker;
+import android.widget.TimePicker.OnTimeChangedListener;
+
+@SuppressLint("ValidFragment")
+public class DateTimeDialogFragment extends DialogFragment implements OnDateChangedListener, OnTimeChangedListener {
+    // Define constants for date-time picker.
+    public final static int DATE_PICKER = 1;
+    public final static int TIME_PICKER = 2;
+    public final static int DATE_TIME_PICKER = 3;
+
+    // DatePicker reference
+    public DatePicker datePicker;
+
+    // TimePicker reference
+    public TimePicker timePicker;
+
+    // Calendar reference
+    private Calendar mCalendar;
+
+    // Define activity
+    private Activity activity;
+
+    // Define Dialog type
+    private int DialogType;
+
+    // Define Dialog view
+    private View mView;
+
+    // Constructor start
+    public DateTimeDialogFragment(Activity activity) {
+        this(activity, DATE_TIME_PICKER);
+    }
+
+    public DateTimeDialogFragment(Activity activity, int DialogType) {
+        this.activity = activity;
+        this.DialogType = DialogType;
+
+        // Inflate layout for the view
+        // Pass null as the parent view because its going in the dialog layout
+        LayoutInflater inflater = activity.getLayoutInflater();
+        mView = inflater.inflate(R.layout.date_time_dialog, null);  
+
+        // Grab a Calendar instance
+        mCalendar = Calendar.getInstance();
+
+        // Init date picker
+        datePicker = (DatePicker) mView.findViewById(R.id.DatePicker);
+        datePicker.init(mCalendar.get(Calendar.YEAR), mCalendar.get(Calendar.MONTH), mCalendar.get(Calendar.DAY_OF_MONTH), this);
+
+        // Init time picker
+        timePicker = (TimePicker) mView.findViewById(R.id.TimePicker);
+
+        // Set default Calendar and Time Style
+        setIs24HourView(true);
+        setCalendarViewShown(false);
+
+        switch (DialogType) {
+        case DATE_PICKER:
+            timePicker.setVisibility(View.GONE);
+            break;
+        case TIME_PICKER:
+            datePicker.setVisibility(View.GONE);
+            break;
+        }
+    }
+    
+
+   public long getDate(){
+	   
+       int day = datePicker.getDayOfMonth();
+       int month = datePicker.getMonth();
+       int year =  datePicker.getYear();
+       
+       int hourOfDay = timePicker.getCurrentHour();
+       int minute = timePicker.getCurrentMinute();
+
+       Calendar calendar = Calendar.getInstance();
+       calendar.set(year, month, day, hourOfDay, minute);
+
+       return calendar.getTime().getTime();
+   }
+    
+    public interface DateTimeDialogFragmentListener {
+        public void onDateTimePickerPositiveClick(DateTimeDialogFragment dialog);
+        public void onDateTimePickerNegativeClick(DateTimeDialogFragment dialog);
+    }
+    private DateTimeDialogFragmentListener mListener;
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        try {
+            
+            if (activity.getClass().equals(MainActivity.class)){
+            	mListener = (DateTimeDialogFragmentListener) (((MainActivity)activity).getDisplayedFragment());
+            } else {
+            	mListener = (DateTimeDialogFragmentListener) activity;
+            }
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement DateTimeDialogListener");
+        }
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+
+        Builder builder = new AlertDialog.Builder(activity);
+
+        builder.setView(mView);
+
+        builder.setMessage("Set Date")
+                .setPositiveButton("Set",
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int id) {
+                                mListener.onDateTimePickerPositiveClick(DateTimeDialogFragment.this);
+                            }
+                        })
+                .setNegativeButton("Cancel",
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int id) {
+                                mListener.onDateTimePickerNegativeClick(DateTimeDialogFragment.this);
+                                DateTimeDialogFragment.this.getDialog().cancel();
+                            }
+                        }); 
+
+        return builder.create();
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        timePicker.setOnTimeChangedListener(this);
+    }
+
+    public int get(final int field) {
+        return mCalendar.get(field);
+    }
+
+    public long getDateTimeMillis() {
+        return mCalendar.getTimeInMillis();
+    }
+
+    public void setIs24HourView(boolean is24HourView) {
+        timePicker.setIs24HourView(is24HourView);
+    }
+
+    public boolean is24HourView() {
+        return timePicker.is24HourView();
+    }
+
+    public void setCalendarViewShown(boolean calendarView) {
+        datePicker.setCalendarViewShown(calendarView);
+    }
+
+    public boolean CalendarViewShown() {
+        return datePicker.getCalendarViewShown();
+    }
+
+    public void updateDate(int year, int monthOfYear, int dayOfMonth) {
+        datePicker.updateDate(year, monthOfYear, dayOfMonth);
+    }
+
+    public void updateTime(int currentHour, int currentMinute) {
+        timePicker.setCurrentHour(currentHour);
+        timePicker.setCurrentMinute(currentMinute);
+    }
+
+    public String getDateTime() {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
+        return sdf.format(mCalendar.getTime());
+    }
+
+    public void onDateChanged(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
+        mCalendar.set(year, monthOfYear, dayOfMonth, mCalendar.get(Calendar.HOUR_OF_DAY), mCalendar.get(Calendar.MINUTE));
+    }
+
+    public void onTimeChanged(TimePicker view, int hourOfDay, int minute) {
+        mCalendar.set(mCalendar.get(Calendar.YEAR), mCalendar.get(Calendar.MONTH), mCalendar.get(Calendar.DAY_OF_MONTH), hourOfDay, minute);
+    }
+}

src/de/tudarmstadt/informatik/hostage/ui2/dialog/TimePickerFragment.java

@@ -0,0 +1,31 @@
+package de.tudarmstadt.informatik.hostage.ui2.dialog;
+
+import java.util.Calendar;
+
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.app.TimePickerDialog;
+import android.os.Bundle;
+import android.text.format.DateFormat;
+import android.widget.TimePicker;
+
+
+public class TimePickerFragment extends DialogFragment implements
+		TimePickerDialog.OnTimeSetListener {
+
+	@Override
+	public Dialog onCreateDialog(Bundle savedInstanceState) {
+		// Use the current time as the default values for the picker
+		final Calendar c = Calendar.getInstance();
+		int hour = c.get(Calendar.HOUR_OF_DAY);
+		int minute = c.get(Calendar.MINUTE);
+
+		// Create a new instance of TimePickerDialog and return it
+		return new TimePickerDialog(getActivity(), this, hour, minute,
+				DateFormat.is24HourFormat(getActivity()));
+	}
+
+	public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
+		// Do something with the time chosen by the user
+	}
+}

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

@@ -0,0 +1,447 @@
+package de.tudarmstadt.informatik.hostage.ui2.fragment;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+
+import android.annotation.SuppressLint;
+import android.app.Fragment;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.SimpleAdapter;
+import android.widget.Toast;
+import de.tudarmstadt.informatik.hostage.R;
+import de.tudarmstadt.informatik.hostage.logging.DatabaseHandler;
+import de.tudarmstadt.informatik.hostage.logging.Record;
+import de.tudarmstadt.informatik.hostage.logging.Record.TYPE;
+import de.tudarmstadt.informatik.hostage.ui.LogFilter;
+import de.tudarmstadt.informatik.hostage.ui.LogFilter.SortType;
+import de.tudarmstadt.informatik.hostage.ui2.dialog.ChecklistDialog;
+import de.tudarmstadt.informatik.hostage.ui2.dialog.DateTimeDialogFragment;
+
+public class RecordOverviewFragment extends Fragment implements ChecklistDialog.ChecklistDialogListener, DateTimeDialogFragment.DateTimeDialogFragmentListener {
+	static final String SELECTED_KEY = "Selected";
+	static final String OTHERS_KEY = "Other";
+	
+	static final String FILTER_MENU_TITLE_BSSID = "BSSID";
+	static final String FILTER_MENU_TITLE_ESSID = "ESSID";
+	static final String FILTER_MENU_TITLE_PROTOCOLS = "Protocols";
+	static final String FILTER_MENU_TITLE_TIMESTAMP_BELOW = "To Date";
+	static final String FILTER_MENU_TITLE_TIMESTAMP_ABOVE = "From Date";
+	static final String FILTER_MENU_TITLE_SORTING = "Sort by";
+	static final String FILTER_MENU_TITLE_REMOVE = "Remove";
+	
+	private boolean wasBelowTimePicker;
+
+	private LogFilter filter;
+	private ListView listView;
+	private boolean showFilterButton;
+	DatabaseHandler dbh;
+	
+	
+    public RecordOverviewFragment(){}
+	
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+	public View onCreateView(LayoutInflater inflater, ViewGroup container,
+             Bundle savedInstanceState) {
+
+		
+		dbh = new DatabaseHandler(this.getActivity().getBaseContext());
+	    // Get the message from the intent
+	    Intent intent = this.getActivity().getIntent();
+	    LogFilter filter = intent.getParcelableExtra(LogFilter.LOG_FILTER_INTENT_KEY);
+
+	    if(filter == null){
+	    	this.clearFilter();
+	    } else {
+	    	this.filter = filter;
+	    }
+
+	    this.setShowFilterButton(!this.filter.isNotEditable());
+	    
+	    this.addRecordToDB();
+	    
+		View rootView = inflater.inflate(R.layout.fragment_record_list, container, false);
+		ListView mylist = (ListView) rootView.findViewById(R.id.loglistview);
+		this.listView = mylist;
+		populateListViewFromDB(mylist);
+		
+		registerListClickCallback(mylist);
+		
+		return rootView;
+	 }
+	
+	private void clearFilter(){
+    	this.filter = new LogFilter();
+    	this.filter.setProtocols(this.protocolTitles());
+    	this.filter.setBSSIDs(this.bssids());
+    	this.filter.setESSIDs(this.essids());
+	}
+	
+	private void populateListViewFromDB(ListView mylist) {
+		
+		ArrayList<HashMap<String, String>> Items = new ArrayList<HashMap<String, String>>();
+
+		ArrayList<Record> data = dbh.getRecordsForFilter(this.filter);    
+		
+
+		for (Record val : data) {
+			HashMap<String, String> map = new HashMap<String, String>();
+			map.put(this.getString(R.string.RecordBSSID), val.getBSSID());
+			map.put(this.getString(R.string.RecordSSID), val.getSSID());
+			map.put(this.getString(R.string.RecordProtocol), val.getProtocol());
+			map.put(this.getString(R.string.RecordTimestamp),
+					this.getDateAsString(val.getTimestamp()));
+			Items.add(map);
+		}
+	        
+	     // Adding Items to ListView
+	        String keys[] = new String[] { this.getString(R.string.RecordBSSID), this.getString(R.string.RecordSSID), this.getString(R.string.RecordProtocol), this.getString(R.string.RecordTimestamp)};
+	        int ids[] = new int[] {R.id.RecordTextFieldBSSID, R.id.RecordTextFieldSSID, R.id.RecordTextFieldProtocol, R.id.RecordTextFieldTimestamp };
+	        
+	        ListAdapter adapter = new SimpleAdapter(this.getActivity(), Items, R.layout.loglist_row, keys, ids);
+	        
+	        mylist.setAdapter(adapter);
+	}
+	
+	private Context getBaseContext(){
+		return this.getActivity().getBaseContext();
+	}
+	
+	private Context getApplicationContext(){
+		return this.getActivity().getApplicationContext();
+	}
+	
+	private void registerListClickCallback(ListView mylist) {
+
+		mylist.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+			public void onItemClick(AdapterView<?> parent, View viewClicked,
+					int position, long idInDB) {
+				DatabaseHandler dbh = new DatabaseHandler(getBaseContext());
+				Record rec = dbh.getRecord((int) idInDB);
+				String message = createInformationStringFromRecord(rec);
+				Toast.makeText(getApplicationContext(), message,
+						Toast.LENGTH_LONG).show();
+			}
+
+			private String createInformationStringFromRecord(Record rec) {
+				String message = "id: " + rec.getId() + "\n" + "attack_id: "
+						+ rec.getAttack_id() + "\n" + "protocol: "
+						+ rec.getProtocol() + "\n" + "type: " + rec.getType()
+						+ "\n" + "externalIP: " + rec.getExternalIP() + "\n"
+						+ "localIP: " + rec.getLocalIP() + "\n"
+						+ "local port: " + rec.getLocalPort() + "\n"
+						+ "remoteIP: " + rec.getRemoteIP() + "\n" + "BSSID: "
+						+ rec.getBSSID() + "\n" + "SSID: " + rec.getSSID()
+						+ "\n" + "latitude: " + rec.getLatitude() + "\n"
+						+ "longitude: " + rec.getLongitude() + "\n"
+						+ "accuracy: " + rec.getAccuracy() + "\n" + "packet: "
+						+ rec.getPacket() + "\n"
+						+ getDateAsString(rec.getTimestamp()) + "";
+				return message;
+			}
+
+			@SuppressLint("SimpleDateFormat")
+			private String getDateAsString(long timeStamp) {
+
+				try {
+					DateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
+					Date netDate = (new Date(timeStamp));
+					return sdf.format(netDate);
+				} catch (Exception ex) {
+					return "xx";
+				}
+			}
+
+		});
+	}
+	
+
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		super.onCreateOptionsMenu(menu, inflater);
+		if(this.showFilterButton){
+			for(String title : this.filterTitles()){
+				MenuItem item = menu.add(title);
+				
+			}
+		}
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		String title = item.getTitle().toString();
+		
+		if(title.equals(FILTER_MENU_TITLE_BSSID)){
+			this.openBSSIDFilterDialog();
+		}
+		if(title.equals(FILTER_MENU_TITLE_ESSID)){
+			this.openESSIDFilterDialog();
+		}		
+		if(title.equals(FILTER_MENU_TITLE_PROTOCOLS)){
+			this.openProtocolsFilterDialog();
+		}
+		if(title.equals(FILTER_MENU_TITLE_SORTING)){
+			this.openSortingDialog();
+		}
+		if(title.equals(FILTER_MENU_TITLE_REMOVE)){
+			this.clearFilter();
+		}
+		if(title.equals(FILTER_MENU_TITLE_TIMESTAMP_BELOW)){
+			this.openTimestampToFilterDialog();
+		}
+		if(title.equals(FILTER_MENU_TITLE_TIMESTAMP_ABOVE)){
+			this.openTimestampFromFilterDialog();
+		}
+		return super.onOptionsItemSelected(item);
+	}
+	
+	
+	
+	
+	private void openBSSIDFilterDialog(){
+	    Intent intent = this.getActivity().getIntent();
+	    intent.putExtra(ChecklistDialog.DIALOG_TITLE_KEY, FILTER_MENU_TITLE_BSSID);
+	    intent.putExtra(ChecklistDialog.DIALOG_IS_MULTIPLECHOICE_KEY, true);
+
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_TITLE_ARRAY_KEY, this.bssids());
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_MULTIPLECHOICE_SELECTED_KEY, this.selectedBSSIDs());
+		
+		ChecklistDialog newFragment = new ChecklistDialog();
+	    newFragment.show(this.getActivity().getFragmentManager(), FILTER_MENU_TITLE_BSSID);
+	}
+	
+	private void openESSIDFilterDialog(){
+		
+	    Intent intent = this.getActivity().getIntent();
+	    intent.putExtra(ChecklistDialog.DIALOG_TITLE_KEY, FILTER_MENU_TITLE_ESSID);
+	    intent.putExtra(ChecklistDialog.DIALOG_IS_MULTIPLECHOICE_KEY, true);
+
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_TITLE_ARRAY_KEY, this.essids());
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_MULTIPLECHOICE_SELECTED_KEY, this.selectedESSIDs());
+		
+		ChecklistDialog newFragment = new ChecklistDialog();
+	    newFragment.show(this.getActivity().getFragmentManager(), FILTER_MENU_TITLE_ESSID);
+	}
+	
+	private void openProtocolsFilterDialog(){
+	    Intent intent = this.getActivity().getIntent();
+	    intent.putExtra(ChecklistDialog.DIALOG_TITLE_KEY, FILTER_MENU_TITLE_PROTOCOLS);
+	    intent.putExtra(ChecklistDialog.DIALOG_IS_MULTIPLECHOICE_KEY, true);
+
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_TITLE_ARRAY_KEY, this.protocolTitles());
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_MULTIPLECHOICE_SELECTED_KEY, this.selectedProtocols());
+		
+		ChecklistDialog newFragment = new ChecklistDialog();
+	    newFragment.show(this.getActivity().getFragmentManager(), FILTER_MENU_TITLE_PROTOCOLS);
+	}
+	
+	private void openTimestampFromFilterDialog(){
+		this.wasBelowTimePicker = false;
+		DateTimeDialogFragment newFragment = new DateTimeDialogFragment(this.getActivity());
+	    newFragment.show(this.getActivity().getFragmentManager(), FILTER_MENU_TITLE_SORTING);
+	}
+	
+	private void openTimestampToFilterDialog(){
+		this.wasBelowTimePicker = true;
+		DateTimeDialogFragment newFragment = new DateTimeDialogFragment(this.getActivity());
+	    newFragment.show(this.getActivity().getFragmentManager(), FILTER_MENU_TITLE_SORTING);
+	}
+	
+	private void openSortingDialog(){
+	    Intent intent = this.getActivity().getIntent();
+	    intent.putExtra(ChecklistDialog.DIALOG_TITLE_KEY, FILTER_MENU_TITLE_SORTING);
+	    intent.putExtra(ChecklistDialog.DIALOG_IS_MULTIPLECHOICE_KEY, false);
+	    
+	     intent.putStringArrayListExtra(ChecklistDialog.DIALOG_TITLE_ARRAY_KEY, this.sortTypeTtiles());
+	     intent.putExtra(ChecklistDialog.DIALOG_SELECTED_INDEX_KEY, this.filter.sorttype.getValue());
+		
+		ChecklistDialog newFragment = new ChecklistDialog();
+	    newFragment.show(this.getActivity().getFragmentManager(), FILTER_MENU_TITLE_SORTING);
+	}
+	
+	
+	public void onDialogPositiveClick(ChecklistDialog dialog) {
+		// TODO Auto-generated method stub
+		String title = dialog.getTitle();
+		if(title.equals(FILTER_MENU_TITLE_BSSID)){
+			this.filter.setBSSIDs(dialog.getSelectedItemTitles());
+		}
+		if(title.equals(FILTER_MENU_TITLE_ESSID)){
+			this.filter.setESSIDs(dialog.getSelectedItemTitles());
+		}
+		if(title.equals(FILTER_MENU_TITLE_PROTOCOLS)){
+			this.filter.setProtocols(dialog.getSelectedItemTitles());
+		}
+		if(title.equals(FILTER_MENU_TITLE_SORTING)){
+			ArrayList<String> titles = dialog.getSelectedItemTitles();
+			String t = titles.get(0);
+			int sortType = this.sortTypeTtiles().indexOf(t);
+			this.filter.setSorttype(SortType.values()[sortType]);
+		}
+		this.populateListViewFromDB(this.listView);
+	}
+
+	public void onDialogNegativeClick(ChecklistDialog dialog) {
+		// nothing in here
+	}
+
+	
+	
+	@SuppressLint("SimpleDateFormat")
+	private String getDateAsString(long timeStamp) {
+
+		try {
+			DateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
+			Date netDate = (new Date(timeStamp));
+			return sdf.format(netDate);
+		} catch (Exception ex) {
+			return "xx";
+		}
+	}
+
+	public boolean isShowFilterButton() {
+		return showFilterButton;
+	}
+
+	public void setShowFilterButton(boolean showFilterButton) {
+		this.showFilterButton = showFilterButton;
+	}
+	
+	
+	public ArrayList<String> protocolTitles(){
+		ArrayList<String> titles = new ArrayList<String>();
+		for (String protocol : this.getResources().getStringArray(
+				R.array.protocols)) {
+			titles.add(protocol);
+		}
+		return titles;
+	}
+	public ArrayList<String> selectedProtocols(){
+		return this.filter.protocols;
+	}
+
+	public ArrayList<String> sortTypeTtiles(){
+		ArrayList<String> titles = new ArrayList<String>();
+		titles.add("Time");
+		titles.add("Protocol");
+		titles.add("BSSID");
+		titles.add("ESSID");
+		titles.add("Remote Host Name");
+		titles.add("Local Host Name");
+		//titles.add("Attack ID");
+		//titles.add("ID");
+		return titles;
+	}
+	
+	public ArrayList<String> bssids(){
+		ArrayList<String> titles = new ArrayList<String>();
+		ArrayList<String> records = dbh.getUniqueBSSIDRecords();
+
+		return records;
+	}
+	public ArrayList<String> selectedBSSIDs(){
+		return this.filter.BSSIDs;
+	}
+
+
+	public ArrayList<String> essids(){
+		ArrayList<String> titles = new ArrayList<String>();
+		ArrayList<String> records = dbh.getUniqueESSIDRecords();
+
+		return records;
+	}
+	public ArrayList<String> selectedESSIDs(){
+		return this.filter.ESSIDs;
+	}
+
+	
+	private ArrayList<String> filterTitles(){
+		ArrayList<String> titles = new ArrayList<String>();
+		titles.add(FILTER_MENU_TITLE_BSSID);
+		titles.add(FILTER_MENU_TITLE_ESSID);
+		titles.add(FILTER_MENU_TITLE_PROTOCOLS);
+		titles.add(FILTER_MENU_TITLE_TIMESTAMP_ABOVE);
+		titles.add(FILTER_MENU_TITLE_TIMESTAMP_BELOW);
+		titles.add(FILTER_MENU_TITLE_SORTING);
+		titles.add(FILTER_MENU_TITLE_REMOVE);
+		return titles;
+	}
+
+	
+	
+	
+	/*****************************
+	 * 
+	 *          TEST 
+	 * 
+	 * ***************************/
+	
+	private void addRecordToDB() {
+		Calendar cal = Calendar.getInstance();
+
+		int maxProtocolsIndex = this.getResources().getStringArray(
+				R.array.protocols).length;
+
+		int numberofRecords = (int) (Math.random() * (50 - 10));
+		for (int i = 0; i < numberofRecords; i++) {
+			Record record = new Record();
+			record.setBSSID("BSSID: " + i);
+			record.setSSID("SSID: w" + i);
+			record.setTimestamp(cal.getTimeInMillis()
+					+ ((i * 60 * 60 * 60 * 24) * 1000));
+
+			int index = i % maxProtocolsIndex;
+			String protocolName = this.getResources().getStringArray(
+					R.array.protocols)[index];
+
+			record.setProtocol(protocolName);
+			record.setId(i);
+			record.setAttack_id(i);
+			try {
+				InetAddress localIP = InetAddress.getByAddress("Digga",
+						new byte[] { 127, 0, 0, 1 }); // .getByName("192.168.2.1");
+				record.setLocalIP(localIP);
+				record.setRemoteIP(InetAddress.getByAddress("Digga",
+						new byte[] { 127, 1, 1, 1 }));
+				record.setType(TYPE.SEND);
+			} catch (UnknownHostException e) {
+				e.printStackTrace();
+			}
+
+			dbh.addRecord(record);
+		}
+	}
+
+	public void onDateTimePickerPositiveClick(DateTimeDialogFragment dialog) {
+		if(this.wasBelowTimePicker){
+			this.filter.setBelowTimestamp(dialog.getDate());
+		} else {
+			this.filter.setAboveTimestamp(dialog.getDate());
+		}
+		this.populateListViewFromDB(listView);
+	}
+
+	public void onDateTimePickerNegativeClick(DateTimeDialogFragment dialog) {
+		// nothing in here
+	}
+
+}