Get data from SQLite and Show to Mixare (Augmented Reality)?

My code was working, but I have simple case and I don't have any reference to how get all Data from SQLite include Name, Latitude, Longitude to show marker on Mixare Augmented Reality, when I'm press btn_AR

DBHeper.java

       String CREATE_TABLE_PARKIRLUAR = "CREATE TABLE " + ParkirLuar.TABLE + "("
            + ParkirLuar.KEY_ID + " INTEGER PRIMARY KEY AUTOINCREMENT ,"
            + ParkirLuar.KEY_Latitude + " TEXT, "
            + ParkirLuar.KEY_Longitude + " TEXT, "
            + ParkirLuar.KEY_Nama + " TEXT ) ";

DBLokasi.Java

import java.io.Serializable;

public class DBLokasi implements Serializable{

    /**
     *
     */
    private static final long serialVersionUID = -151607691806704480L;
    private long id;
    private String lat;
    private String lng;
    private String nama;
    private double latD;
    private double lngD;

    public DBLokasi()
    {

    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    // Will be used by the ArrayAdapter in the ListView
    public String toString() {
        return "("+id+")"+" Nama : "+nama+" "+" ("+lat+" , "+lng+")";
    }

    public String getLat() {
        return lat;
    }

    public void setLat(String lat) {
        this.lat = lat;
    }

    public String getLng() {
        return lng;
    }

    public void setLng(String lng) {
        this.lng = lng;
    }

    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }

    public String getNama() {
        return nama;
    }

    public void setNama(String nama) {
        this.nama = nama;
    }

    public double getLatD() {
        latD = Double.parseDouble(lat);
        return latD;
    }

    public void setLatD(double latD) {
        this.latD = latD;
    }

    public double getLngD() {
        lngD = Double.parseDouble(lng);
        return lngD;
    }

    public void setLngD(double lngD) {
        this.lngD = lngD;
    }
}

UnivDataSource.Java

    import java.util.ArrayList;
import java.util.List;

import com.R;
import com.AR.UI.IconMarker;
import com.AR.UI.Marker;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;


public class UnivDataSource extends DataSource{
    private final List<Marker> cachedMarkers = new ArrayList<Marker>();

    private static Bitmap iconuniv = null;

    public UnivDataSource(Resources res) {
        if (res==null) throw new NullPointerException();

        createIcon(res);
    }

    protected void createIcon(Resources res) {
        if (res==null) throw new NullPointerException();

        iconuniv=BitmapFactory.decodeResource(res, R.drawable.univ);
    }
    //-7.128792, 112.723803
    public List<Marker> getMarkers() {


        Marker wis1 = new IconMarker("Situs Pangeran Ronggosukowati", -7.15319, 113.48497, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis2);

        Marker wis2 = new IconMarker("Makam Keramat Pasarean Batu Ampar", -7.09854, 113.37629, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis3);

        Marker wis3 = new IconMarker("Pantai Talang Siring", -7.13791, 113.58967, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis4);

        Marker wis4 = new IconMarker("Vihara Alokitesvara", -7.1471, 113.58149, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis5);

        Marker wis5 = new IconMarker("Pemandian Sumber Mata Air", -7.12397, 113.60601, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis6);

        Marker wis6 = new IconMarker("Api Tak Kunjung Padam", -7.205, 113.46106, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis7);

        Marker wis7 = new IconMarker("Pemandian Anjungan", -7.1821, 113.49285, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis8);

        Marker wis8 = new IconMarker("Pantai Jumiang", -7.23532, 113.54043, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis9);

        return cachedMarkers;
    }
}

So I'm just have to change this code to get All data from SQLite, and I have Variable getNama, getLatD, getLngD..

  Marker wis1 = new IconMarker("Situs Pangeran Ronggosukowati", -7.15319, 113.48497, 0, Color.BLUE, iconuniv);
        cachedMarkers.add(wis2);

and this is Activity to Show data from Mixare

UnivARAllActivity.java

import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import android.content.Intent;
import android.location.Location;
import android.os.Bundle;
import android.util.Log;

import com.AR.AugmentedActivity;
import com.AR.DataAR;
import com.AR.Data.NetworkDataSource;
import com.AR.Data.UnivDataSource;
import com.AR.UI.Marker;
import com.AR.Monitor.KantorPusat;
import com.bagi.Univ;


