// 해쉬 키값 구하기.
try{
  PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_SIGNATURES);
    for (Signature signature : info.signatures) {
      MessageDigest md;
      md = MessageDigest.getInstance("SHA");
      md.update(signature.toByteArray());
      String key = new String(Base64.encode(md.digest(), 0));
      Log.d("Hash key:", "!!!!!!!"+key+"!!!!!!");
        }
    } catch (Exception e){
      Log.e("name not found", e.toString());
}

package app.cap.ajm.api;
//item 클래스
public class Item {
  public String place_name;
  public String place_url;
  public String address_name;
  public String road_address_name;
  public String phone;
  public double x;
  public double y;
  public double distance;
  public String category_group_name;
  public String category_group_code;
  public String id;
  public String placeUrl;
}

package app.cap.ajm.api;
//MapApiConst 클래스
public class MapApiConst {
    public static final String DAUM_MAPS_ANDROID_APP_API_KEY = "발급받은 키";
}

package app.cap.ajm.api;

import java.util.List;
//OnFinishSearchListener 인터페이스
public interface OnFinishSearchListener {
	public void onSuccess(List<Item> itemList);
	public void onFail();
}

package app.cap.ajm.api;;

import java.net.*;
import java.util.*;
import org.json.JSONArray;
import org.json.JSONObject;
//......중략

//Searcher 클래스
public class Searcher {
  //API 콜백 URL
  public static final String LOCAL_KEYWORD_SEARCH_API_FORMAT = "https://dapi.kakao.com/v2/local/search/keyword.json?query=%s&y=%s&x=%s&radius=%d&page=%d&apikey=%s";

//......중략

public void searchKeyword(Context applicationContext, String query, double latitude, double longitude, int radius, int page, String apikey, OnFinishSearchListener onFinishSearchListener) {
  this.onFinishSearchListener = onFinishSearchListener;
  if (searchTask != null) {
    searchTask.cancel(true);
    searchTask = null;
  }
  String url = buildKeywordSearchApiUrlString(query, latitude, longitude, radius, page, apikey);
  searchTask = new SearchTask();
  searchTask.execute(url);
}
//UTF-8로 키워드 인코딩 필요.
private String buildKeywordSearchApiUrlString(String query, double latitude, double longitude, int radius, int page, String apikey) {
  String encodedQuery = "";
  try {
    encodedQuery = URLEncoder.encode(query, "utf-8");
  } catch (UnsupportedEncodingException e) {
    e.printStackTrace();
  }
  return String.format(Locale.ENGLISH, LOCAL_KEYWORD_SEARCH_API_FORMAT, encodedQuery, latitude, longitude, radius, page, apikey);
}

//API 호출을 위한 메서드
private String fetchData(String urlString, Map<String, String> header) {
  try {
    URL url = new URL(urlString);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setReadTimeout(4000 /* milliseconds */);
    conn.setConnectTimeout(7000 /* milliseconds */);
    conn.setRequestMethod("GET"); // GET 방식으로  API 요청
    con.setRequestProperty("Authorization", "KakaoAK "+MapApiConst.DAUM_MAPS_ANDROID_APP_API_KEY); // header 부분에 앱키 작성
    conn.setDoInput(true);
    conn.connect();

    InputStream is = conn.getInputStream();
    @SuppressWarnings("resource")
    Scanner s = new Scanner(is);
    s.useDelimiter("\\A");
    String data = s.hasNext() ? s.next() : "";

    Log.w("data : ", data);

    return data;
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  //JSON 파싱용 메서드
private List<Item> parse(String jsonString) {
  List<Item> itemList = new ArrayList<Item>();
  try {
    JSONObject reader = new JSONObject(jsonString);
    JSONArray objects = reader.getJSONArray("documents");
    for (int i = 0; i < objects.length(); i++) {
      JSONObject object = objects.getJSONObject(i);
      //item 클래스에 json 데이터 할당.
      Item item = new Item();
      item.place_name = object.getString("place_name");
      //...중략
    }
  } catch (Exception e) {
    e.printStackTrace();  
    return null;
  }
  return itemList;  
}
}

package app.cap.ajm.activity;

import net.daum.mf.map.api.*;
//...중략
public class SearchActivity extends FragmentActivity implements
MapView.MapViewEventListener,
MapView.POIItemEventListener{
//지도를 컨트롤 하기 위한 인스턴스.
private MapView mMapView;
//결과 CalloutBallon에 대한 값을 저장하기 위한 해쉬 맵 객체.
private HashMap<Integer, Item> mTagItemMap = new HashMap<Integer, Item>();
//...중략
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.search);
    //각종 리스너 등록.
    mMapView = (MapView)findViewById(R.id.map_view);
    mMapView.setMapViewEventListener(this);
    mMapView.setPOIItemEventListener(this);
    mMapView.setCalloutBalloonAdapter(new CustomCalloutBalloonAdapter());

    //...중략
    try {
    String query = mEditTextQuery.getText().toString();
    int radius = 10000; // 중심 좌표부터의 반경거리. 특정 지역을 중심으로 검색하려고 할 경우 사용. meter 단위 (0 ~ 10000)
    int page = 1; // 페이지 번호 (1 ~ 3). 한페이지에 15개
    GeoCoordinate geoCoordinate = mMapView.getMapCenterPoint().getMapPointGeoCoord(); //좌표 정보 지오코딩.
    double latitude = geoCoordinate.latitude; // 위도
    double longitude = geoCoordinate.longitude; // 경도
    String apikey = MapApiConst.DAUM_MAPS_ANDROID_APP_API_KEY;
    Searcher searcher = new Searcher(); // Searcher
    Toast.makeText(getApplicationContext(), String.format(getString(R.string.search_10km), query),Toast.LENGTH_SHORT).show();
    searcher.searchKeyword(getApplicationContext(), query, latitude, longitude, radius, page, apikey, new OnFinishSearchListener() {
          @Override
          public void onSuccess(List<Item> itemList) {
          mMapView.removeAllPOIItems(); // 기존 검색 결과 삭제.
          showResult(itemList); // 검색 결과 보여줌.
          @Override
          public void onFail(){
          Log.w("오류: ","오류");
            }
          });
        }catch (Exception e){
          e.printStackTrace();
        }
    }
  }

//다음 지도를 그려주기 위한 초기화 작업 구현.
  @Override
  public void onMapViewInitialized(MapView mapView) {
    ActivityCompat.requestPermissions(this, new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION}, 1);
    mapView.setCurrentLocationTrackingMode(MapView.CurrentLocationTrackingMode.TrackingModeOnWithHeading);
  }
