package net.mobilefight.trackbuilder;

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

import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
import com.google.android.maps.Overlay;
import com.google.android.maps.OverlayController;
import com.google.android.maps.Point;

import android.app.NotificationManager;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.IntentReceiver;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.Paint.Style;
import android.location.Location;
import android.location.LocationManager;
import android.location.LocationProvider;
import android.os.Bundle;
import android.os.Looper;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.SubMenu;

public class TrackBuilder extends MapActivity {
     
     protected LocationManager myLocationManager = null;
     protected Location myLocation = null;
     protected MyIntentReceiver myIntentReceiver = new MyIntentReceiver();
     protected final long MINIMUM_DISTANCECHANGE_FOR_UPDATE = 5; // in Meters
    protected final long MINIMUM_TIME_BETWEEN_UPDATE = 1000; // in Milliseconds
     protected static final String LOCATION_CHANGED_ACTION =
     new String("android.intent.action.LOCATION_CHANGED");
    protected final IntentFilter myIntentFilter = new IntentFilter(LOCATION_CHANGED_ACTION);
    protected final Intent myIntent = new Intent(LOCATION_CHANGED_ACTION);
    protected boolean doUpdates = true;
   
    protected ProgressDialog myProgressDialog;
     
     protected MapView myMapView = null;
     protected MapController myMapController = null;
    protected OverlayController myOverlayController = null;
   
    protected List<Location> path = new ArrayList<Location>();
    protected SubMenu providers;
    protected LocationProvider provider;
   
    protected static final int SAVE_POINTS_REQUEST_CODE = 666;
    protected static final int SAVE_PATH_REQUEST_CODE = 667;
    protected static final int LOAD_PATH_REQUEST_CODE = 668;
   
    protected boolean providersLoaded = false;
    protected boolean loadingProviders = false;
    protected boolean loadedPath = false;
   
   
    class MyIntentReceiver extends IntentReceiver {
        @Override
        public void onReceiveIntent(Context context, Intent intent) {
             if(TrackBuilder.this.doUpdates)
                TrackBuilder.this.updateView();
        }
   }
   
    protected class MyLocationOverlay extends Overlay {
     @Override
     public void draw(Canvas canvas, PixelCalculator calculator, boolean shadow) {
          super.draw(canvas, calculator, shadow);
          Paint paint = new Paint();
          paint.setStyle(Style.FILL);
          
          paint.setARGB(255, 105, 105, 105);
          Point mapCentre = myMapView.getMapCenter();
          
          // we are always drawing the long/lat of the mapCentre
            canvas.drawText("longitude: " + mapCentre.getLongitudeE6() +
                    ", latitude: " + mapCentre.getLatitudeE6(),
                    5, 15, paint);
           
            // if there is GPS provider available, we draw the violet dot at the current
            // position and the long/lat at the top of the screen
          if (doUpdates && myLocation != null && provider != null) {                 
               Double lat = TrackBuilder.this.myLocation.getLatitude() * 1E6;
               Double lng = TrackBuilder.this.myLocation.getLongitude() * 1E6;
               Point point = new Point(lat.intValue(), lng.intValue());

               int[] myScreenCoords = new int[2];
               calculator.getPointXY(point, myScreenCoords);
               
               paint.setARGB(255, 80, 30, 150);
               canvas.drawOval(new RectF(myScreenCoords[0] - 5, myScreenCoords[1] + 5,
                        myScreenCoords[0] + 5, myScreenCoords[1] - 5), paint);
                canvas.drawText("longitude: " + point.getLongitudeE6() +
                         ", latitude: " + point.getLatitudeE6(),
                         5, 26, paint);
          }
          int[] prevScreenCoords = new int[2];
          boolean first = true;
          // we are iterating all the path's points and draw the green dots at the
          // points' positions and red lines between them
          for (Location loc : path) {
               Point point = new Point((int) loc.getLatitude(), (int) loc.getLongitude());          
               int[] screenCoords = new int[2];
               calculator.getPointXY(point, screenCoords);
               paint.setARGB(80, 156, 192, 36);
               canvas.drawOval(new RectF(screenCoords[0] - 5, screenCoords[1] + 5,
                        screenCoords[0] + 5, screenCoords[1] - 5), paint);
               if (!first) {
                    paint.setARGB(80, 255, 0, 0);
                    canvas.drawLine(prevScreenCoords[0], prevScreenCoords[1],
                            screenCoords[0], screenCoords[1], paint);
               }
               prevScreenCoords[0] = screenCoords[0];
               prevScreenCoords[1] = screenCoords[1];
               first = false;
          }
     }
    }
     