public class UnivARActivity extends AugmentedActivity {
    private static final String TAG = "WisataARActivity";
    private static final String locale = "en";
    private static final BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(1);
    private static final ThreadPoolExecutor exeService = new ThreadPoolExecutor(1, 1, 20, TimeUnit.SECONDS, queue);
    private static final Map<String,NetworkDataSource> sources = new ConcurrentHashMap<String,NetworkDataSource>();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        UnivDataSource apDataSource = new UnivDataSource(this.getResources());
        DataAR.addMarkers(apDataSource.getMarkers());
    }

    @Override
    public void onStart() {
        super.onStart();

        Location last = DataAR.getCurrentLocation();
        updateData(last.getLatitude(),last.getLongitude(),last.getAltitude());
    }

    /*@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menu, menu);
        return true;
    }*/

   /* @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        Log.v(TAG, "onOptionsItemSelected() item="+item);
        switch (item.getItemId()) {
            case R.id.showRadar:
                showRadar = !showRadar;
                item.setTitle(((showRadar)? "Hide" : "Show")+" Radar");
                break;
            case R.id.showZoomBar:
                showZoomBar = !showZoomBar;
                item.setTitle(((showZoomBar)? "Hide" : "Show")+" Zoom Bar");
                zoomLayout.setVisibility((showZoomBar)?LinearLayout.VISIBLE:LinearLayout.GONE);
                break;
            case R.id.exit:
                finish();
                break;
        }
        return true;
    }*/

    @Override
    public void onLocationChanged(Location location) {
        super.onLocationChanged(location);

        updateData(location.getLatitude(),location.getLongitude(),location.getAltitude());
    }

    @Override
    protected void markerTouched(Marker marker) {
        if("Monumen Are' Lancor".equals(marker.getName())){
            startActivity(new Intent(UnivARActivity.this, Univ.class));
        }else if("coba".equals(marker.getName())){
            startActivity(new Intent(UnivARActivity.this, null));
        }
    }

    @Override
    protected void updateDataOnZoom() {
        super.updateDataOnZoom();
        Location last = DataAR.getCurrentLocation();
        updateData(last.getLatitude(),last.getLongitude(),last.getAltitude());
    }

    private void updateData(final double lat, final double lon, final double alt) {
        try {
            exeService.execute(
                    new Runnable() {

                        public void run() {
                            for (NetworkDataSource source : sources.values())
                                download(source, lat, lon, alt);
                        }
                    }
            );
        } catch (RejectedExecutionException rej) {
            Log.w(TAG, "Not running new download Runnable, queue is full.");
        } catch (Exception e) {
            Log.e(TAG, "Exception running download Runnable.",e);
        }
    }

    private static boolean download(NetworkDataSource source, double lat, double lon, double alt) {
        if (source==null) return false;

        String url = null;
        try {
            url = source.createRequestURL(lat, lon, alt, DataAR.getRadius(), locale);
        } catch (NullPointerException e) {
            return false;
        }

        List<Marker> markers = null;
        try {
            markers = source.parse(url);
        } catch (NullPointerException e) {
            return false;
        }

        DataAR.addMarkers(markers);
        return true;
    }
}

DataAR.Java

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;

import com.AR.UI.Marker;

import android.location.Location;
import android.util.Log;

