diff --git a/app/src/main/java/de/apps4ics/mountainnavigation/DatabaseHandler.java b/app/src/main/java/de/apps4ics/mountainnavigation/DatabaseHandler.java
index 34c3195..10056c5 100644
--- a/app/src/main/java/de/apps4ics/mountainnavigation/DatabaseHandler.java
+++ b/app/src/main/java/de/apps4ics/mountainnavigation/DatabaseHandler.java
@@ -26,6 +26,8 @@
     private static final String TABLE_CELL_RECEPTION = "cell_reception";
     private static final String TABLE_WIFI = "wifi";
     private static final String TABLE_LIFT = "lift";
+    private static final String[] TABLES = new String[]{TABLE_FOUNTAIN, TABLE_PATH, TABLE_HUT, TABLE_PEAK, TABLE_BREAK_POINT, TABLE_TRASH_BIN, TABLE_IMAGE, TABLE_CELL_RECEPTION, TABLE_WIFI, TABLE_LIFT};
+    private static final Integer[] TABLE_TYPES = new Integer[]{Types.FOUNTAIN, Types.PATH, Types.HUT, Types.PEAK, Types.BREAK_POINT, Types.TRASH_BIN, Types.PIC, Types.CELL_RECEPTION, Types.WIFI, Types.LIFT};
 
     private static final String KEY_POI_ID = "_id";
     private static final String KEY_POI_LAT = "_lat";
@@ -124,7 +126,8 @@
                 + KEY_CELL_RECEPTION_STRENGTH + " INTEGER,"
                 + KEY_CELL_RECEPTION_OP_NAME + " TEXT,"
                 + KEY_CELL_RECEPTION_OP_COUNTRY + " TEXT,"
-                + KEY_CELL_RECEPTION_ROAMING + " INTEGER" + ")";
+                + KEY_CELL_RECEPTION_ROAMING + " INTEGER,"
+                + KEY_CELL_RECEPTION_NW_TYPE + " TEXT" + ")";
         db.execSQL(CREATE_CR_TABLE);
         //create wifi table
         String CREATE_WIFI_TABLE = "CREATE TABLE " + TABLE_WIFI + "("
@@ -209,14 +212,37 @@
                 values.put(KEY_IMAGE_IMG, i.getImage());
                 break;
             case Types.CELL_RECEPTION:
+                CellReception cr = (CellReception) poi;
+                values.put(KEY_GP_ID, cr.getGpId());
+                values.put(KEY_CELL_RECEPTION_STRENGTH, cr.getStrength());
+                values.put(KEY_CELL_RECEPTION_OP_NAME, cr.getOpName());
+                values.put(KEY_CELL_RECEPTION_OP_COUNTRY, cr.getOpCountry());
+                values.put(KEY_CELL_RECEPTION_ROAMING, cr.getRoaming());
+                values.put(KEY_CELL_RECEPTION_NW_TYPE, cr.getNwType());
                 break;
             case Types.WIFI:
+                Wifi w = (Wifi) poi;
+                values.put(KEY_GP_ID, w.getGpId());
+                values.put(KEY_WIFI_SSID, w.getSsid());
+                values.put(KEY_WIFI_LEVELS, w.getLevels());
                 break;
             case Types.LIFT:
+                Lift l = (Lift) poi;
+                values.put(KEY_GP_S_ID, l.getStartGpId());
+                values.put(KEY_GP_E_ID, l.getEndGpId());
+                values.put(KEY_LIFT_NAME, l.getName());
                 break;
             case Types.PEAK:
+                Peak peak = (Peak) poi;
+                values.put(KEY_GP_ID, peak.getGpId());
+                values.put(KEY_PEAK_NAME, peak.getName());
                 break;
             case Types.HUT:
+                Hut h = (Hut) poi;
+                values.put(KEY_GP_ID, h.getGpId());
+                values.put(KEY_HUT_TYPE, h.getHutType());
+                values.put(KEY_HUT_WINTER_ROOM, h.getWinterRoom());
+                values.put(KEY_HUT_NAME, h.getName());
                 break;
             case Types.GP:
                 DbGeoPoint dbgp = (DbGeoPoint) poi;
@@ -232,46 +258,389 @@
         return rowId;
     }
 