//...중략
  private void showResult(List<Item> itemList) 	{
    //화면에 보여질 영역 설정을 위한 객체.
    MapPointBounds mapPointBounds = new MapPointBounds();
    //검색 api를 통해 호출받은 List의 크기만큼 반복.
    for (int i = 0; i < itemList.size(); i++) {
      //마커와 CalloutBallon을 설정하기 위한 옵션들.
      Item item = itemList.get(i);
      MapPOIItem poiItem = new MapPOIItem();
      poiItem.setTag(i);
      //길 찾기 기능 설정을 위해 해당 POI(관심지점) 객체에 mapPoint(경위도 좌표 값)를 등록.
      MapPoint mapPoint = MapPoint.mapPointWithGeoCoord(item.latitude, item.longitude);
      poiItem.setMapPoint(mapPoint);
      //...중략
      mMapView.addPOIItem(poiItem);
      mTagItemMap.put(poiItem.getTag(), item);
  }
  //화면 이동.
  mMapView.moveCamera(CameraUpdateFactory.newMapPointBounds(mapPointBounds));
  //트랙킹모드 실행.
  mMapView.setCurrentLocationTrackingMode(MapView.CurrentLocationTrackingMode.TrackingModeOnWithoutHeadingWithoutMapMoving);
  MapPOIItem[] poiItems = mMapView.getPOIItems();
    if (poiItems.length > 0) {
        mMapView.selectPOIItem(poiItems[0], false);
    }
  }
//...중략
}