    @Override
    public void onCreate(Bundle icicle) {
     super.onCreate(icicle);
       
     myLocationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
        myMapView = new MapView(this);
        setContentView(myMapView);
        myMapController = this.myMapView.getController();        
        myOverlayController = this.myMapView.createOverlayController();
        MyLocationOverlay myLocationOverlay = new MyLocationOverlay();
        myOverlayController.add(myLocationOverlay, true);        
        myMapController.zoomTo(2);
    }
   
    @Override
    public void onResume() {
         super.onResume();
         doUpdates = true;
         registerReceiver(myIntentReceiver, myIntentFilter);
    }
   
    @Override
    public void onFreeze(Bundle icicle) {
         doUpdates = false;
         unregisterReceiver(myIntentReceiver);
         super.onFreeze(icicle);
    }
   
    private void updateView() {
     if (provider != null) {
          myLocation = myLocationManager.getCurrentLocation(provider.getName());
          myMapView.invalidate();
     }
    }
   
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
         boolean supRetVal = super.onCreateOptionsMenu(menu);
         menu.add(0, 0, getString(R.string.map_menu_zoom_in));
         menu.add(0, 1, getString(R.string.map_menu_zoom_out));
         menu.add(0, 2, getString(R.string.map_menu_satellite));
         menu.add(0, 3, getString(R.string.map_menu_traffic));
         menu.add(0, 4, getString(R.string.map_menu_set_point));
         menu.add(0, 5, getString(R.string.map_menu_remove_point));
         menu.add(0, 6, getString(R.string.map_menu_clear_points));
         // we remember the reference to submenu in order to modify it in the future
         providers = menu.addSubMenu(0, 7, getString(R.string.map_menu_providers));
         menu.add(0, 8, getString(R.string.map_menu_save_points));
         menu.addSeparator(0, 9);
         menu.add(0, 10, getString(R.string.map_menu_save_path));
         menu.add(0, 11, getString(R.string.map_menu_load_path));
         menu.addSeparator(0, 12);
         menu.add(0, 13, getString(R.string.map_menu_exit));
         return supRetVal;
    }
   

   
    @Override
    protected void onActivityResult(int requestCode, int resultCode,
          final String data, final Bundle extras) {
     super.onActivityResult(requestCode, resultCode, data, extras);
     switch (requestCode) {
     case SAVE_POINTS_REQUEST_CODE: // this is the result from save points subactivity
          if (resultCode == RESULT_OK) {
               // display the progress dialog
               myProgressDialog = ProgressDialog.show(TrackBuilder.this,
                         "Please wait...", "Saving track...", true);
               // start the thread, which will do the hard work
               new Thread() {
                    public void run() {
                         boolean resultOK = TrackFactory.saveFile(path, TrackBuilder.this, data, extras.getInteger("step"));
                         myProgressDialog.dismiss();
                         // we have to call Looper.prepare() before calling showAlert
                         Looper.prepare();
                         if (resultOK) {
                              showAlert("File saved", "Track successfully saved as " + data, "OK", false);
                         }
                         else {
                              showAlert("Error", "Track cannot be saved as " + data, "OK", false);
                         }
                         // in order to display alert dialog we have to call Looper.loop()
                         Looper.loop();
                         // after Looper.loop() we have to call quit() on our looper
                         Looper.myLooper().quit();
                    }
               }.start();
          }
          break;
     case SAVE_PATH_REQUEST_CODE:
          if (resultCode == RESULT_OK) {
               myProgressDialog = ProgressDialog.show(TrackBuilder.this,
                         "Please wait...", "Saving path...", true);
               new Thread() {
                    public void run() {
                         boolean resultOK = TrackFactory.savePath(path, TrackBuilder.this, data);
                         myProgressDialog.dismiss();
                         Looper.prepare();
                         if (resultOK) {
                              showAlert("File saved", "Path successfully saved as " + data, "OK", false);
                         }
                         else {
                              showAlert("Error", "Path cannot be saved as " + data, "OK", false);
                         }
                         Looper.loop();
                         Looper.myLooper().quit();
                    }
               }.start();
          }
          break;
     case LOAD_PATH_REQUEST_CODE:
          if (resultCode == RESULT_OK) {
               myProgressDialog = ProgressDialog.show(TrackBuilder.this,
                         "Please wait...", "Loading path...", true);
               loadedPath = false;
               new Thread() {
                    public void run() {
                         List<Location> newPath = new ArrayList<Location>();
                         boolean resultOK = TrackFactory.loadPath(newPath, TrackBuilder.this, data);
                         myProgressDialog.dismiss();
                         Looper.prepare();
                         if (resultOK) {
                              path.clear();
                              path.addAll(newPath);
                              showAlert("File loaded", "Path file " + data + " successfully loaded", "OK", false);
                         }
                         else {
                              showAlert("Error", "Path file " + data + " cannot be loaded", "OK", false);
                         }
                         // we have to release the main thread before calling Looper.lopp()!
                         loadedPath = true;
                         Looper.loop();
                         Looper.myLooper().quit();
                    }
               }.start();
               // we have to wait on the worker thread to invalidate the map view at the
               // proper moment
               while (true) {
                    if (loadedPath) {
                         break;
                    }                             
                    try {
                         Thread.sleep(500);
                    }
                    catch (InterruptedException e) {
                         // do nothing
                    }
               }
               // invalidate the map view in order to redraw the screen
               myMapView.invalidate();
          }
          else if (resultCode == LoadPath.RESULT_EMPTY) {
               showAlert("Error", "There are no saved path files!", "OK", false);
          }
          break;
     }
    }
   
    @Override
    public boolean onOptionsItemSelected(Menu.Item item){
     if (item.getGroup() == 0) { // main menu
          switch (item.getId()) {
          case 0: return zoomIn();
          case 1: return zoomOut();               
          case 2: return toggleSatellite();                 
          case 3: return toggleTraffic();                
          case 4: return setPoint();               
          case 5: return removePoint();
          case 6: return clearAllPoints();
          case 7: return updateProviders();
          case 8: return savePoints();
          case 10: return savePath();
          case 11: return loadPath();
          case 13: return exit();                 
          }
     }
     else { // submenu
          if (item.getId() == 0) { // none
               myLocationManager.removeUpdates(myIntent);
               doUpdates = false;
               myLocation = null;
               provider = null;
               myMapView.invalidate();
          }
          else {
               List<LocationProvider> locProviders = myLocationManager.getProviders();
               provider = locProviders.get(item.getId()-1);

               myLocationManager.requestUpdates(provider, MINIMUM_TIME_BETWEEN_UPDATE,
                         MINIMUM_DISTANCECHANGE_FOR_UPDATE, myIntent);
               onResume();
          }
     }
        return false;
    }
   
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
     switch (keyCode) {
     case KeyEvent.KEYCODE_I: return zoomIn();
     case KeyEvent.KEYCODE_O: return zoomOut();
     case KeyEvent.KEYCODE_S: return toggleSatellite();        
     case KeyEvent.KEYCODE_T: return toggleTraffic();
     case KeyEvent.KEYCODE_P: return setPoint();
     case KeyEvent.KEYCODE_R: return removePoint();
     case KeyEvent.KEYCODE_C: return clearAllPoints();
     case KeyEvent.KEYCODE_X: return savePoints();
     }
     return false;
    }
   
    // menu methods
    private boolean zoomIn() {
     this.myMapController.zoomTo(Math.min(21, this.myMapView.getZoomLevel() + 1));
     return true;
    }
   
    private boolean zoomOut() {
     this.myMapController.zoomTo(Math.max(1, this.myMapView.getZoomLevel() - 1));
        return true;
    }
   
    private boolean toggleSatellite() {
     myMapView.toggleSatellite();
         return true;
    }
   
    private boolean toggleTraffic() {
     myMapView.toggleTraffic();
        return true;
    }
   
    private boolean setPoint() {
     Point mapCentre = myMapView.getMapCenter();
     Location centreLocation = new Location();
     centreLocation.setLatitude(mapCentre.getLatitudeE6());
     centreLocation.setLongitude(mapCentre.getLongitudeE6());
     path.add(centreLocation);
     myMapView.invalidate();
     return true;
    }
   
    private boolean removePoint() {
     if (!path.isEmpty()) {
          path.remove(path.size()-1);
          myMapView.invalidate();
     }
     return true;
    }
   
    private boolean exit() {
     this.finish();
        return true;
    }
   
    private boolean updateProviders() {
     synchronized (this) {
          if (providersLoaded) {
               // the worker thread has finished and we simply update the
               // providers sumbenu with retrieved providers
          providers.removeGroup(1);
          providers.add(1, 0, getString(R.string.map_submenu_none));
               Collection<LocationProvider> locProviders = myLocationManager.getProviders();
               int counter = 1;
               for (LocationProvider provider : locProviders) {
                    providers.add(1, counter, provider.getName());
                    counter++;
               }
               return true;
          }
          else if (loadingProviders) { // the working thread hasn't finished yet
               return true;
          }
          // we have to set this flag at this moment to avoid creation of multiple threads
          loadingProviders = true;
     }

     myProgressDialog = ProgressDialog.show(TrackBuilder.this,
               "Please wait...", "Retrieving available providers...", true);
     new Thread() {
          // this working thread simply calls getProviders() method in order
          // to initialize the providers
          public void run() {
               myLocationManager.getProviders();
               myProgressDialog.dismiss();
               synchronized (TrackBuilder.this) {
                    providersLoaded = true;
               }                   
          }
     }.start();     
     return true;
    }
   
    private boolean clearAllPoints() {
     path.clear();
     this.myMapView.invalidate();
     return true;
    }
   
    private boolean savePoints() {
     if (path.size() < 2) {
          NotificationManager nm = (NotificationManager)
          getSystemService(NOTIFICATION_SERVICE);
          nm.notifyWithText(100, "You have to put at least two points on the map!",
                    NotificationManager.LENGTH_SHORT, null);
     }
     else {
          // start save points subactivity
          Intent i = new Intent(TrackBuilder.this, SavePoints.class);
          // we are adding the bundle to the intent with 'path' set to false
          Bundle extras = new Bundle();
          extras.putBoolean("path", false);
          i.putExtras(extras);
          startSubActivity(i, SAVE_POINTS_REQUEST_CODE);
     }
     return true;
    }
   
    private boolean savePath() {
     if (path.size() < 2) {
          NotificationManager nm = (NotificationManager)
          getSystemService(NOTIFICATION_SERVICE);
          nm.notifyWithText(100, "You have to put at least two points on the map!",
                    NotificationManager.LENGTH_SHORT, null);
     }
     else {
          Intent i = new Intent(TrackBuilder.this, SavePoints.class);
          // we are adding the bundle to the intent with 'path' set to true          
          Bundle extras = new Bundle();
          extras.putBoolean("path", true);
          i.putExtras(extras);
          startSubActivity(i, SAVE_PATH_REQUEST_CODE);
     }
     return true;
    }
   
    private boolean loadPath() {
     Intent i = new Intent(TrackBuilder.this, LoadPath.class);
          startSubActivity(i, LOAD_PATH_REQUEST_CODE);
          return true;
    }
}

