android.location.OnNmeaMessageListener - java examples

Here are the examples of the java api android.location.OnNmeaMessageListener taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

3 Examples 7

16 View Complete Implementation : GpsActivity.java
Copyright Apache License 2.0
Author : androidthings
public clreplaced GpsActivity extends Activity {

    private static final String TAG = "GpsActivity";

    public static final int UART_BAUD = 9600;

    // From GPS datasheet
    public static final float ACCURACY = 2.5f;

    private LocationManager mLocationManager;

    private NmeaGpsDriver mGpsDriver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mLocationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
        // We need permission to get location updates
        if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // A problem occurred auto-granting the permission
            Log.d(TAG, "No permission");
            return;
        }
        try {
            // Register the GPS driver
            mGpsDriver = new NmeaGpsDriver(this, BoardDefaults.getUartName(), UART_BAUD, ACCURACY);
            mGpsDriver.register();
            // Register for location updates
            mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, mLocationListener);
            mLocationManager.registerGnssStatusCallback(mStatusCallback);
            mLocationManager.addNmeaListener(mMessageListener);
        } catch (IOException e) {
            Log.w(TAG, "Unable to open GPS UART", e);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Verify permission was granted
        if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "No permission");
            return;
        }
        if (mGpsDriver != null) {
            // Unregister components
            mGpsDriver.unregister();
            mLocationManager.removeUpdates(mLocationListener);
            mLocationManager.unregisterGnssStatusCallback(mStatusCallback);
            mLocationManager.removeNmeaListener(mMessageListener);
            try {
                mGpsDriver.close();
            } catch (IOException e) {
                Log.w(TAG, "Unable to close GPS driver", e);
            }
        }
    }

    /**
     * Report location updates
     */
    private LocationListener mLocationListener = new LocationListener() {

        @Override
        public void onLocationChanged(Location location) {
            Log.v(TAG, "Location update: " + location);
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {
        }

        @Override
        public void onProviderEnabled(String provider) {
        }

        @Override
        public void onProviderDisabled(String provider) {
        }
    };

    /**
     * Report satellite status
     */
    private GnssStatus.Callback mStatusCallback = new GnssStatus.Callback() {

        @Override
        public void onStarted() {
        }

        @Override
        public void onStopped() {
        }

        @Override
        public void onFirstFix(int ttffMillis) {
        }

        @Override
        public void onSatelliteStatusChanged(GnssStatus status) {
            Log.v(TAG, "GNSS Status: " + status.getSatelliteCount() + " satellites.");
        }
    };

    /**
     * Report raw NMEA messages
     */
    private OnNmeaMessageListener mMessageListener = new OnNmeaMessageListener() {

        @Override
        public void onNmeaMessage(String message, long timestamp) {
            Log.v(TAG, "NMEA: " + message);
        }
    };
}

16 View Complete Implementation : GnssContainer.java
Copyright Apache License 2.0
Author : google
/**
 * A container for GPS related API calls, it binds the {@link LocationManager} with {@link UiLogger}
 */