import com.kakao.kakaonavi.*;
import net.daum.mf.map.api.*;
//...중략
private HashMap<Integer, Item> mTagItemMap = new HashMap<Integer, Item>();
//...중략
@Override
  public void onCalloutBalloonOfPOIItemTouched(MapView mapView, MapPOIItem mapPOIItem, MapPOIItem.CalloutBalloonButtonType calloutBalloonButtonType) {
    //클릭한 Balloon의 정보를 가져온다. mTagItemMap 해쉬 맵 객체의 태그를 이용해 가져온다.
    Item item = mTagItemMap.get(mapPOIItem.getTag());
    //도착지 정보를 파라미터로 넘겨준다.
    navigationDialog(item.newAddress, item.latitude, item.longitude);
  }

  private void navigationDialog(final String des, final Double lat, final Double lon){
    android.app.AlertDialog.Builder alertDialog = new android.app.AlertDialog.Builder(SearchActivity.this);
    alertDialog.setTitle(getString(R.string.direction));
    alertDialog.setMessage(getString(R.string.set_map_loc_ok));
    alertDialog.setPositiveButton(getString(R.string.start), new DialogInterface.OnClickListener() {
      public void onClick(DialogInterface dialog,int which) {
        try {
          //카카오 내비가 설치 되어 있는지 확인.
        if(KakaoNaviService.isKakaoNaviInstalled(getApplicationContext())) {
          //카카오 내비가 설치 되어 있다면 KakaoNaviParams 빌더를 통해 도착지 정보와 출발지 정보를 넘겨준다.
          com.kakao.kakaonavi.Location kakao = Destination.newBuilder(des, lon, lat).build();
          KakaoNaviParams params = KakaoNaviParams.newBuilder(kakao)
          .setNaviOptions(NaviOptions.newBuilder()
          .setCoordType(CoordType.WGS84) // WGS84로 설정해야 경위도 좌표 사용 가능.
          .setRpOption(RpOption.NO_AUTO)
          .setStartAngle(200) //시작 앵글 크기 설정.
          .setVehicleType(VehicleType.TWO_WHEEL).build()).build(); //길 안내 차종 타입 설정
          //카카오 내비앱 실행.
          KakaoNaviService.navigate(SearchActivity.this, params);
        }else {
          //카카오 내비가 설치되어 있지 않다면, 카카오 내비의 설치를 요청한다.
          Intent intent = new Intent(Intent.ACTION_VIEW,
          Uri.parse("https://play.google.com/store/apps/details?id=com.locnall.KimGiSa"));
          startActivity(intent);
          Toast.makeText(getApplicationContext(), getString(R.string.navi_install),Toast.LENGTH_LONG).show();
        }
      }catch (Exception e){
        e.printStackTrace();
        Toast.makeText(getApplicationContext(),e.toString()+getString(R.string.error_default),Toast.LENGTH_LONG).show();
      }
    }
  });
  alertDialog.setNegativeButton(getString(R.string.close), new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int which) {
      dialog.cancel();
    }
  });
  alertDialog.show();
}
//...중략

public class TrackAdapter extends CursorAdapter{

    private Context mContext;
    private int startAddr;
    private int endAddr;
    private int startTime;
    private int endTime;
    private int avgSpeed;
    private int calorie;
    private int distance;
    private int temps;
    private int wets;