package net.mobilefight.trackbuilder;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;

import com.google.android.maps.Point;

import android.location.Location;

public class TrackFactory {
     
     private static long time = 0;
   
    public static double euclDistance(Point p1, Point p2) {
        return Math.sqrt(((double)p1.getLatitudeE6()-p2.getLatitudeE6())*((double)p1.getLatitudeE6()-p2.getLatitudeE6())
               + ((double)p1.getLongitudeE6()-p2.getLongitudeE6())*((double)p1.getLongitudeE6()-p2.getLongitudeE6()));
    }
   
    private static double genStepSmallPoints(double fstep, Point start, Point end, final double step, List<Point> computed) {
        double dist = euclDistance(start, end);
        if (fstep > dist) {
          return fstep - dist;
        }
        double t = fstep / dist;
        computed.add(new Point((int) (start.getLatitudeE6() * (1 - t) + end.getLatitudeE6() * t),
                             (int) (start.getLongitudeE6() * (1 - t) + end.getLongitudeE6() * t)));
       
        int points_no = (int)((dist-fstep)/step);
        for (int i = 0; i < points_no; ++i) {
          t += step / dist;
          computed.add(new Point((int) (start.getLatitudeE6() * (1 - t) + end.getLatitudeE6() * t),
                        (int) (start.getLongitudeE6() * (1 - t) + end.getLongitudeE6() * t)));
        }
        return step - (dist - fstep - (points_no*step));
    }
   