// Mengakses AR Data

    public abstract class DataAR {
        private static final String TAG = "ARData";
        private static final Map<String,Marker> markerList = new ConcurrentHashMap<String,Marker>();
        private static final List<Marker> cache = new CopyOnWriteArrayList<Marker>();
        private static final AtomicBoolean dirty = new AtomicBoolean(false);
        private static final float[] locationArray = new float[3];

        public static final Location posBaru = new Location("Posisi Baru");
        static {
            posBaru.setLatitude(0);
            posBaru.setLongitude(0);
            posBaru.setAltitude(1);
        }

        private static final Object radiusLock = new Object();
        private static float radius = new Float(20);
        private static String zoomLevel = new String();
        private static final Object zoomProgressLock = new Object();
        private static int zoomProgress = 0;
        private static Location currentLocation = posBaru;
        private static Matrix rotationMatrix = new Matrix();
        private static final Object azimuthLock = new Object();
        private static float azimuth = 0;
        private static final Object pitchLock = new Object();
        private static float pitch = 0;
        private static final Object rollLock = new Object();
        private static float roll = 0;

        public static void setZoomLevel(String zoomLevel) {
            if (zoomLevel==null) throw new NullPointerException();

            synchronized (DataAR.zoomLevel) {
                DataAR.zoomLevel = zoomLevel;
            }
        }

        public static void setZoomProgress(int zoomProgress) {
            synchronized (DataAR.zoomProgressLock) {
                if (DataAR.zoomProgress != zoomProgress) {
                    DataAR.zoomProgress = zoomProgress;
                    if (dirty.compareAndSet(false, true)) {
                        Log.v(TAG, "Perubahan Zoom Bar Dilakukan !");
                        cache.clear();
                    }
                }
            }
        }

        public static void setRadius(float radius) {
            synchronized (DataAR.radiusLock) {
                DataAR.radius = radius;
            }
        }

        public static float getRadius() {
            synchronized (DataAR.radiusLock) {
                return DataAR.radius;
            }
        }

        public static void setCurrentLocation(Location currentLocation) {
            if (currentLocation==null) throw new NullPointerException();

            Log.d(TAG, "current location. location="+currentLocation.toString());
            synchronized (currentLocation) {
                DataAR.currentLocation = currentLocation;
            }
            onLocationChanged(currentLocation);
        }

        public static Location getCurrentLocation() {
            synchronized (DataAR.currentLocation) {
                return DataAR.currentLocation;
            }
        }

        public static void setRotationMatrix(Matrix rotationMatrix) {
            synchronized (DataAR.rotationMatrix) {
                DataAR.rotationMatrix = rotationMatrix;
            }
        }

        public static Matrix getRotationMatrix() {
            synchronized (DataAR.rotationMatrix) {
                return rotationMatrix;
            }
        }

        public static List<Marker> getMarkers() {
            if (dirty.compareAndSet(true, false)) {
                Log.v(TAG, "Perubahan zoom dilakukan, reset seluruh marker ke menjadi nol");
                for(Marker ma : markerList.values()) {
                    ma.getLocation().get(locationArray);
                    locationArray[1]=ma.getInitialY();
                    ma.getLocation().set(locationArray);
                }

                Log.v(TAG, "Cache ke-");
                List<Marker> copy = new ArrayList<Marker>();
                copy.addAll(markerList.values());
                Collections.sort(copy,comparator);
                cache.clear();
                cache.addAll(copy);
            }
            return Collections.unmodifiableList(cache);
        }

        public static void setAzimuth(float azimuth) {
            synchronized (azimuthLock) {
                DataAR.azimuth = azimuth;
            }
        }

        public static float getAzimuth() {
            synchronized (azimuthLock) {
                return DataAR.azimuth;
            }
        }

        public static void setPitch(float pitch) {
            synchronized (pitchLock) {
                DataAR.pitch = pitch;
            }
        }

        public static float getPitch() {
            synchronized (pitchLock) {
                return DataAR.pitch;
            }
        }

        public static void setRoll(float roll) {
            synchronized (rollLock) {
                DataAR.roll = roll;
            }
        }

        public static float getRoll() {
            synchronized (rollLock) {
                return DataAR.roll;
            }
        }

        private static final Comparator<Marker> comparator = new Comparator<Marker>() {
            public int compare(Marker arg0, Marker arg1) {
                return Double.compare(arg0.getDistance(),arg1.getDistance());
            }
        };


        // Method Memasukkan marker
        public static void addMarkers(Collection<Marker> markers) {
            if (markers==null) throw new NullPointerException();

            if (markers.size()<=0) return;

            Log.d(TAG, "Markers Baru, Update Markers. Markers Baru="+markers.toString());
            for(Marker marker : markers) {
                if (!markerList.containsKey(marker.getName())) {
                    marker.calcRelativePosition(DataAR.getCurrentLocation());
                    markerList.put(marker.getName(),marker);
                }
            }

            if (dirty.compareAndSet(false, true)) {
                Log.v(TAG, "Setting DIRTY flag!");
                cache.clear();
            }
        }

        private static void onLocationChanged(Location location) {
            Log.d(TAG, "Lokasi Baru, Update Markers. Lokasi="+location.toString());
            for(Marker ma: markerList.values()) {
                ma.calcRelativePosition(location);
            }

            if (dirty.compareAndSet(false, true)) {
                Log.v(TAG, "Pengaturan dilakukan!");
                cache.clear();
            }
        }
    }