-    public Poi getPoi(int id){
-        SQLiteDatabase db = this.getReadableDatabase();
+    private Poi getPoiFromCursor(Cursor cursor, int type){
+        switch(type){
+            case Types.FOUNTAIN:
+                return getFountainFromCursor(cursor);
+            case Types.PATH:
+                return getPathFromCursor(cursor);
+            case Types.BREAK_POINT:
+                return getBreakpointFromCursor(cursor);
+            case Types.TRASH_BIN:
+                return getTrashbinFromCursor(cursor);
+            case Types.PIC:
+                return getImageFromCursor(cursor);
+            case Types.CELL_RECEPTION:
+                return getCellReceptionFromCursor(cursor);
+            case Types.WIFI:
+                return getWifiFromCursor(cursor);
+            case Types.LIFT:
+                return getLiftFromCursor(cursor);
+            case Types.PEAK:
+                return getPeakFromCursor(cursor);
+            case Types.HUT:
+                return getHutFromCursor(cursor);
+            case Types.GP:
+                return getGeoPointFromCursor(cursor);
+        }
+        return null;
+    }
 
-        Cursor cursor = db.query(TABLE_POI,
-                new String[]{KEY_POI_ID, KEY_POI_LAT, KEY_POI_LON, KEY_POI_ALT, KEY_POI_TYPE, KEY_POI_TIME, KEY_POI_EXT_POI_ID},
+    private DbGeoPoint getGeoPointFromCursor(Cursor cursor){
+        long gp_id = cursor.getLong(0);
+        double lat = cursor.getDouble(1);
+        double lon = cursor.getDouble(2);
+        double alt = cursor.getDouble(3);
+        String type_id = cursor.getString(4);
+        long time = cursor.getLong(5) * 1000;
+        return new DbGeoPoint(gp_id, lat, lon, alt, time, type_id);
+    }
+
+    private DbGeoPoint getGeoPoint(long gp_id){
+        SQLiteDatabase db = getReadableDatabase();
+        Cursor gpCursor = db.query(TABLE_GP,
+                new String[]{KEY_POI_ID, KEY_POI_LAT, KEY_POI_LON, KEY_POI_ALT, KEY_TYPE_ID, KEY_POI_TIME},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(gp_id)}, null, null, null, null);
+        if(gpCursor != null){
+            gpCursor.moveToFirst();
+        }
+        return getGeoPointFromCursor(gpCursor);
+    }
+
+    private Fountain getFountainFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        int size = cursor.getInt(2);
+        return new Fountain(_id, size, getGeoPoint(_gp_id));
+    }
+
+    private Fountain getFountain(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_FOUNTAIN,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_FOUNTAIN_SIZE},
                 KEY_POI_ID + "=?",
                 new String[]{String.valueOf(id)}, null, null, null, null);
-        if(cursor != null){
+        if (cursor != null) {
             cursor.moveToFirst();
         }
+        return getFountainFromCursor(cursor);
+    }
 