public clreplaced GnssContainer {

    public static final String TAG = "GnssLogger";

    private static final long LOCATION_RATE_GPS_MS = TimeUnit.SECONDS.toMillis(1L);

    private static final long LOCATION_RATE_NETWORK_MS = TimeUnit.SECONDS.toMillis(60L);

    private boolean mLogLocations = true;

    private boolean mLogNavigationMessages = true;

    private boolean mLogMeasurements = true;

    private boolean mLogStatuses = true;

    private boolean mLogNmeas = true;

    private long registrationTimeNanos = 0L;

    private long firstLocationTimeNanos = 0L;

    private long ttff = 0L;

    private boolean firstTime = true;

    private final List<GnssListener> mLoggers;

    private final LocationManager mLocationManager;

    private final LocationListener mLocationListener = new LocationListener() {

        @Override
        public void onProviderEnabled(String provider) {
            if (mLogLocations) {
                for (GnssListener logger : mLoggers) {
                    if (logger instanceof AgnssUiLogger && !firstTime) {
                        continue;
                    }
                    logger.onProviderEnabled(provider);
                }
            }
        }

        @Override
        public void onProviderDisabled(String provider) {
            if (mLogLocations) {
                for (GnssListener logger : mLoggers) {
                    if (logger instanceof AgnssUiLogger && !firstTime) {
                        continue;
                    }
                    logger.onProviderDisabled(provider);
                }
            }
        }

        @Override
        public void onLocationChanged(Location location) {
            if (firstTime && location.getProvider().equals(LocationManager.GPS_PROVIDER)) {
                if (mLogLocations) {
                    for (GnssListener logger : mLoggers) {
                        firstLocationTimeNanos = SystemClock.elapsedRealtimeNanos();
                        ttff = firstLocationTimeNanos - registrationTimeNanos;
                        logger.onTTFFReceived(ttff);
                    }
                }
                firstTime = false;
            }
            if (mLogLocations) {
                for (GnssListener logger : mLoggers) {
                    if (logger instanceof AgnssUiLogger && !firstTime) {
                        continue;
                    }
                    logger.onLocationChanged(location);
                }
            }
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {
            if (mLogLocations) {
                for (GnssListener logger : mLoggers) {
                    logger.onLocationStatusChanged(provider, status, extras);
                }
            }
        }
    };

    private final GnssMeasurementsEvent.Callback gnssMeasurementsEventListener = new GnssMeasurementsEvent.Callback() {

        @Override
        public void onGnssMeasurementsReceived(GnssMeasurementsEvent event) {
            if (mLogMeasurements) {
                for (GnssListener logger : mLoggers) {
                    logger.onGnssMeasurementsReceived(event);
                }
            }
        }

        @Override
        public void onStatusChanged(int status) {
            if (mLogMeasurements) {
                for (GnssListener logger : mLoggers) {
                    logger.onGnssMeasurementsStatusChanged(status);
                }
            }
        }
    };

    private final GnssNavigationMessage.Callback gnssNavigationMessageListener = new GnssNavigationMessage.Callback() {

        @Override
        public void onGnssNavigationMessageReceived(GnssNavigationMessage event) {
            if (mLogNavigationMessages) {
                for (GnssListener logger : mLoggers) {
                    logger.onGnssNavigationMessageReceived(event);
                }
            }
        }

        @Override
        public void onStatusChanged(int status) {
            if (mLogNavigationMessages) {
                for (GnssListener logger : mLoggers) {
                    logger.onGnssNavigationMessageStatusChanged(status);
                }
            }
        }
    };

    private final GnssStatus.Callback gnssStatusListener = new GnssStatus.Callback() {

        @Override
        public void onStarted() {
        }

        @Override
        public void onStopped() {
        }

        @Override
        public void onFirstFix(int ttff) {
        }

        @Override
        public void onSatelliteStatusChanged(GnssStatus status) {
            for (GnssListener logger : mLoggers) {
                logger.onGnssStatusChanged(status);
            }
        }
    };

    private final OnNmeaMessageListener nmeaListener = new OnNmeaMessageListener() {

        @Override
        public void onNmeaMessage(String s, long l) {
            if (mLogNmeas) {
                for (GnssListener logger : mLoggers) {
                    logger.onNmeaReceived(l, s);
                }
            }
        }
    };

    public GnssContainer(Context context, GnssListener... loggers) {
        this.mLoggers = Arrays.asList(loggers);
        mLocationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
    }

    public LocationManager getLocationManager() {
        return mLocationManager;
    }

    public void setLogLocations(boolean value) {
        mLogLocations = value;
    }

    public boolean canLogLocations() {
        return mLogLocations;
    }

    public void setLogNavigationMessages(boolean value) {
        mLogNavigationMessages = value;
    }

    public boolean canLogNavigationMessages() {
        return mLogNavigationMessages;
    }

    public void setLogMeasurements(boolean value) {
        mLogMeasurements = value;
    }

    public boolean canLogMeasurements() {
        return mLogMeasurements;
    }

    public void setLogStatuses(boolean value) {
        mLogStatuses = value;
    }

    public boolean canLogStatuses() {
        return mLogStatuses;
    }

    public void setLogNmeas(boolean value) {
        mLogNmeas = value;
    }

    public boolean canLogNmeas() {
        return mLogNmeas;
    }

    public void registerLocation() {
        boolean isGpsProviderEnabled = mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        if (isGpsProviderEnabled) {
            mLocationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, LOCATION_RATE_NETWORK_MS, 0.0f, /* minDistance */
            mLocationListener);
            mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, LOCATION_RATE_GPS_MS, 0.0f, /* minDistance */
            mLocationListener);
        }
        logRegistration("LocationUpdates", isGpsProviderEnabled);
    }

    public void registerSingleNetworkLocation() {
        boolean isNetworkProviderEnabled = mLocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        if (isNetworkProviderEnabled) {
            mLocationManager.requestSingleUpdate(LocationManager.NETWORK_PROVIDER, mLocationListener, null);
        }
        logRegistration("LocationUpdates", isNetworkProviderEnabled);
    }

    public void registerSingleGpsLocation() {
        boolean isGpsProviderEnabled = mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        if (isGpsProviderEnabled) {
            this.firstTime = true;
            registrationTimeNanos = SystemClock.elapsedRealtimeNanos();
            mLocationManager.requestSingleUpdate(LocationManager.GPS_PROVIDER, mLocationListener, null);
        }
        logRegistration("LocationUpdates", isGpsProviderEnabled);
    }

    public void unregisterLocation() {
        mLocationManager.removeUpdates(mLocationListener);
    }

    public void registerMeasurements() {
        logRegistration("GnssMeasurements", mLocationManager.registerGnssMeasurementsCallback(gnssMeasurementsEventListener));
    }

    public void unregisterMeasurements() {
        mLocationManager.unregisterGnssMeasurementsCallback(gnssMeasurementsEventListener);
    }

    public void registerNavigation() {
        logRegistration("GpsNavigationMessage", mLocationManager.registerGnssNavigationMessageCallback(gnssNavigationMessageListener));
    }

    public void unregisterNavigation() {
        mLocationManager.unregisterGnssNavigationMessageCallback(gnssNavigationMessageListener);
    }

    public void registerGnssStatus() {
        logRegistration("GnssStatus", mLocationManager.registerGnssStatusCallback(gnssStatusListener));
    }

    public void unregisterGpsStatus() {
        mLocationManager.unregisterGnssStatusCallback(gnssStatusListener);
    }

    public void registerNmea() {
        logRegistration("Nmea", mLocationManager.addNmeaListener(nmeaListener));
    }

    public void unregisterNmea() {
        mLocationManager.removeNmeaListener(nmeaListener);
    }

    public void registerAll() {
        registerLocation();
        registerMeasurements();
        registerNavigation();
        registerGnssStatus();
        registerNmea();
    }

    public void unregisterAll() {
        unregisterLocation();
        unregisterMeasurements();
        unregisterNavigation();
        unregisterGpsStatus();
        unregisterNmea();
    }

    private void logRegistration(String listener, boolean result) {
        for (GnssListener logger : mLoggers) {
            if (logger instanceof AgnssUiLogger && !firstTime) {
                continue;
            }
            logger.onListenerRegistration(listener, result);
        }
    }
}