    public TrackAdapter(Context context, Cursor cursor){
        super(context, cursor, 0);
        mContext = context;
        startAddr = cursor.getColumnIndex("startAddr");
        endAddr = cursor.getColumnIndex("endAddr");
        startTime = cursor.getColumnIndex("startTime");
        endTime = cursor.getColumnIndex("endTime");
        avgSpeed = cursor.getColumnIndex("avgSpeed");
        calorie = cursor.getColumnIndex("calorie");
        distance = cursor.getColumnIndex("distance");
        temps = cursor.getColumnIndex("temp");
        wets = cursor.getColumnIndex("wet");
    }
    //newView 메서드를 오버라이딩 해서 원하는 커스텀 레이아웃을 구현한다.
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent){
        return LayoutInflater.from(context).inflate(R.layout.custom_listview, parent, false);
    }
    //bindView 메서드를 오버라이딩해서 DB에 저장된 데이터를 원하는 포멧에 맞게 출력한다.
    @Override
    public void bindView(final View view, final Context context, final Cursor cursor){
        //포멧팅을 통해 원하는 포멧으로 출력한다. 포멧팅을 설정하지 않으면, 출력 값을 표현할 때 소숫점이 굉장히 길어지는 현상?을 마주 할 수 있다.
        DecimalFormat decimalFormat = new DecimalFormat("#.###");
        //DB에서 값을 읽어오기
        final String sttime = cursor.getString(startTime);
        final String endtime = cursor.getString(endTime);
        final String stAddr = cursor.getString(startAddr);
        final String edAddr = cursor.getString(endAddr);
        double speed = cursor.getDouble(avgSpeed);
        double dis = cursor.getDouble(distance);
        double cal = cursor.getDouble(calorie);
        double temp = cursor.getDouble(temps);
        double wet = cursor.getDouble(wets);
        //레이아웃 구성에 맞게 TextView와 매칭한다.
        TextView stTime = (TextView) view.findViewById(R.id.startTime);
        TextView edTime = (TextView) view.findViewById(R.id.endTime);
        TextView startA = (TextView) view.findViewById(R.id.startAddr);
        TextView endA = (TextView) view.findViewById(R.id.endAddr);
        TextView avgsp = (TextView) view.findViewById(R.id.Avg);
        TextView distanceView = (TextView) view.findViewById(R.id.Distance);
        TextView calorieView = (TextView) view.findViewById(R.id.Calorie);
        TextView tempView = (TextView) view.findViewById(R.id.Temp);
        TextView wetView = (TextView) view.findViewById(R.id.Wet);

        //출력 폼 설정 코드 작성.
                stTime.setText(sttime);
                edTime.setText(endtime);
                startA.setText(stAddr);
                endA.setText(edAddr);
                avgsp.setText(String.valueOf(decimalFormat.format(speed))+"km/h");
            if (cal/1000f<1) {
                calorieView.setText(String.valueOf(decimalFormat.format(cal))+"cal");
            }else {
                calorieView.setText(String.valueOf(decimalFormat.format(cal/1000f))+"kcal");
            }
            if (dis/1000f<1) {
                distanceView.setText(String.valueOf(decimalFormat.format(dis))+"m");
            }else{
                distanceView.setText(String.valueOf(decimalFormat.format(dis/1000f))+"km");
            }
                tempView.setText(String.valueOf(decimalFormat.format(temp))+"°C");
                wetView.setText(String.valueOf(decimalFormat.format(wet))+"%");
    }
}

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.*;
//...중략
public class TrackDBhelper{
  private static final String TAG ="TrackDBhelper";
    //DB에 저장될 컬럼 구성.
      public static final String KEY_ROWID = "_id";
      public static final String KEY_START_ADDR = "startAddr";
      public static final String KEY_END_ADDR = "endAddr";
      public static final String KEY_START_TIME = "startTime";
      public static final String KEY_END_TIME = "endTime";
      public static final String KEY_AVG_SPEED = "avgSpeed";
      public static final String KEY_CALORIE = "calorie";
      public static final String KEY_DISTANCE = "distance";
      public static final String KEY_TEMP = "temp";
      public static final String KEY_WET = "wet";
      public static final String KEY_RUNNING_TIME = "runtime";
      public static final String KEY_COORDINATE_X = "_x";
      public static final String KEY_COORDINATE_Y = "_y";

      private DatabaseHelper mDbHelper;
      private SQLiteDatabase mDb;

      private static final String DATABASE_NAME = "trackdb";
      private static final String DATABASE_TABLE = "track";
      private static final String DATABASE_TABLE_MAP = "map";
      private static final int DATABASE_VERSION = 1;
      //커스텀 레이아웃에 출력할 정보를 저장할 컬럼 구성.
      private static final String DATABASE_CREATE =
              "CREATE TABLE "+ DATABASE_TABLE +" ("
                      +KEY_ROWID+" INTEGER PRIMARY KEY AUTOINCREMENT, "
                      +KEY_START_ADDR+" TEXT,"
                      +KEY_START_TIME+" TEXT,"
                      +KEY_END_ADDR+" TEXT,"
                      +KEY_END_TIME+" TEXT,"
                      +KEY_AVG_SPEED+" TEXT,"
                      +KEY_CALORIE+ " REAL,"
                      +KEY_DISTANCE+" REAL,"
                      +KEY_TEMP+" TEXT,"
                      +KEY_WET+" TEXT"+ ");";

      //지도에 출력할 위치 정보를 저장할 컬럼 구성.
      private static final String DATABASE_CREATE_MAP =
              "CREATE TABLE "+ DATABASE_TABLE_MAP+" ("
                      + KEY_ROWID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
                      + KEY_START_TIME + " TEXT,"
                      + KEY_END_TIME + " TEXT,"
                      + KEY_RUNNING_TIME + " TEXT,"
                      + KEY_COORDINATE_X+" REAL,"
                      + KEY_COORDINATE_Y+" REAL"+ ");";

