internal/location/NmeaParser.java

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.internal.location;

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.TimeZone;

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

/**
 * {@hide}
 */
public class NmeaParser {

    private static final String TAG = "NmeaParser";

    private static final TimeZone sUtcTimeZone = TimeZone.getTimeZone("UTC");

    private static final float KNOTS_TO_METERS_PER_SECOND = 0.51444444444f;

    private final String mName;

    private int mYear = -1;
    private int mMonth;
    private int mDay;

    private long mTime = -1;
    private long mBaseTime;
    private double mLatitude;
    private double mLongitude;

    private boolean mHasAltitude;
    private double mAltitude;
    private boolean mHasBearing;
    private float mBearing;
    private boolean mHasSpeed;
    private float mSpeed;

    private boolean mNewWaypoint = false;
    private Location mLocation = null;
    private Bundle mExtras;

    public NmeaParser(String name) {
        mName = name;
    }

    private boolean updateTime(String time) {
        if (time.length() < 6) {
            return false;
        }
        if (mYear == -1) {
            // Since we haven't seen a day/month/year yet,
            // we can't construct a meaningful time stamp.
            // Clean up any old data.
            mLatitude = 0.0;
            mLongitude = 0.0;
            mHasAltitude = false;
            mHasBearing = false;
            mHasSpeed = false;
            mExtras = null;
            return false;
        }

        int hour, minute;
        float second;
        try {
            hour = Integer.parseInt(time.substring(0, 2));
            minute = Integer.parseInt(time.substring(2, 4));
            second = Float.parseFloat(time.substring(4, time.length()));
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Error parsing timestamp " + time);
            return false;
        }

        int isecond = (int) second;
        int millis = (int) ((second - isecond) * 1000);
        Calendar c = new GregorianCalendar(sUtcTimeZone);
        c.set(mYear, mMonth, mDay, hour, minute, isecond);
        long newTime = c.getTimeInMillis() + millis;

        if (mTime == -1) {
            mTime = 0;
            mBaseTime = newTime;
        }
        newTime -= mBaseTime;

        // If the timestamp has advanced, copy the temporary data
        // into a new Location
        if (newTime != mTime) {
            mNewWaypoint = true;
            mLocation = new Location(mName);
            mLocation.setTime(mTime);
            mLocation.setLatitude(mLatitude);
            mLocation.setLongitude(mLongitude);
            if (mHasAltitude) {
                mLocation.setAltitude(mAltitude);
            }
            if (mHasBearing) {
                mLocation.setBearing(mBearing);
            }
            if (mHasSpeed) {
                mLocation.setSpeed(mSpeed);
            }
            mLocation.setExtras(mExtras);
            mExtras = null;

            mTime = newTime;
            mHasAltitude = false;
            mHasBearing = false;
            mHasSpeed = false;
        }
        return true;
    }

    private boolean updateDate(String date) {
        if (date.length() != 6) {
            return false;
        }
        int month, day, year;
        try {
            day = Integer.parseInt(date.substring(0, 2));
            month = Integer.parseInt(date.substring(2, 4));
            year = 2000 + Integer.parseInt(date.substring(4, 6));
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Error parsing date " + date);
            return false;
        }

        mYear = year;
        mMonth = month;
        mDay = day;
        return true;
    }

    private boolean updateTime(String time, String date) {
        if (!updateDate(date)) {
                return false;
        }
        return updateTime(time);
    }

    private boolean updateIntExtra(String name, String value) {
        int val;
        try {
            val = Integer.parseInt(value);
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Exception parsing int " + name + ": " + value, nfe);
            return false;
        }
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putInt(name, val);
        return true;
    }

    private boolean updateFloatExtra(String name, String value) {
        float val;
        try {
            val = Float.parseFloat(value);
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Exception parsing float " + name + ": " + value, nfe);
            return false;
        }
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putFloat(name, val);
        return true;
    }

    private boolean updateDoubleExtra(String name, String value) {
        double val;
        try {
            val = Double.parseDouble(value);
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Exception parsing double " + name + ": " + value, nfe);
            return false;
        }
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putDouble(name, val);
        return true;
    }

    private double convertFromHHMM(String coord) {
        double val = Double.parseDouble(coord);
        int degrees = ((int) Math.floor(val)) / 100;
        double minutes = val - (degrees * 100);
        double dcoord = degrees + minutes / 60.0;
        return dcoord;
    }

    private boolean updateLatLon(String latitude, String latitudeHemi,
        String longitude, String longitudeHemi) {
        if (latitude.length() == 0 || longitude.length() == 0) {
            return false;
        }

        // Lat/long values are expressed as {D}DDMM.MMMM
        double lat, lon;
        try {
            lat = convertFromHHMM(latitude);
            if (latitudeHemi.charAt(0) == 'S') {
                lat = -lat;
            }
        } catch (NumberFormatException nfe1) {
            Log.e(TAG, "Exception parsing lat/long: " + nfe1, nfe1);
            return false;
        }

        try {
            lon = convertFromHHMM(longitude);
            if (longitudeHemi.charAt(0) == 'W') {
                lon = -lon;
            }
        } catch (NumberFormatException nfe2) {
            Log.e(TAG, "Exception parsing lat/long: " + nfe2, nfe2);
            return false;
        }

        // Only update if both were parsed cleanly
        mLatitude = lat;
        mLongitude = lon;
        return true;
    }

    private boolean updateAltitude(String altitude) {
        if (altitude.length() == 0) {
            return false;
        }
        double alt;
        try {
            alt = Double.parseDouble(altitude);
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Exception parsing altitude " + altitude + ": " + nfe,
                  nfe);
            return false;
        }

