applications/zanavi/NavitVehicle.java

/**
 * ZANavi, Zoff Android Navigation system.
 * Copyright (C) 2011 Zoff <zoff@zoff.cc>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

package com.zoffcc.applications.zanavi;

import java.util.Iterator;

import android.content.Context;
import android.location.Criteria;
import android.location.GpsSatellite;
import android.location.GpsStatus;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.location.LocationProvider;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class NavitVehicle
{
        private LocationManager locationManager = null;
        private static LocationManager locationManager_s = null;
        private int vehicle_callbackid;
        private static int vehicle_callbackid_ = 0;
        private String preciseProvider = null;
        private String fastProvider = null;
        private static LocationListener fastLocationListener_s = null;
        private static LocationListener preciseLocationListener_s = null;
        private static GpsStatus.Listener gps_status_listener_s = null;
        private static float compass_heading;
        private static float current_accuracy = 99999999F;

        public static Handler vehicle_handler_ = null;

        public static final float GPS_SPEED_ABOVE_USE_FOR_HEADING = (float) (9 / 3.6f); //  (9 km/h) / (3.6) ~= m/s

        private static String preciseProvider_s = null;
        private static String fastProvider_s = null;

        public static long last_p_fix = 0;
        public static long last_f_fix = 0;
        public Bundle gps_extras = null;
        public static GpsStatus gps_status = null;

        private static Location last_location = null;

        public static native void VehicleCallback(int id, Location location);

        // private static SatStatusThread st = null;

        private class SatStatusThread extends Thread
        {
                // get new gpsstatus --------
                int sats1 = 0;
                int satsInFix1 = 0;
                Boolean running = true;

                public void run()
                {
                        this.running = true;

                        while (this.running)
                        {
                                try
                                {
                                        if (!Navit.DemoVehicle)
                                        {
                                                GpsStatus stat = locationManager.getGpsStatus(gps_status);
                                                gps_status = stat;
                                                Iterator<GpsSatellite> localIterator = stat.getSatellites().iterator();
                                                while (localIterator.hasNext())
                                                {
                                                        GpsSatellite localGpsSatellite = (GpsSatellite) localIterator.next();
                                                        sats1++;
                                                        if (localGpsSatellite.usedInFix())
                                                        {
                                                                satsInFix1++;
                                                        }
                                                }
                                        }
                                }
                                catch (Exception e)
                                {
                                        e.printStackTrace();
                                }
                                // System.out.println("Statellites (Thread): " + satsInFix1 + "/" + sats1);
                                // Navit.set_debug_messages3_wrapper("sat: " + satsInFix1 + "/" + sats1);
                                // get new gpsstatus --------

                                try
                                {
                                        Thread.sleep(1000);
                                }
                                catch (InterruptedException e)
                                {
                                }
                        }
                }

                public void stop_me()
                {
                        this.running = false;
                }
        }

        NavitVehicle(Context context, int callbackid)
        {
                vehicle_handler_ = vehicle_handler;

                vehicle_callbackid = callbackid;
                vehicle_callbackid_ = callbackid;

                locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
                locationManager_s = locationManager;

                LocationListener fastLocationListener = new LocationListener()
                {
                        public void onLocationChanged(Location location)
                        {
                                last_f_fix = location.getTime();
                                // if last gps fix was longer than 4 secs. ago, use this fix
                                // and we dont have a GPS lock
                                if ((last_p_fix + 4000 < last_f_fix) && (Navit.satsInFix < 3))
                                {
                                        if (Navit.PREF_follow_gps)
                                        {
                                                if (Navit.PREF_use_compass_heading_base)
                                                {
                                                        if ((Navit.PREF_use_compass_heading_always) || (location.getSpeed() < GPS_SPEED_ABOVE_USE_FOR_HEADING))
                                                        {
                                                                // use compass heading
                                                                location.setBearing(compass_heading);
                                                        }
                                                }

                                                //System.out.println("send values 1");
                                                //Log.e("NavitVehicle", "LocationChanged provider=fast Latitude " + location.getLatitude() + " Longitude " + location.getLongitude());
                                                last_location = location;
                                                if (!Navit.DemoVehicle)
                                                {
                                                        VehicleCallback(vehicle_callbackid, location);
                                                }
                                        }
                                }
                        }

                        public void onProviderDisabled(String provider)
                        {
                                //Log.e("NavitVehicle", "onProviderDisabled -> provider=" + provider);
                        }

                        public void onProviderEnabled(String provider)
                        {
                                //Log.e("NavitVehicle", "onProviderEnabled -> provider=" + provider);
                        }

                        public void onStatusChanged(String provider, int status, Bundle extras)
                        {
                                //Log.e("NavitVehicle", "onStatusChanged -> provider=" + provider + " status=" + status);
                                try
                                {
                                        switch (status)
                                        {
                                        case LocationProvider.OUT_OF_SERVICE:
                                                System.out.println("*** No Service ***");
                                                break;
                                        case LocationProvider.TEMPORARILY_UNAVAILABLE:
                                                System.out.println("*** No Fix ***");
                                                break;
                                        case LocationProvider.AVAILABLE:
                                                System.out.println("@@@  Fix   @@@");
                                                break;
                                        }
                                }
                                catch (Exception e)
                                {

                                }
                        }
                };
                fastLocationListener_s = fastLocationListener;

                LocationListener preciseLocationListener = new LocationListener()
                {
                        public void onLocationChanged(Location location)
                        {
                                last_p_fix = location.getTime();
                                current_accuracy = location.getAccuracy();

                                if (Navit.PREF_follow_gps)
                                {
                                        if (Navit.PREF_use_compass_heading_base)
                                        {
                                                if ((Navit.PREF_use_compass_heading_always) || (location.getSpeed() < GPS_SPEED_ABOVE_USE_FOR_HEADING))
                                                {
                                                        // use compass heading
                                                        location.setBearing(compass_heading);
                                                }
                                        }
                                        //System.out.println("send values 2");
                                        //Log.e("NavitVehicle", "LocationChanged provider=precise Latitude " + location.getLatitude() + " Longitude " + location.getLongitude());
                                        last_location = location;
                                        VehicleCallback(vehicle_callbackid, location);
                                }
                        }

                        public void onProviderDisabled(String provider)
                        {
                                //Log.e("NavitVehicle", "onProviderDisabled -> provider=" + provider);
                        }

                        public void onProviderEnabled(String provider)
                        {
                                //Log.e("NavitVehicle", "onProviderEnabled -> provider=" + provider);
                        }

                        public void onStatusChanged(String provider, int status, Bundle extras)
                        {
                                Log.e("NavitVehicle", "onStatusChanged -> provider=" + provider + " status=" + status);

                                try
                                {
                                        if (status == GpsStatus.GPS_EVENT_FIRST_FIX)
                                        {
                                                System.out.println("*** GPS first fix ***");
                                        }
                                        switch (status)
                                        {
                                        case LocationProvider.OUT_OF_SERVICE:
                                                System.out.println("*** No Service ***");
                                                break;
                                        case LocationProvider.TEMPORARILY_UNAVAILABLE:
                                                System.out.println("*** No Fix ***");
                                                break;
                                        case LocationProvider.AVAILABLE:
                                                System.out.println("@@@  Fix   @@@");
                                                break;
                                        }
                                }
                                catch (Exception e)
                                {

                                }
                        }
                };
                preciseLocationListener_s = preciseLocationListener;

                /*
                 * Use 2 LocationProviders, one precise (usually GPS), and one
                 * not so precise, but possible faster.
                 */
                Criteria highCriteria = null;
                Criteria lowCriteria = null;
                try
                {
                        // Selection criterias for the precise provider
                        highCriteria = new Criteria();
                        highCriteria.setAccuracy(Criteria.ACCURACY_FINE);
                        highCriteria.setAltitudeRequired(true);
                        highCriteria.setBearingRequired(true);
                        //highCriteria.setCostAllowed(true);
                        //highCriteria.setPowerRequirement(Criteria.POWER_HIGH);

                        // Selection criterias for the fast provider
                        lowCriteria = new Criteria();
                        lowCriteria.setAccuracy(Criteria.ACCURACY_COARSE);
                        lowCriteria.setAltitudeRequired(false);
                        lowCriteria.setBearingRequired(false);
                        //lowCriteria.setCostAllowed(true);
                        //lowCriteria.setPowerRequirement(Criteria.POWER_HIGH);
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

                try
                {
                        //Log.e("NavitVehicle", "Providers " + locationManager.getAllProviders());

                        preciseProvider = locationManager.getBestProvider(highCriteria, false);
                        preciseProvider_s = preciseProvider;
                        //Log.e("NavitVehicle", "Precise Provider " + preciseProvider);
                        fastProvider = locationManager.getBestProvider(lowCriteria, false);
                        fastProvider_s = fastProvider;
                        //Log.e("NavitVehicle", "Fast Provider " + fastProvider);
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

                try
                {
                        locationManager.requestLocationUpdates(preciseProvider, 0, 0, preciseLocationListener);
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

                try
                {
                        // If the 2 providers is the same, only activate one listener
                        if (fastProvider == null || preciseProvider.compareTo(fastProvider) == 0)
                        {
                                fastProvider = null;
                        }
                        else
                        {
                                if (Navit.PREF_use_fast_provider)
                                {
                                        locationManager.requestLocationUpdates(fastProvider, 0, 0, fastLocationListener);
                                }
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

                gps_status_listener_s = new GpsStatus.Listener()
                {
                        public void onGpsStatusChanged(int event)
                        {
                                if (event == GpsStatus.GPS_EVENT_SATELLITE_STATUS)
                                {
                                        // get new gpsstatus --------
                                        GpsStatus stat = locationManager.getGpsStatus(null);
                                        Navit.sats = 0;
                                        Navit.satsInFix = 0;

                                        try
                                        {
                                                Iterator<GpsSatellite> localIterator = stat.getSatellites().iterator();
                                                while (localIterator.hasNext())
                                                {
                                                        GpsSatellite localGpsSatellite = (GpsSatellite) localIterator.next();
                                                        Navit.sats++;
                                                        if (localGpsSatellite.usedInFix())
                                                        {
                                                                Navit.satsInFix++;
                                                        }
                                                }
                                                // redraw NavitOSDJava
                                                Message msg = NavitOSDJava.progress_handler_.obtainMessage();
                                                Bundle b = new Bundle();
                                                msg.what = 1;
                                                msg.setData(b);
                                                NavitOSDJava.progress_handler_.sendMessage(msg);
                                        }
                                        catch (Exception e)
                                        {
                                                e.printStackTrace();
                                        }
                                        // Navit.set_debug_messages3_wrapper("sat: " + Navit.satsInFix + "/" + Navit.sats);
                                        // System.out.println("Statellites: " + Navit.satsInFix + "/" + Navit.sats);
                                        // get new gpsstatus --------
                                }
                        }
                };
        }

        public static void set_mock_location__fast(Location mock_location)
        {
                try
                {
                        //locationManager_s.setTestProviderLocation("ZANavi_mock", mock_location);
                        // mock_location;
                        // System.out.println("llllllll" + mock_location.getLatitude() + " " + mock_location.getLongitude());
                        if ((vehicle_callbackid_ != 0) && (mock_location != null))
                        {
                                if (mock_location.getSpeed() == 0.0f)
                                {
                                        float save_speed = last_location.getSpeed();
                                        mock_location.setSpeed(0.2f);
                                        VehicleCallback(vehicle_callbackid_, mock_location);
                                        mock_location.setSpeed(save_speed);
                                }
                                else
                                {
                                        VehicleCallback(vehicle_callbackid_, mock_location);
                                }
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
        }

        public static void set_last_known_pos_precise_provider()
        {
                try
                {
                        Location l = locationManager_s.getLastKnownLocation(preciseProvider_s);
                        if (l != null)
                        {
                                if (l.getAccuracy() > 0)
                                {
                                        if ((l.getLatitude() != 0) && (l.getLongitude() != 0))
                                        {
                                                if (Navit.PREF_follow_gps)
                                                {
                                                        Log.e("NavitVehicle", "getLastKnownLocation precise (2) l=" + l.toString());
                                                        last_location = l;
                                                        VehicleCallback(vehicle_callbackid_, l);
                                                }
                                        }
                                }
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
        }

        public static void set_last_known_pos_fast_provider()
        {
                try
                {
                        // If the 2 providers is the same, only activate one listener
                        if (fastProvider_s != null)
                        {
                                if (Navit.PREF_use_fast_provider)
                                {
                                        if (!Navit.DemoVehicle)
                                        {
                                                Location l = locationManager_s.getLastKnownLocation(fastProvider_s);
                                                if (l != null)
                                                {
                                                        if (l.getAccuracy() > 0)
                                                        {
                                                                if ((l.getLatitude() != 0) && (l.getLongitude() != 0))
                                                                {
                                                                        if (Navit.PREF_follow_gps)
                                                                        {
                                                                                Log.e("NavitVehicle", "getLastKnownLocation fast (3) l=" + l.toString());
                                                                                last_location = l;
                                                                                VehicleCallback(vehicle_callbackid_, l);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

        }

        public static void turn_on_fast_provider()
        {
                try
                {
                        // If the 2 providers is the same, only activate one listener
                        if (fastProvider_s != null)
                        {
                                if (Navit.PREF_use_fast_provider)
                                {
                                        if (!Navit.DemoVehicle)
                                        {
                                                locationManager_s.requestLocationUpdates(fastProvider_s, 0, 0, fastLocationListener_s);
                                        }
                                }
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

        }

        public static void turn_on_precise_provider()
        {
                try
                {
                        locationManager_s.requestLocationUpdates(preciseProvider_s, 0, 0, preciseLocationListener_s);
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

                turn_on_sat_status();

                try
                {
                        // try to download aGPS data!!
                        if (Navit.PREF_use_agps)
                        {
                                Navit.downloadGPSXtra(Navit.getBaseContext_);
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
        }

        public static void turn_off_precise_provider()
        {
                try
                {
                        if (preciseProvider_s != null)
                        {
                                locationManager_s.removeUpdates(preciseLocationListener_s);
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }

                turn_off_sat_status();
        }

        public static void turn_on_sat_status()
        {
                try
                {
                        Navit.sats = 0;
                        Navit.satsInFix = 0;
                        if (preciseProvider_s != null)
                        {
                                try
                                {
                                        locationManager_s.removeGpsStatusListener(gps_status_listener_s);
                                }
                                catch (Exception e3)
                                {
                                        e3.printStackTrace();
                                }
                                locationManager_s.addGpsStatusListener(gps_status_listener_s);
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
                System.out.println("turn_ON_sat_status");
        }

        public static void turn_off_sat_status()
        {
                try
                {
                        Navit.sats = 0;
                        Navit.satsInFix = 0;
                        if (preciseProvider_s != null)
                        {
                                locationManager_s.removeGpsStatusListener(gps_status_listener_s);
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
                System.out.println("turn_off_sat_status");
        }

        public static void turn_off_fast_provider()
        {
                try
                {
                        if (fastProvider_s != null)
                        {
                                locationManager_s.removeUpdates(fastLocationListener_s);
                        }
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
        }

        public static void turn_off_all_providers()
        {
                turn_off_precise_provider();
                turn_off_fast_provider();
        }

        public Handler vehicle_handler = new Handler()
        {
                public void handleMessage(Message msg)
                {
                        switch (msg.what)
                        {
                        case 1:
                                // dismissDialog(msg.getData().getInt("dialog_num"));
                                // removeDialog(msg.getData().getInt("dialog_num"));
                                Location l = new Location("Network");
                                l.setLatitude(msg.getData().getFloat("lat"));
                                l.setLongitude(msg.getData().getFloat("lng"));
                                l.setBearing(msg.getData().getFloat("b"));
                                l.setSpeed(0.8f);
                                NavitVehicle.set_mock_location__fast(l);
                                break;
                        }
                }
        };

        public static void update_compass_heading(float heading)
        {
                compass_heading = heading;
                // use compass heading
                try
                {
                        if (Navit.PREF_use_compass_heading_base)
                        {
                                if ((Navit.PREF_use_compass_heading_always) || (last_location.getSpeed() < GPS_SPEED_ABOVE_USE_FOR_HEADING))
                                {
                                        last_location.setBearing(compass_heading);
                                        // !! ugly hack to make map redraw !!
                                        // !! ugly hack to make map redraw !!
                                        // !! ugly hack to make map redraw !!
                                        if (last_location.getSpeed() == 0.0f)
                                        {
                                                float save_speed = last_location.getSpeed();
                                                last_location.setSpeed(0.2f);
                                                if (!Navit.DemoVehicle)
                                                {
                                                        VehicleCallback(vehicle_callbackid_, last_location);
                                                }
                                                last_location.setSpeed(save_speed);
                                        }
                                        else
                                        {
                                                if (!Navit.DemoVehicle)
                                                {
                                                        VehicleCallback(vehicle_callbackid_, last_location);
                                                }
                                        }
                                        // !! ugly hack to make map redraw !!
                                        // !! ugly hack to make map redraw !!
                                        // !! ugly hack to make map redraw !!
                                }
                        }
                }
                catch (Exception e)
                {
                        //e.printStackTrace();
                }
        }
}
1	/**
2	* ZANavi, Zoff Android Navigation system.
3	* Copyright (C) 2011 Zoff <zoff@zoff.cc>
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* version 2 as published by the Free Software Foundation.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the
16	* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17	* Boston, MA 02110-1301, USA.
18	*/
19
20	/**
21	* Navit, a modular navigation system.
22	* Copyright (C) 2005-2008 Navit Team
23	*
24	* This program is free software; you can redistribute it and/or
25	* modify it under the terms of the GNU General Public License
26	* version 2 as published by the Free Software Foundation.
27	*
28	* This program is distributed in the hope that it will be useful,
29	* but WITHOUT ANY WARRANTY; without even the implied warranty of
30	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31	* GNU General Public License for more details.
32	*
33	* You should have received a copy of the GNU General Public License
34	* along with this program; if not, write to the
35	* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
36	* Boston, MA 02110-1301, USA.
37	*/
38
39	package com.zoffcc.applications.zanavi;
40
41	import java.util.Iterator;
42
43	import android.content.Context;
44	import android.location.Criteria;
45	import android.location.GpsSatellite;
46	import android.location.GpsStatus;
47	import android.location.Location;
48	import android.location.LocationListener;
49	import android.location.LocationManager;
50	import android.location.LocationProvider;
51	import android.os.Bundle;
52	import android.os.Handler;
53	import android.os.Message;
54	import android.util.Log;
55
56	public class NavitVehicle
57	{
58	private LocationManager locationManager = null;
59	private static LocationManager locationManager_s = null;
60	private int vehicle_callbackid;
61	private static int vehicle_callbackid_ = 0;
62	private String preciseProvider = null;
63	private String fastProvider = null;
64	private static LocationListener fastLocationListener_s = null;
65	private static LocationListener preciseLocationListener_s = null;
66	private static GpsStatus.Listener gps_status_listener_s = null;
67	private static float compass_heading;
68	private static float current_accuracy = 99999999F;
69
70	public static Handler vehicle_handler_ = null;
71
72	public static final float GPS_SPEED_ABOVE_USE_FOR_HEADING = (float) (9 / 3.6f); // (9 km/h) / (3.6) ~= m/s
73
74	private static String preciseProvider_s = null;
75	private static String fastProvider_s = null;
76
77	public static long last_p_fix = 0;
78	public static long last_f_fix = 0;
79	public Bundle gps_extras = null;
80	public static GpsStatus gps_status = null;
81
82	private static Location last_location = null;
83
84	public static native void VehicleCallback(int id, Location location);
85
86	// private static SatStatusThread st = null;
87
88	private class SatStatusThread extends Thread
89	{
90	// get new gpsstatus --------
91	int sats1 = 0;
92	int satsInFix1 = 0;
93	Boolean running = true;
94
95	public void run()
96	{
97	this.running = true;
98
99	while (this.running)
100	{
101	try
102	{
103	if (!Navit.DemoVehicle)
104	{
105	GpsStatus stat = locationManager.getGpsStatus(gps_status);
106	gps_status = stat;
107	Iterator<GpsSatellite> localIterator = stat.getSatellites().iterator();
108	while (localIterator.hasNext())
109	{
110	GpsSatellite localGpsSatellite = (GpsSatellite) localIterator.next();
111	sats1++;
112	if (localGpsSatellite.usedInFix())
113	{
114	satsInFix1++;
115	}
116	}
117	}
118	}
119	catch (Exception e)
120	{
121	e.printStackTrace();
122	}
123	// System.out.println("Statellites (Thread): " + satsInFix1 + "/" + sats1);
124	// Navit.set_debug_messages3_wrapper("sat: " + satsInFix1 + "/" + sats1);
125	// get new gpsstatus --------
126
127	try
128	{
129	Thread.sleep(1000);
130	}
131	catch (InterruptedException e)
132	{
133	}
134	}
135	}
136
137	public void stop_me()
138	{
139	this.running = false;
140	}
141	}
142
143	NavitVehicle(Context context, int callbackid)
144	{
145	vehicle_handler_ = vehicle_handler;
146
147	vehicle_callbackid = callbackid;
148	vehicle_callbackid_ = callbackid;
149
150	locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
151	locationManager_s = locationManager;
152
153	LocationListener fastLocationListener = new LocationListener()
154	{
155	public void onLocationChanged(Location location)
156	{
157	last_f_fix = location.getTime();
158	// if last gps fix was longer than 4 secs. ago, use this fix
159	// and we dont have a GPS lock
160	if ((last_p_fix + 4000 < last_f_fix) && (Navit.satsInFix < 3))
161	{
162	if (Navit.PREF_follow_gps)
163	{
164	if (Navit.PREF_use_compass_heading_base)
165	{
166	if ((Navit.PREF_use_compass_heading_always) \|\| (location.getSpeed() < GPS_SPEED_ABOVE_USE_FOR_HEADING))
167	{
168	// use compass heading
169	location.setBearing(compass_heading);
170	}
171	}
172
173	//System.out.println("send values 1");
174	//Log.e("NavitVehicle", "LocationChanged provider=fast Latitude " + location.getLatitude() + " Longitude " + location.getLongitude());
175	last_location = location;
176	if (!Navit.DemoVehicle)
177	{
178	VehicleCallback(vehicle_callbackid, location);
179	}
180	}
181	}
182	}
183
184	public void onProviderDisabled(String provider)
185	{
186	//Log.e("NavitVehicle", "onProviderDisabled -> provider=" + provider);
187	}
188
189	public void onProviderEnabled(String provider)
190	{
191	//Log.e("NavitVehicle", "onProviderEnabled -> provider=" + provider);
192	}
193
194	public void onStatusChanged(String provider, int status, Bundle extras)
195	{
196	//Log.e("NavitVehicle", "onStatusChanged -> provider=" + provider + " status=" + status);
197	try
198	{
199	switch (status)
200	{
201	case LocationProvider.OUT_OF_SERVICE:
202	System.out.println("* No Service *");
203	break;
204	case LocationProvider.TEMPORARILY_UNAVAILABLE:
205	System.out.println("* No Fix *");
206	break;
207	case LocationProvider.AVAILABLE:
208	System.out.println("@@@ Fix @@@");
209	break;
210	}
211	}
212	catch (Exception e)
213	{
214
215	}
216	}
217	};
218	fastLocationListener_s = fastLocationListener;
219
220	LocationListener preciseLocationListener = new LocationListener()
221	{
222	public void onLocationChanged(Location location)
223	{
224	last_p_fix = location.getTime();
225	current_accuracy = location.getAccuracy();
226
227	if (Navit.PREF_follow_gps)
228	{
229	if (Navit.PREF_use_compass_heading_base)
230	{
231	if ((Navit.PREF_use_compass_heading_always) \|\| (location.getSpeed() < GPS_SPEED_ABOVE_USE_FOR_HEADING))
232	{
233	// use compass heading
234	location.setBearing(compass_heading);
235	}
236	}
237	//System.out.println("send values 2");
238	//Log.e("NavitVehicle", "LocationChanged provider=precise Latitude " + location.getLatitude() + " Longitude " + location.getLongitude());
239	last_location = location;
240	VehicleCallback(vehicle_callbackid, location);
241	}
242	}
243
244	public void onProviderDisabled(String provider)
245	{
246	//Log.e("NavitVehicle", "onProviderDisabled -> provider=" + provider);
247	}
248
249	public void onProviderEnabled(String provider)
250	{
251	//Log.e("NavitVehicle", "onProviderEnabled -> provider=" + provider);
252	}
253
254	public void onStatusChanged(String provider, int status, Bundle extras)
255	{
256	Log.e("NavitVehicle", "onStatusChanged -> provider=" + provider + " status=" + status);
257
258	try
259	{
260	if (status == GpsStatus.GPS_EVENT_FIRST_FIX)
261	{
262	System.out.println("* GPS first fix *");
263	}
264	switch (status)
265	{
266	case LocationProvider.OUT_OF_SERVICE:
267	System.out.println("* No Service *");
268	break;
269	case LocationProvider.TEMPORARILY_UNAVAILABLE:
270	System.out.println("* No Fix *");
271	break;
272	case LocationProvider.AVAILABLE:
273	System.out.println("@@@ Fix @@@");
274	break;
275	}
276	}
277	catch (Exception e)
278	{
279
280	}
281	}
282	};
283	preciseLocationListener_s = preciseLocationListener;
284
285	/*
286	* Use 2 LocationProviders, one precise (usually GPS), and one
287	* not so precise, but possible faster.
288	*/
289	Criteria highCriteria = null;
290	Criteria lowCriteria = null;
291	try
292	{
293	// Selection criterias for the precise provider
294	highCriteria = new Criteria();
295	highCriteria.setAccuracy(Criteria.ACCURACY_FINE);
296	highCriteria.setAltitudeRequired(true);
297	highCriteria.setBearingRequired(true);
298	//highCriteria.setCostAllowed(true);
299	//highCriteria.setPowerRequirement(Criteria.POWER_HIGH);
300
301	// Selection criterias for the fast provider
302	lowCriteria = new Criteria();
303	lowCriteria.setAccuracy(Criteria.ACCURACY_COARSE);
304	lowCriteria.setAltitudeRequired(false);
305	lowCriteria.setBearingRequired(false);
306	//lowCriteria.setCostAllowed(true);
307	//lowCriteria.setPowerRequirement(Criteria.POWER_HIGH);
308	}
309	catch (Exception e)
310	{
311	e.printStackTrace();
312	}
313
314	try
315	{
316	//Log.e("NavitVehicle", "Providers " + locationManager.getAllProviders());
317
318	preciseProvider = locationManager.getBestProvider(highCriteria, false);
319	preciseProvider_s = preciseProvider;
320	//Log.e("NavitVehicle", "Precise Provider " + preciseProvider);
321	fastProvider = locationManager.getBestProvider(lowCriteria, false);
322	fastProvider_s = fastProvider;
323	//Log.e("NavitVehicle", "Fast Provider " + fastProvider);
324	}
325	catch (Exception e)
326	{
327	e.printStackTrace();
328	}
329
330	try
331	{
332	locationManager.requestLocationUpdates(preciseProvider, 0, 0, preciseLocationListener);
333	}
334	catch (Exception e)
335	{
336	e.printStackTrace();
337	}
338
339	try
340	{
341	// If the 2 providers is the same, only activate one listener
342	if (fastProvider == null \|\| preciseProvider.compareTo(fastProvider) == 0)
343	{
344	fastProvider = null;
345	}
346	else
347	{
348	if (Navit.PREF_use_fast_provider)
349	{
350	locationManager.requestLocationUpdates(fastProvider, 0, 0, fastLocationListener);
351	}
352	}
353	}
354	catch (Exception e)
355	{
356	e.printStackTrace();
357	}
358
359	gps_status_listener_s = new GpsStatus.Listener()
360	{
361	public void onGpsStatusChanged(int event)
362	{
363	if (event == GpsStatus.GPS_EVENT_SATELLITE_STATUS)
364	{
365	// get new gpsstatus --------
366	GpsStatus stat = locationManager.getGpsStatus(null);
367	Navit.sats = 0;
368	Navit.satsInFix = 0;
369
370	try
371	{
372	Iterator<GpsSatellite> localIterator = stat.getSatellites().iterator();
373	while (localIterator.hasNext())
374	{
375	GpsSatellite localGpsSatellite = (GpsSatellite) localIterator.next();
376	Navit.sats++;
377	if (localGpsSatellite.usedInFix())
378	{
379	Navit.satsInFix++;
380	}
381	}
382	// redraw NavitOSDJava
383	Message msg = NavitOSDJava.progress_handler_.obtainMessage();
384	Bundle b = new Bundle();
385	msg.what = 1;
386	msg.setData(b);
387	NavitOSDJava.progress_handler_.sendMessage(msg);
388	}
389	catch (Exception e)
390	{
391	e.printStackTrace();
392	}
393	// Navit.set_debug_messages3_wrapper("sat: " + Navit.satsInFix + "/" + Navit.sats);
394	// System.out.println("Statellites: " + Navit.satsInFix + "/" + Navit.sats);
395	// get new gpsstatus --------
396	}
397	}
398	};
399	}
400
401	public static void set_mock_location__fast(Location mock_location)
402	{
403	try
404	{
405	//locationManager_s.setTestProviderLocation("ZANavi_mock", mock_location);
406	// mock_location;
407	// System.out.println("llllllll" + mock_location.getLatitude() + " " + mock_location.getLongitude());
408	if ((vehicle_callbackid_ != 0) && (mock_location != null))
409	{
410	if (mock_location.getSpeed() == 0.0f)
411	{
412	float save_speed = last_location.getSpeed();
413	mock_location.setSpeed(0.2f);
414	VehicleCallback(vehicle_callbackid_, mock_location);
415	mock_location.setSpeed(save_speed);
416	}
417	else
418	{
419	VehicleCallback(vehicle_callbackid_, mock_location);
420	}
421	}
422	}
423	catch (Exception e)
424	{
425	e.printStackTrace();
426	}
427	}
428
429	public static void set_last_known_pos_precise_provider()
430	{
431	try
432	{
433	Location l = locationManager_s.getLastKnownLocation(preciseProvider_s);
434	if (l != null)
435	{
436	if (l.getAccuracy() > 0)
437	{
438	if ((l.getLatitude() != 0) && (l.getLongitude() != 0))
439	{
440	if (Navit.PREF_follow_gps)
441	{
442	Log.e("NavitVehicle", "getLastKnownLocation precise (2) l=" + l.toString());
443	last_location = l;
444	VehicleCallback(vehicle_callbackid_, l);
445	}
446	}
447	}
448	}
449	}
450	catch (Exception e)
451	{
452	e.printStackTrace();
453	}
454	}
455
456	public static void set_last_known_pos_fast_provider()
457	{
458	try
459	{
460	// If the 2 providers is the same, only activate one listener
461	if (fastProvider_s != null)
462	{
463	if (Navit.PREF_use_fast_provider)
464	{
465	if (!Navit.DemoVehicle)
466	{
467	Location l = locationManager_s.getLastKnownLocation(fastProvider_s);
468	if (l != null)
469	{
470	if (l.getAccuracy() > 0)
471	{
472	if ((l.getLatitude() != 0) && (l.getLongitude() != 0))
473	{
474	if (Navit.PREF_follow_gps)
475	{
476	Log.e("NavitVehicle", "getLastKnownLocation fast (3) l=" + l.toString());
477	last_location = l;
478	VehicleCallback(vehicle_callbackid_, l);
479	}
480	}
481	}
482	}
483	}
484	}
485	}
486	}
487	catch (Exception e)
488	{
489	e.printStackTrace();
490	}
491
492	}
493
494	public static void turn_on_fast_provider()
495	{
496	try
497	{
498	// If the 2 providers is the same, only activate one listener
499	if (fastProvider_s != null)
500	{
501	if (Navit.PREF_use_fast_provider)
502	{
503	if (!Navit.DemoVehicle)
504	{
505	locationManager_s.requestLocationUpdates(fastProvider_s, 0, 0, fastLocationListener_s);
506	}
507	}
508	}
509	}
510	catch (Exception e)
511	{
512	e.printStackTrace();
513	}
514
515	}
516
517	public static void turn_on_precise_provider()
518	{
519	try
520	{
521	locationManager_s.requestLocationUpdates(preciseProvider_s, 0, 0, preciseLocationListener_s);
522	}
523	catch (Exception e)
524	{
525	e.printStackTrace();
526	}
527
528	turn_on_sat_status();
529
530	try
531	{
532	// try to download aGPS data!!
533	if (Navit.PREF_use_agps)
534	{
535	Navit.downloadGPSXtra(Navit.getBaseContext_);
536	}
537	}
538	catch (Exception e)
539	{
540	e.printStackTrace();
541	}
542	}
543
544	public static void turn_off_precise_provider()
545	{
546	try
547	{
548	if (preciseProvider_s != null)
549	{
550	locationManager_s.removeUpdates(preciseLocationListener_s);
551	}
552	}
553	catch (Exception e)
554	{
555	e.printStackTrace();
556	}
557
558	turn_off_sat_status();
559	}
560
561	public static void turn_on_sat_status()
562	{
563	try
564	{
565	Navit.sats = 0;
566	Navit.satsInFix = 0;
567	if (preciseProvider_s != null)
568	{
569	try
570	{
571	locationManager_s.removeGpsStatusListener(gps_status_listener_s);
572	}
573	catch (Exception e3)
574	{
575	e3.printStackTrace();
576	}
577	locationManager_s.addGpsStatusListener(gps_status_listener_s);
578	}
579	}
580	catch (Exception e)
581	{
582	e.printStackTrace();
583	}
584	System.out.println("turn_ON_sat_status");
585	}
586
587	public static void turn_off_sat_status()
588	{
589	try
590	{
591	Navit.sats = 0;
592	Navit.satsInFix = 0;
593	if (preciseProvider_s != null)
594	{
595	locationManager_s.removeGpsStatusListener(gps_status_listener_s);
596	}
597	}
598	catch (Exception e)
599	{
600	e.printStackTrace();
601	}
602	System.out.println("turn_off_sat_status");
603	}
604
605	public static void turn_off_fast_provider()
606	{
607	try
608	{
609	if (fastProvider_s != null)
610	{
611	locationManager_s.removeUpdates(fastLocationListener_s);
612	}
613	}
614	catch (Exception e)
615	{
616	e.printStackTrace();
617	}
618	}
619
620	public static void turn_off_all_providers()
621	{
622	turn_off_precise_provider();
623	turn_off_fast_provider();
624	}
625
626	public Handler vehicle_handler = new Handler()
627	{
628	public void handleMessage(Message msg)
629	{
630	switch (msg.what)
631	{
632	case 1:
633	// dismissDialog(msg.getData().getInt("dialog_num"));
634	// removeDialog(msg.getData().getInt("dialog_num"));
635	Location l = new Location("Network");
636	l.setLatitude(msg.getData().getFloat("lat"));
637	l.setLongitude(msg.getData().getFloat("lng"));
638	l.setBearing(msg.getData().getFloat("b"));
639	l.setSpeed(0.8f);
640	NavitVehicle.set_mock_location__fast(l);
641	break;
642	}
643	}
644	};
645
646	public static void update_compass_heading(float heading)
647	{
648	compass_heading = heading;
649	// use compass heading
650	try
651	{
652	if (Navit.PREF_use_compass_heading_base)
653	{
654	if ((Navit.PREF_use_compass_heading_always) \|\| (last_location.getSpeed() < GPS_SPEED_ABOVE_USE_FOR_HEADING))
655	{
656	last_location.setBearing(compass_heading);
657	// !! ugly hack to make map redraw !!
658	// !! ugly hack to make map redraw !!
659	// !! ugly hack to make map redraw !!
660	if (last_location.getSpeed() == 0.0f)
661	{
662	float save_speed = last_location.getSpeed();
663	last_location.setSpeed(0.2f);
664	if (!Navit.DemoVehicle)
665	{
666	VehicleCallback(vehicle_callbackid_, last_location);
667	}
668	last_location.setSpeed(save_speed);
669	}
670	else
671	{
672	if (!Navit.DemoVehicle)
673	{
674	VehicleCallback(vehicle_callbackid_, last_location);
675	}
676	}
677	// !! ugly hack to make map redraw !!
678	// !! ugly hack to make map redraw !!
679	// !! ugly hack to make map redraw !!
680	}
681	}
682	}
683	catch (Exception e)
684	{
685	//e.printStackTrace();
686	}
687	}
688	}