15 View Complete Implementation : MapFragment.java
Copyright Apache License 2.0
Author : Pygmalion69
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setHasOptionsMenu(true);
    setRetainInstance(true);
    Context context = requireActivity().getApplicationContext();
    IConfigurationProvider configuration = Configuration.getInstance();
    configuration.setUserAgentValue(BuildConfig.APPLICATION_ID);
    configuration.load(context, PreferenceManager.getDefaultSharedPreferences(context));
    mPrefs = requireActivity().getSharedPreferences(MAP_PREFS, Context.MODE_PRIVATE);
    mBaseMap = mPrefs.getInt(PREF_BASE_MAP, BASE_MAP_OTM);
    mOverlay = mPrefs.getInt(PREF_OVERLAY, OverlayHelper.OVERLAY_NONE);
    mLocationManager = (LocationManager) requireActivity().getSystemService(Context.LOCATION_SERVICE);
    mLocationViewModel = new ViewModelProvider(requireActivity()).get(LocationViewModel.clreplaced);
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
        OnNmeaMessageListener nmeaListener = (s, l) -> {
            if (mLocationViewModel != null && mLocationViewModel.getCurrentNmea() != null) {
                mLocationViewModel.getCurrentNmea().setValue(s);
            }
        };
        if (requireActivity().checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            mLocationManager.addNmeaListener(nmeaListener);
        }
    } else {
        GpsStatus.NmeaListener nmeaListener = (l, s) -> {
            if (mLocationViewModel != null && mLocationViewModel.getCurrentNmea() != null) {
                mLocationViewModel.getCurrentNmea().setValue(s);
            }
        };
        mLocationManager.addNmeaListener(nmeaListener);
    }
}