    public static List<Point> genAllSteps(List<Location> big_points, double step) {
        List<Point> ret = new Vector<Point>();
        double fstep = 0.0;
        for (int i = 0; i < big_points.size() - 1; ++i) {
          Location loc = big_points.get(i);
          Point pointI = new Point((int) loc.getLatitude(), (int) loc.getLongitude());
          loc = big_points.get(i+1);
          Point pointIp1 = new Point((int) loc.getLatitude(), (int) loc.getLongitude());
            fstep = genStepSmallPoints(fstep, pointI, pointIp1, step, ret);
        }
        return ret;
    }
   
    private static String prepareTrackSequence(Point point) {
     StringBuilder toReturn = new StringBuilder();
     toReturn.append(time);
     toReturn.append(" ");
     toReturn.append((double)point.getLongitudeE6() / 1E6);
     toReturn.append(" ");
     toReturn.append((double)point.getLatitudeE6() / 1E6);
     toReturn.append(" 0");
     time += 1000;
     return toReturn.toString();
    }
   
     public final static boolean saveFile(List<Location> path, TrackBuilder context, String filename, int step) {       
          try {
               BufferedOutputStream output = new BufferedOutputStream(context.openFileOutput(filename + "_track", 0));
               List<Point> points = genAllSteps(path, step);
               for (Point point : points) {
                    output.write((prepareTrackSequence(point) + "\n").getBytes());
               }
               output.close();
          } catch (IOException e) {
               return false;
          }
          return true;
     }
     