      private List<TrackPoint> trackPoints;
      private final Context mCtx;

      private static class DatabaseHelper extends SQLiteOpenHelper {

        DatabaseHelper(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
        }
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        }
        //지도에 출력할 정보와 데이터를 저장할 테이블을 CREATE 한다.
        @Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL(DATABASE_CREATE);
            db.execSQL(DATABASE_CREATE_MAP);
        }
    }

    public TrackDBhelper(Context context){
        this.mCtx =context;
    }

    public TrackDBhelper open() throws SQLException {
        mDbHelper = new DatabaseHelper(mCtx);
        mDb = mDbHelper.getWritableDatabase();
        return this;
    }

    public void close() {
        mDbHelper.close();
    }
    //종료할 때 출발 주소<>시간, 도착 주소<>시간, 평속, 칼로리, 거리, 온도, 습도 저장
    public long trackDBallFetch(String startAddr, String endAddr, String startTime, String endTime, String avgSpeed, double calroie, double distance, String temp, String wet){
        ContentValues contentValues = new ContentValues();
        contentValues.put(KEY_START_ADDR, startAddr);
        contentValues.put(KEY_END_ADDR, endAddr);
        contentValues.put(KEY_START_TIME, startTime);
        contentValues.put(KEY_END_TIME, endTime);
        contentValues.put(KEY_AVG_SPEED, avgSpeed);
        contentValues.put(KEY_CALORIE, calroie);
        contentValues.put(KEY_DISTANCE, distance);
        contentValues.put(KEY_TEMP, temp);
        contentValues.put(KEY_WET, wet);
        return mDb.insert(DATABASE_TABLE, null, contentValues);
    }

    //시작할 때 위치, 시간 저장.
    public long trackDBlocationStart(String startTime, double lat, double lng){
        ContentValues contentValues = new ContentValues();
        contentValues.put(KEY_START_TIME, startTime);
        contentValues.put(KEY_COORDINATE_X, lat);
        contentValues.put(KEY_COORDINATE_Y, lng);
        return mDb.insert(DATABASE_TABLE_MAP, null, contentValues);
    }

    //출발 시간 between 도착 시간 사이에 있는 값을 가져오기.
    public List<TrackPoint> fetchBetweenTime(String start, String end){
        trackPoints = new ArrayList<>();
        mDbHelper = new DatabaseHelper(mCtx);
        mDb =  mDbHelper.getReadableDatabase();
        Cursor res = mDb.rawQuery("select * from " + DATABASE_TABLE_MAP+" where "+ KEY_RUNNING_TIME +" between "+"'"+start+"'"+" and "+"'"+end+"'", null);
        res.moveToFirst();
        while (!res.isAfterLast()) {
            double lat = res.getDouble(res.getColumnIndex(KEY_COORDINATE_X));
            double lng = res.getDouble(res.getColumnIndex(KEY_COORDINATE_Y));
            trackPoints.add(new TrackPoint(lat, lng));
            res.moveToNext();
        }
        if (res.getCount()==0){
            return null;
        }
        res.close();
        return trackPoints;
    }
    //...중략
}

//DB에 저장된 포인트를 경위도 형식으로 출력하기 위한 TrackPoint VO 모델 클래스
public class TrackPoint {
    private double lat;
    private double lng;

    public TrackPoint(double lat, double lng){
        this.lat = lat;
        this.lng = lng;
    }
    public double getLat(){
        return lat;
    }
    public double getLng(){
        return lng;
    }
}