        mHasAltitude = true;
        mAltitude = alt;
        return true;
    }

    private boolean updateBearing(String bearing) {
        float brg;
        try {
            brg = Float.parseFloat(bearing);
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Exception parsing bearing " + bearing + ": " + nfe,
                  nfe);
            return false;
        }

        mHasBearing = true;
        mBearing = brg;
        return true;
    }

    private boolean updateSpeed(String speed) {
        float spd;
        try {
            spd = Float.parseFloat(speed) * KNOTS_TO_METERS_PER_SECOND;
        } catch (NumberFormatException nfe) {
            Log.e(TAG, "Exception parsing speed " + speed + ": " + nfe, nfe);
            return false;
        }

        mHasSpeed = true;
        mSpeed = spd;
        return true;
    }

    public boolean parseSentence(String s) {
        int len = s.length();
        if (len < 9) {
            return false;
        }
        if (s.charAt(len - 3) == '*') {
            // String checksum = s.substring(len - 4, len);
            s = s.substring(0, len - 3);
        }
        String[] tokens = s.split(",");
        String sentenceId = tokens[0].substring(3, 6);

        int idx = 1;
        try {
            if (sentenceId.equals("GGA")) {
                String time = tokens[idx++];
                String latitude = tokens[idx++];
                String latitudeHemi = tokens[idx++];
                String longitude = tokens[idx++];
                String longitudeHemi = tokens[idx++];
                String fixQuality = tokens[idx++];
                String numSatellites = tokens[idx++];
                String horizontalDilutionOfPrecision = tokens[idx++];
                String altitude = tokens[idx++];
                String altitudeUnits = tokens[idx++];
                String heightOfGeoid = tokens[idx++];
                String heightOfGeoidUnits = tokens[idx++];
                String timeSinceLastDgpsUpdate = tokens[idx++];

                updateTime(time);
                updateLatLon(latitude, latitudeHemi,
                        longitude, longitudeHemi);
                updateAltitude(altitude);
                // updateQuality(fixQuality);
                updateIntExtra("numSatellites", numSatellites);
                updateFloatExtra("hdop", horizontalDilutionOfPrecision);

                if (mNewWaypoint) {
                    mNewWaypoint = false;
                    return true;
                }
            } else if (sentenceId.equals("GSA")) {
                // DOP and active satellites
                String selectionMode = tokens[idx++]; // m=manual, a=auto 2d/3d
                String mode = tokens[idx++]; // 1=no fix, 2=2d, 3=3d
                for (int i = 0; i < 12; i++) {
                    String id = tokens[idx++];
                }
                String pdop = tokens[idx++];
                String hdop = tokens[idx++];
                String vdop = tokens[idx++];

                // TODO - publish satellite ids
                updateFloatExtra("pdop", pdop);
                updateFloatExtra("hdop", hdop);
                updateFloatExtra("vdop", vdop);
            } else if (sentenceId.equals("GSV")) {
                // Satellites in view
                String numMessages = tokens[idx++];
                String messageNum = tokens[idx++];
                String svsInView = tokens[idx++];
                for (int i = 0; i < 4; i++) {
                    if (idx + 2 < tokens.length) {
                        String prnNumber = tokens[idx++];
                        String elevation = tokens[idx++];
                        String azimuth = tokens[idx++];
                        if (idx < tokens.length) {
                            String snr = tokens[idx++];
                        }
                    }
                }
                // TODO - publish this info
            } else if (sentenceId.equals("RMC")) {
                // Recommended minimum navigation information
                String time = tokens[idx++];
                String fixStatus = tokens[idx++];
                String latitude = tokens[idx++];
                String latitudeHemi = tokens[idx++];
                String longitude = tokens[idx++];
                String longitudeHemi = tokens[idx++];
                String speed = tokens[idx++];
                String bearing = tokens[idx++];
                String utcDate = tokens[idx++];
                String magneticVariation = tokens[idx++];
                String magneticVariationDir = tokens[idx++];
                String mode = tokens[idx++];

                if (fixStatus.charAt(0) == 'A') {
                    updateTime(time, utcDate);
                    updateLatLon(latitude, latitudeHemi,
                        longitude, longitudeHemi);
                    updateBearing(bearing);
                    updateSpeed(speed);
                }

                if (mNewWaypoint) {
                    return true;
                }
            } else {
                Log.e(TAG, "Unknown sentence: " + s);
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            // do nothing - sentence will have no effect
            Log.e(TAG, "AIOOBE", e);

            for (int i = 0; i < tokens.length; i++) {
                Log.e(TAG, "Got token #" + i + " = " + tokens[i]);
            }
        }

        return false;
    }

//  } else if (sentenceId.equals("GLL")) {
//  // Geographics position lat/long
//  String latitude = tokens[idx++];
//  String latitudeHemi = tokens[idx++];
//  String longitude = tokens[idx++];
//  String longitudeHemi = tokens[idx++];
//  String time = tokens[idx++];
//  String status = tokens[idx++];
//  String mode = tokens[idx++];
//  String checksum = tokens[idx++];
//
//  if (status.charAt(0) == 'A') {
//      updateTime(time);
//      updateLatLon(latitude, latitudeHemi, longitude, longitudeHemi);
//  }
//} else if (sentenceId.equals("VTG")) {
//    String trackMadeGood = tokens[idx++];
//    String t = tokens[idx++];
//    String unused1 = tokens[idx++];
//    String unused2 = tokens[idx++];
//    String groundSpeedKnots = tokens[idx++];
//    String n = tokens[idx++];
//    String groundSpeedKph = tokens[idx++];
//    String k = tokens[idx++];
//    String checksum = tokens[idx++];
//
//    updateSpeed(groundSpeedKph);

    public Location getLocation() {
        return mLocation;
    }
}