     public final static boolean savePath(List<Location> path, TrackBuilder context, String filename) {       
          try {
               BufferedOutputStream output = new BufferedOutputStream(context.openFileOutput(filename + "_path", 0));
               for (Location loc : path) {
                    output.write((loc.getLongitude() + " " + loc.getLatitude() + "\n").getBytes());
               }
               output.close();
          } catch (IOException e) {
               return false;
          }
          return true;
     }
     
     public final static boolean loadPath(List<Location> path, TrackBuilder context, String filename) {       
          try {
               BufferedInputStream input = new BufferedInputStream(context.openFileInput(filename));
               StringBuilder data = new StringBuilder();
               byte[] buffer = new byte[4096];
               while (input.read(buffer) != -1) {
                    data.append(new String(buffer));
               }
               StringTokenizer tokenizer = new StringTokenizer(data.toString(), " \n");
               try {
                    while (tokenizer.hasMoreTokens()) {
                         Location location = new Location();
                         location.setLongitude(Double.valueOf(tokenizer.nextToken()));
                         location.setLatitude(Double.valueOf(tokenizer.nextToken()));
                         path.add(location);
                    }
               }
               catch (Exception e) {
                    // do nothing
               }
               input.close();
          } catch (IOException e) {
               return false;
          }
          return true;
     }
}