-        int _id = Integer.parseInt(cursor.getString(0));
-        double _lat = Double.parseDouble(cursor.getString(1));
-        double _lon = Double.parseDouble(cursor.getString(2));
-        double _alt = Double.parseDouble(cursor.getString(3));
-        int _type = Integer.parseInt(cursor.getString(4));
-        long _time = Long.parseLong(cursor.getString(5)) * 1000;
-        int _ext_poi_id = Integer.parseInt(cursor.getString(6));
+    private Path getPathFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_s_id = cursor.getLong(1);
+        long _gp_e_id = cursor.getLong(2);
+        long _length = cursor.getLong(3);
+        int exposed = cursor.getInt(4);
+        int diff_wet = cursor.getInt(5);
+        int giddiness = cursor.getInt(6);
+        int climbing = cursor.getInt(7);
+        return new Path(_id, _length, exposed, diff_wet, giddiness, climbing, getGeoPoint(_gp_s_id), getGeoPoint(_gp_e_id));
+    }
+
+    private Path getPath(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_PATH,
+                new String[]{KEY_POI_ID, KEY_GP_S_ID, KEY_GP_E_ID, KEY_PATH_LENGTH, KEY_PATH_EXPOSED, KEY_PATH_DIFF_WET, KEY_PATH_GIDDINESS, KEY_PATH_CLIMBING},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getPathFromCursor(cursor);
+    }
+
+    private BreakPoint getBreakpointFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        int stone = cursor.getInt(2);
+        int bench = cursor.getInt(3);
+        int table = cursor.getInt(4);
+        int roofed = cursor.getInt(5);
+        return new BreakPoint(_id, stone, bench, table, roofed, getGeoPoint(_gp_id));
+    }
+
+    private BreakPoint getBreakpoint(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_BREAK_POINT,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_BREAK_POINT_STONE, KEY_BREAK_POINT_BENCH, KEY_BREAK_POINT_TABLE, KEY_BREAK_POINT_ROOFED},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getBreakpointFromCursor(cursor);
+    }
+
+    private TrashBin getTrashbinFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        return new TrashBin(_id, getGeoPoint(_gp_id));
+    }
+
+    private TrashBin getTrashbin(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_TRASH_BIN,
+                new String[]{KEY_POI_ID, KEY_GP_ID},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getTrashbinFromCursor(cursor);
+    }
+
+    private Image getImageFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        String type_id = cursor.getString(2);
+        byte[] img = cursor.getBlob(3);
+        return new Image(_id, type_id, img, getGeoPoint(_gp_id));
+    }
+
+    private Image getImage(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_IMAGE,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_TYPE_ID, KEY_IMAGE_IMG},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getImageFromCursor(cursor);
+    }
+
+    private CellReception getCellReceptionFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        int strength = cursor.getInt(2);
+        String opName = cursor.getString(3);
+        String opCountry = cursor.getString(4);
+        int roaming = cursor.getInt(5);
+        String nwType = cursor.getString(6);
+        return new CellReception(_id, strength, opName, opCountry, roaming, nwType, getGeoPoint(_gp_id));
+    }
+
+    private CellReception getCellReception(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_CELL_RECEPTION,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_CELL_RECEPTION_STRENGTH, KEY_CELL_RECEPTION_OP_NAME, KEY_CELL_RECEPTION_OP_COUNTRY, KEY_CELL_RECEPTION_ROAMING, KEY_CELL_RECEPTION_NW_TYPE},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getCellReceptionFromCursor(cursor);
+    }
+
+    private Wifi getWifiFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        String ssid = cursor.getString(2);
+        int levels = cursor.getInt(3);
+        return new Wifi(_id, ssid, levels, getGeoPoint(_gp_id));
+    }
+
+    private Wifi getWifi(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_WIFI,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_WIFI_SSID, KEY_WIFI_LEVELS},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getWifiFromCursor(cursor);
+    }
+
+    private Lift getLiftFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_s_id = cursor.getLong(1);
+        long _gp_e_id = cursor.getLong(2);
+        String name = cursor.getString(3);
+        return new Lift(_id, name, getGeoPoint(_gp_s_id), getGeoPoint(_gp_e_id));
+    }
+
+    private Lift getLift(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_LIFT,
+                new String[]{KEY_POI_ID, KEY_GP_S_ID, KEY_GP_E_ID, KEY_LIFT_NAME},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getLiftFromCursor(cursor);
+    }
+
+    private Peak getPeakFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        String name = cursor.getString(2);
+        return new Peak(_id, name, getGeoPoint(_gp_id));
+    }
+
+    private Peak getPeak(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_PEAK,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_PEAK_NAME},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getPeakFromCursor(cursor);
+    }
+
+    private Hut getHutFromCursor(Cursor cursor){
+        long _id = cursor.getLong(0);
+        long _gp_id = cursor.getLong(1);
+        int hut_type = cursor.getInt(2);
+        int winterroom = cursor.getInt(3);
+        String name = cursor.getString(4);
+        return new Hut(_id, hut_type, winterroom, name, getGeoPoint(_gp_id));
+    }
+
+    private Hut getHut(SQLiteDatabase db, long id){
+        Cursor cursor = db.query(TABLE_HUT,
+                new String[]{KEY_POI_ID, KEY_GP_ID, KEY_HUT_TYPE, KEY_HUT_WINTER_ROOM, KEY_HUT_NAME},
+                KEY_POI_ID + "=?",
+                new String[]{String.valueOf(id)}, null, null, null, null);
+        if (cursor != null) {
+            cursor.moveToFirst();
+        }
+        return getHutFromCursor(cursor);
+    }
+
+    public Poi getPoi(long id, int type){
+        SQLiteDatabase db = this.getReadableDatabase();
+
+        switch(type){
+            case Types.FOUNTAIN:
+                return getFountain(db, id);
+            case Types.PATH:
+                return getPath(db, id);
+            case Types.BREAK_POINT:
+                return getBreakpoint(db, id);
+            case Types.TRASH_BIN:
+                return getTrashbin(db, id);
+            case Types.PIC:
+                return getImage(db, id);
+            case Types.CELL_RECEPTION:
+                return getCellReception(db, id);
+            case Types.WIFI:
+                return getWifi(db, id);
+            case Types.LIFT:
+                return getLift(db , id);
+            case Types.PEAK:
+                return getPeak(db, id);
+            case Types.HUT:
+                return getHut(db, id);
+            case Types.GP:
+                return getGeoPoint(id);
+        }
 
         db.close();
-        cursor.close();
-
-        return new Poi(_id, _lat, _lon, _alt, _type, _time, _ext_poi_id);
+        return null;
     }
 
     public List<Poi> getAllPois() {
         List<Poi> poiList = new ArrayList<>();
-        String query = "SELECT * FROM " + TABLE_POI;
+        for(int i=0; i<TABLES.length; ++i){
+            String query = "SELECT * FROM " + TABLES[i];
+            SQLiteDatabase db = this.getReadableDatabase();
+            Cursor cursor = db.rawQuery(query, null);
+            if(cursor.moveToFirst()){
+                do {
+                    poiList.add(getPoiFromCursor(cursor, TABLE_TYPES[i]));
+                } while(cursor.moveToNext());
+            }
+
+            db.close();
+            cursor.close();
+        }
+
+        return poiList;
+    }
+
+    public int getPoiCount(){
         SQLiteDatabase db = this.getReadableDatabase();
+        int count = 0;
+        for(int i=0; i<TABLES.length; ++i){
+            String query = "SELECT * FROM " + TABLES[i];
+            Cursor cursor = db.rawQuery(query, null);
+            count += cursor.getCount();
+            cursor.close();
+        }
+
+        return count;
+    }
+
+    public int updatePoi(long id, int type){
+        SQLiteDatabase db = this.getWritableDatabase();
+        ContentValues values = new ContentValues();
+        String table = "";
+
+        //TODO set values
+
+        return db.update(table, values, KEY_POI_ID + "=?",
+                new String[]{ String.valueOf(id) });
+    }
+
+    //TODO recursive delete
+    public void deletePoi(long _id, int type){
+        SQLiteDatabase db = this.getWritableDatabase();
+        switch (type){
+            case Types.FOUNTAIN:
+                db.delete(TABLE_FOUNTAIN, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.PATH:
+                db.delete(TABLE_PATH, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.BREAK_POINT:
+                db.delete(TABLE_BREAK_POINT, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.TRASH_BIN:
+                db.delete(TABLE_TRASH_BIN, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.PIC:
+                db.delete(TABLE_IMAGE, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.CELL_RECEPTION:
+                db.delete(TABLE_CELL_RECEPTION, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.WIFI:
+                db.delete(TABLE_WIFI, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.LIFT:
+                db.delete(TABLE_LIFT, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.PEAK:
+                db.delete(TABLE_PEAK, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.HUT:
+                db.delete(TABLE_HUT, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+            case Types.GP:
+                db.delete(TABLE_GP, KEY_POI_ID + "=?",
+                        new String[]{String.valueOf(_id)});
+                break;
+        }
+    }
+
+    public List<Poi> getPoiByType(int _type){
+        List<Poi> poiList = new ArrayList<>();
+        SQLiteDatabase db = this.getReadableDatabase();
+
+        String table = getTableName(_type);
+
+        String query = "SELECT * FROM " + table;
         Cursor cursor = db.rawQuery(query, null);
         if(cursor.moveToFirst()){
             do {
-                int _id = Integer.parseInt(cursor.getString(0));
-                double _lat = Double.parseDouble(cursor.getString(1));
-                double _lon = Double.parseDouble(cursor.getString(2));
-                double _alt = Double.parseDouble(cursor.getString(3));
-                int _type = Integer.parseInt(cursor.getString(4));
-                long _time = Long.parseLong(cursor.getString(5)) * 1000;
-                int _ext_poi_id = Integer.parseInt(cursor.getString(6));
-                poiList.add(new Poi(_id, _lat, _lon, _alt, _type, _time, _ext_poi_id));
+                poiList.add(getPoiFromCursor(cursor, _type));
             } while(cursor.moveToNext());
         }
 
@@ -281,59 +650,53 @@
         return poiList;
     }
 
-    public int getPoiCount(){
-        String query = "SELECT * FROM " + TABLE_POI;
+    public int getPoiCountByType(int _type){
         SQLiteDatabase db = this.getReadableDatabase();
+        String query = "SELECT * FROM " + getTableName(_type);
         Cursor cursor = db.rawQuery(query, null);
-
         int count = cursor.getCount();
         cursor.close();
 
         return count;
     }
 
-    public int updatePoi(Poi poi){
-        SQLiteDatabase db = this.getWritableDatabase();
-        ContentValues values = new ContentValues();
-        values.put(KEY_POI_LAT, poi.getLat());
-        values.put(KEY_POI_LON, poi.getLon());
-        values.put(KEY_POI_ALT, poi.getAlt());
-        values.put(KEY_POI_TYPE, poi.getType());
-        values.put(KEY_POI_TIME, poi.getTime());
-        values.put(KEY_POI_EXT_POI_ID, poi.getExtPoiId());
-
-        return db.update(TABLE_POI, values, KEY_POI_ID + "=?",
-                new String[]{ String.valueOf(poi.getId()) });
-    }
-
-    public void deletePoi(Poi poi){
-        SQLiteDatabase db = this.getWritableDatabase();
-        db.delete(TABLE_POI, KEY_POI_ID + "=?",
-                new String[]{String.valueOf(poi.getId())});
-    }
-
-    public List<Poi> getPoiByType(int _type){
-        List<Poi> poiList = new ArrayList<>();
-        SQLiteDatabase db = this.getReadableDatabase();
-        Cursor cursor = db.query(TABLE_POI,
-                new String[]{KEY_POI_ID, KEY_POI_LAT, KEY_POI_LON, KEY_POI_ALT, KEY_POI_TYPE, KEY_POI_TIME, KEY_POI_EXT_POI_ID},
-                KEY_POI_TYPE + "=?",
-                new String[]{String.valueOf(_type)}, null, null, null, null);
-        if(cursor.moveToFirst()){
-            do {
-                int _id = Integer.parseInt(cursor.getString(0));
-                double _lat = Double.parseDouble(cursor.getString(1));
-                double _lon = Double.parseDouble(cursor.getString(2));
-                double _alt = Double.parseDouble(cursor.getString(3));
-                long _time = Long.parseLong(cursor.getString(5)) * 1000;
-                int _ext_poi_id = Integer.parseInt(cursor.getString(6));
-                poiList.add(new Poi(_id, _lat, _lon, _alt, _type, _time, _ext_poi_id));
-            } while(cursor.moveToNext());
+    private String getTableName(int _type){
+        String table = "";
+        switch (_type){
+            case Types.FOUNTAIN:
+                table = TABLE_FOUNTAIN;
+                break;
+            case Types.PATH:
+                table = TABLE_PATH;
+                break;
+            case Types.BREAK_POINT:
+                table = TABLE_BREAK_POINT;
+                break;
+            case Types.TRASH_BIN:
+                table = TABLE_TRASH_BIN;
+                break;
+            case Types.PIC:
+                table = TABLE_IMAGE;
+                break;
+            case Types.CELL_RECEPTION:
+                table = TABLE_CELL_RECEPTION;
+                break;
+            case Types.WIFI:
+                table = TABLE_WIFI;
+                break;
+            case Types.LIFT:
+                table = TABLE_LIFT;
+                break;
+            case Types.PEAK:
+                table = TABLE_PEAK;
+                break;
+            case Types.HUT:
+                table = TABLE_HUT;
+                break;
+            case Types.GP:
+                table = TABLE_GP;
+                break;
         }
-
-        db.close();
-        cursor.close();
-
-        return poiList;
+        return table;
     }
 }
diff --git a/app/src/main/java/de/apps4ics/mountainnavigation/Poi.java b/app/src/main/java/de/apps4ics/mountainnavigation/Poi.java
index a4b2048..f45c5ec 100644
--- a/app/src/main/java/de/apps4ics/mountainnavigation/Poi.java
+++ b/app/src/main/java/de/apps4ics/mountainnavigation/Poi.java
@@ -1,13 +1,16 @@
 package de.apps4ics.mountainnavigation;
 
-import org.osmdroid.util.GeoPoint;
-
 /**
  * Created by Vinz on 06.10.2015.
  */
 public class Poi {
-    private int _id;
-    private int _type;
+    protected long _id;
+    protected int _type;
+    protected DbGeoPoint gp;
+    protected long gpId;
+
+    public Poi() {
+    }
 
     @Override
     public boolean equals(Object o) {
@@ -23,21 +26,35 @@
 
     @Override
     public int hashCode() {
-        int result = _id;
+        int result = (int) _id;
         result = 31 * result + _type;
         return result;
     }
 
+    public long getGpId(){
+        return gpId;
+    }
+
+    public DbGeoPoint getGp(){
+        return gp;
+    }
+
     public Poi(int _type){
         this._type = _type;
     }
 
-    public Poi(int _id, int _type){
+    public Poi(long _id, int _type){
         this._id = _id;
         this._type = _type;
     }
 
-    public int getId(){
+    public Poi(long _id, int _type, DbGeoPoint _gp){
+        this(_id, _type);
+        this.gp = _gp;
+        this.gpId = _gp.getId();
+    }
+
+    public long getId(){
         return _id;
     }
 
@@ -56,17 +73,17 @@
 }
 
 class Fountain extends Poi {
-    long gp_id;
     int size;
-    public Fountain(int _id){
+    DbGeoPoint gp;
+    public Fountain(long _id){
         super(_id, Types.FOUNTAIN);
     }
     public Fountain(){
         super(Types.FOUNTAIN);
     }
-
-    public long getGpId(){
-        return gp_id;
+    public Fountain(long _id, int size, DbGeoPoint gp){
+        super(_id, Types.FOUNTAIN, gp);
+        this.size = size;
     }
 
     public int getSize(){
@@ -77,22 +94,33 @@
 //TODO constructors for other classes, see fountain
 
 class Path extends Poi {
-    long gp_s_id;
     long gp_e_id;
     long length;
     int exposed;
     int diffWet;
     int giddiness;
     int climbing;
-    public Path(int _id) {
+    DbGeoPoint end;
+
+    public Path(long _id) {
         super(_id, Types.PATH);
     }
     public Path() {
         super(Types.PATH);
     }
+    public Path(long _id, long _length, int exposed, int diff_wet, int giddiness, int climbing, DbGeoPoint start, DbGeoPoint end){
+        super(_id, Types.PATH, start);
+        this.length = _length;
+        this.exposed = exposed;
+        this.diffWet = diff_wet;
+        this.giddiness = giddiness;
+        this.climbing = climbing;
+        this.end = end;
+        this.gp_e_id = end.getId();
+    }
 
     public long getStartGp() {
-        return gp_s_id;
+        return gpId;
     }
 
     public long getEndGp() {
@@ -121,41 +149,73 @@
 }
 
 class Hut extends Poi {
+    int huttype;
+    int winterroom;
+    String name;
 
-    public Hut(int _id) {
+    public Hut(long _id) {
         super(_id, Types.HUT);
     }
     public Hut(){
         super(Types.HUT);
     }
+    public Hut(long _id, int hut_type, int winterroom, String name, DbGeoPoint gp){
+        super(_id, Types.HUT, gp);
+        this.huttype = hut_type;
+        this.winterroom = winterroom;
+        this.name = name;
+    }
+
+    public int getHutType() {
+        return huttype;
+    }
+
+    public int getWinterRoom() {
+        return winterroom;
+    }
+
+    public String getName() {
+        return name;
+    }
 }
 
 class Peak extends Poi {
+    String name;
 
-    public Peak(int _id) {
+    public Peak(long _id) {
         super(_id, Types.PEAK);
     }
     public Peak(){
         super(Types.PEAK);
     }
+    public Peak(long _id, String name, DbGeoPoint gp){
+        super(_id, Types.PEAK, gp);
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
 }
 
 class BreakPoint extends Poi {
-    long gpId;
     int stone;
     int bench;
     int table;
     int roofed;
 
-    public BreakPoint(int _id) {
+    public BreakPoint(long _id) {
         super(_id, Types.BREAK_POINT);
     }
     public BreakPoint(){
         super(Types.BREAK_POINT);
     }
-
-    public long getGpId() {
-        return gpId;
+    public BreakPoint(long _id, int stone, int bench, int table, int roofed, DbGeoPoint gp){
+        super(_id, Types.BREAK_POINT, gp);
+        this.stone = stone;
+        this.bench = bench;
+        this.table = table;
+        this.roofed = roofed;
     }
 
     public int getStone() {
@@ -176,34 +236,31 @@
 }
 
 class TrashBin extends Poi {
-    long gpId;
-
-    public TrashBin(int _id) {
+    public TrashBin(long _id) {
         super(_id, Types.TRASH_BIN);
     }
     public TrashBin(){
         super(Types.TRASH_BIN);
     }
-
-    public long getGpId(){
-        return gpId;
+    public TrashBin(long id, DbGeoPoint gp){
+        super(id, Types.TRASH_BIN, gp);
     }
 }
 
 class Image extends Poi {
-    long gpId;
     String typeId;
     byte[] image;
 
-    public Image(int _id) {
+    public Image(long _id) {
         super(_id, Types.PIC);
     }
     public Image(){
         super(Types.PIC);
     }
-
-    public long getGpId(){
-        return gpId;
+    public Image(long _id, String typeId, byte[] image, DbGeoPoint gp){
+        super(_id, Types.PIC, gp);
+        this.typeId = typeId;
+        this.image = image;
     }
 
     public String getTypeId(){
@@ -216,43 +273,112 @@
 }
 
 class CellReception extends Poi {
+    int strength;
+    String opName;
+    String opCountry;
+    int roaming;
+    String nwType;
 
-    public CellReception(int _id) {
+    public CellReception(long _id) {
         super(_id, Types.CELL_RECEPTION);
     }
     public CellReception(){
         super(Types.CELL_RECEPTION);
     }
+    public CellReception(long _id, int strength, String opName, String opCountry, int roaming, String nwType, DbGeoPoint gp){
+        super(_id, Types.CELL_RECEPTION, gp);
+        this.strength = strength;
+        this.opName = opName;
+        this.opCountry = opCountry;
+        this.roaming = roaming;
+        this.nwType = nwType;
+    }
+
+    public int getStrength() {
+        return strength;
+    }
+
+    public String getOpName() {
+        return opName;
+    }
+
+    public String getOpCountry() {
+        return opCountry;
+    }
+
+    public int getRoaming() {
+        return roaming;
+    }
+
+    public String getNwType() {
+        return nwType;
+    }
 }
 
 class Wifi extends Poi {
+    String ssid;
+    int levels;
 
-    public Wifi(int _id) {
+    public Wifi(long _id) {
         super(_id, Types.WIFI);
     }
     public Wifi(){
         super(Types.WIFI);
     }
+    public Wifi(long _id, String ssid, int levels, DbGeoPoint gp){
+        super(_id, Types.WIFI, gp);
+        this.ssid = ssid;
+        this.levels = levels;
+    }
+
+    public String getSsid() {
+        return ssid;
+    }
+
+    public int getLevels() {
+        return levels;
+    }
 }
 
 class Lift extends Poi {
-    public Lift(int _id) {
+    DbGeoPoint end;
+    long endGpId;
+    String name;
+
+    public Lift(long _id) {
         super(_id, Types.LIFT);
     }
     public Lift(){
         super(Types.LIFT);
     }
+    public Lift(long _id, String name, DbGeoPoint start, DbGeoPoint end){
+        super(_id, Types.LIFT, start);
+        this.name = name;
+        this.end = end;
+        this.endGpId = end.getId();
+    }
+
+    public long getStartGpId() {
+        return gpId;
+    }
+
+    public long getEndGpId() {
+        return endGpId;
+    }
+
+    public String getName() {
+        return name;
+    }
 }
 
 class DbGeoPoint extends Poi {
     private double lat;
     private double lon;
     private double alt;
-    private long _id;
     private long _time;
     private String _type_id; //<poi-type>_<poi-id-in-table> => hut_2
 
-    public DbGeoPoint(int _id) {
+    public DbGeoPoint(long _id) {
         super(_id, Types.GP);
     }
     public DbGeoPoint(){
@@ -270,6 +396,15 @@
         this._time = _time;
     }
 
+    public DbGeoPoint(long id, double lat, double lon, double alt, long time, String type_id){
+        this._id = id;
+        this.lat = lat;
+        this.lon = lon;
+        this.alt = alt;
+        this._time = time;
+        this._type_id = type_id;
+    }
+
     public double getLat(){
         return lat;
     }