//...중략
public class TrackActivity extends AppCompatActivity {
  listView = (ListView)findViewById(R.id.trackListview);
  final TrackDBhelper trackDBhelper = new TrackDBhelper(this);
  //...중략
  listView.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
            @Override
            public boolean onItemLongClick(AdapterView<?> parent, View view, final int position, final long id) {
                android.app.AlertDialog.Builder alertDialog = new android.app.AlertDialog.Builder(TrackActivity.this);
                alertDialog.setTitle(getString(R.string.category));
                alertDialog.setItems(new CharSequence[]{getString(R.string.remove), getString(R.string.show_map), getString(R.string.about_pageSHARE), getString(R.string.close)},
                        new DialogInterface.OnClickListener() {
                            @Override
                            //선택 조건에 맞는 코드를 작성한다.
                            public void onClick(DialogInterface dialog, int which) {
                                switch (which){
                                    case 0:     
                                    //...중략                           
                                        break;
                                    case 1:
                                    try {
                                        Cursor cursor1 = (Cursor) trackAdapter.getItem(position);
                                        String startTime = cursor1.getString(cursor1.getColumnIndex(TrackDBhelper.KEY_START_TIME));
                                        String endTime = cursor1.getString(cursor1.getColumnIndex(TrackDBhelper.KEY_END_TIME));

                                        Intent intent = new Intent(TrackActivity.this, MapActivity.class);
                                        //선택된 List의 position을 통해 얻어온 정보를 기준으로 DB에서 주행 시작 시간과 종료시간을 intent로 넘겨준다.
                                        intent.putExtra("startTime", startTime);
                                        intent.putExtra("endTime", endTime);
                                        startActivity(intent);

                                      }catch (Exception e){
                                          e.printStackTrace();
                                          Toast.makeText(getApplicationContext(), getString(R.string.error_default)+e, Toast.LENGTH_SHORT).show();
                                      }
                                        break;
                                    case 2:
                                      //...중략
                                      break;
                                    case 3:
                                        dialog.cancel();
                                      break;
                                }
                            }
                        });
                alertDialog.create().show();
                return false;
            }
        });
    }
    //...중략
}

import net.daum.mf.map.api.*;
//...중략
public class MapActivity extends FragmentActivity implements
MapView.MapViewEventListener,
MapView.POIItemEventListener{
  //받아온 데이터가 null 값이 아니라면.
  if (trackPointList!=null) {
             //DB에 저장된 시간을 기준으로 첫 번째 저장된 포인트 정보를 통해 출발 위치를 지정한다.
             TrackPoint trackPoint = trackPointList.get(0);
             double startLat = trackPoint.getLat();
             double startLng = trackPoint.getLng();
             String startTitle = getString(R.string.start_positon);
             //출발지 지정.
             MapPoint startMarkerPoint = mapPointWithGeoCoord(startLat, startLng);
             mapPOIItem = new MapPOIItem();
             mapPOIItem.setItemName(startTitle);
             mapPOIItem.setTag(0);
             mapPOIItem.setMapPoint(startMarkerPoint);
             mapPOIItem.setMarkerType(MapPOIItem.MarkerType.CustomImage);
             //다음 SDK에서 지원하는 커스텀 출발지 마커 출력.
             mapPOIItem.setCustomImageResourceId(R.drawable.custom_poi_marker_start);
             mapPOIItem.setCustomImageAutoscale(false);
             mapPOIItem.setCustomImageAnchor(0.5f, 1.0f);
             mapView.addPOIItem(mapPOIItem);
             try {
                 runOnUiThread(new Runnable() {
                     @Override
                     public void run() {
                         //시간 정보 비교를 통해 해당 List의 저장된 데이터를 불러온다.
                         trackPointList = trackDBhelper.fetchBetweenTime(starts, ends);
                         mapPolyline = new MapPolyline();
                         if (trackPointList != null && trackPointList.size() > 0) {
                            //TrackPoint 객체에 저장된 데이터(POI)를 하나하나 불러와서 저장하고 반복문을 통해 위치 정보가 저장된 포인트(POI)를 하나하나 연결하여 PolyLine을 그려준다.
                             for (i = 0; i < trackPointList.size()-1; i++) {
                                 TrackPoint obj = trackPointList.get(i);
                                 mapPolyline.setLineColor(Color.argb(128, 50, 0, 255));
                                 mapPolyline.addPoint(MapPoint.mapPointWithGeoCoord(obj.getLat(), obj.getLng()));
                                 mapView.addPolyline(mapPolyline);
                             }
                         }
                     }
                 });
                 Thread.sleep(500);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         //출발지 지정과 마찬가지로 도착지 지정 코드를 여기에 작성한다.
         //...중략
       }else {
          //정상적으로 데이터를 받아오지 못한 경우.
       }
    //해당 액티비티가 Destory 될 때 기존에 출력된 정보를 초기화 한다.
    @Override
    public void onDestroy() {
        super.onDestroy();
        mapView.removeAllPOIItems();
        mapView.removeAllPolylines();
    }
//...중략
}