package net.mobilefight.trackbuilder;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class SavePoints extends Activity {

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        setContentView(R.layout.save_file);
       
        // we are checking the bundle attached to intent for the 'path' value.
        // if it's true, we have to change the activity title and hide label
        // end edit widget for step value
        if (getIntent().getExtras().getBoolean("path")) {
          setTitle(getString(R.string.save_path_name));
          TextView label = (TextView)findViewById(R.id.save_points_label2);
          label.setVisibility(View.INVISIBLE);
            EditText step = (EditText)findViewById(R.id.save_points_edit_step);
            step.setVisibility(View.INVISIBLE);
        }
       
        Button cmd_save = (Button)findViewById(R.id.save_points_cmd_save);
        cmd_save.setOnClickListener(new OnClickListener(){
          // @Override
          public void onClick(View arg0) {
               EditText edit_returvalue = (EditText)findViewById(
                         R.id.save_points_edit_returnvalue);
               Bundle extras = new Bundle();
               EditText step = (EditText)findViewById(
                         R.id.save_points_edit_step);
               Integer stepValue;
               try {
                    stepValue = Integer.valueOf(step.getText().toString());
               }
               catch (Exception e) {
                    stepValue = new Integer(20);
               }
               extras.putInteger("step", stepValue);
               SavePoints.this.setResult(RESULT_OK,
                         edit_returvalue.getText().toString(),
                         extras);
               SavePoints.this.finish();
          }
        });
       
        Button cmd_cancel = (Button)findViewById(R.id.save_points_cmd_cancel);
        cmd_cancel.setOnClickListener(new OnClickListener(){
          // @Override
          public void onClick(View arg0) {
               SavePoints.this.finish();
          }
        });
    }
}

package net.mobilefight.trackbuilder;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

import android.app.AlertDialog;
import android.app.ListActivity;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class LoadPath extends ListActivity {
     
     public static final int RESULT_EMPTY = 2;
          
     private List<String> directoryEntries = new ArrayList<String>();
     
     @Override
     public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      try {
           browseTo(getFileStreamPath(""));
      } catch (FileNotFoundException e) {
           LoadPath.this.setResult(RESULT_EMPTY);
           LoadPath.this.finish();
      }
     }
         
     private void browseTo(final File aDirectory){
          if (aDirectory.isDirectory()){
               fill(aDirectory.listFiles());
          }else{
               OnClickListener okButtonListener = new OnClickListener(){
                    // @Override
                    public void onClick(DialogInterface arg0, int arg1) {
                         LoadPath.this.setResult(RESULT_OK, aDirectory.getName());
                         LoadPath.this.finish();
                    }
               };
               OnClickListener cancelButtonListener = new OnClickListener(){
                    // @Override
                    public void onClick(DialogInterface arg0, int arg1) {
                         // Do nothing ^^
                    }
               };
               AlertDialog.show(this,"Question", "Do you want to load: "
                                        + aDirectory.getName() + "?",
                                        "OK", okButtonListener,
                                        "Cancel", cancelButtonListener, false, null);
          }
     }

     private void fill(File[] files) {
      directoryEntries.clear();
      boolean empty = true;

      for (File file : files){
           String filename = file.getName();
           if (filename.endsWith("_path")) {
                directoryEntries.add(filename);
                empty = false;
           }
      }
     

      ArrayAdapter<String> directoryList = new ArrayAdapter<String>(this,
                R.layout.file_row, this.directoryEntries);

      this.setListAdapter(directoryList);
     
      if (empty) {
           LoadPath.this.setResult(RESULT_EMPTY);
           LoadPath.this.finish();
      }
     }

     @Override
     protected void onListItemClick(ListView l, View v, int position, long id) {
      super.onListItemClick(l, v, position, id);
      int selectionRowID = (int) this.getSelectionRowID();

      File clickedFile = null;
      clickedFile = new File(this.directoryEntries.get(selectionRowID));
      if(clickedFile != null)
           this.browseTo(clickedFile);
     }
}

Looper.prepare();
                              
                              if (resultOK) {
                                   showAlert("File Saved", "Track Saved as "+data,
                                             "OK",false);
                              } else {
                                   showAlert("Error","Track could not be saved as "+data,
                                             "OK",false);
                                   
                              }

Looper.prepare();
                              
                              if (resultOK) {
                                   showAlert("File Saved",0, "Track Saved as "+data,
                                             "OK",false);
                              } else {
                                   showAlert("Error",0,"Track could not be saved as "+data,
                                             "OK",false);
                                   
                              }

Toast.makeText(Context , "You have to put at least two points on the map!", Toast.LENGTH_SHORT).show();