3D.ru

package com.redsense.speedometer;
import com.unity3d.player.UnityPlayerActivity;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.SystemClock;
import android.util.Config;
import android.util.Log;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class GpsUnityPlayerActivity extends UnityPlayerActivity {

    private static final String TAG = "GPS_Unity";
    private static final int SPLINE_LENGTH = 4;
    private static SplineInterpolator spline = null;
   
    private static LinkedList<Location> lastLocations;
    private static LinkedList<Long> lastLocationTimes;
    public static LocationManager locationManager;  
 
    static LocationListener gpsLocationListener;
   
    public static void startLocationListeners() {        
        gpsLocationListener = new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                lastLocations.add(location);
                lastLocationTimes.add(SystemClock.uptimeMillis());

                if (lastLocations.size() >= SPLINE_LENGTH) { lastLocations.popFirst(); }
                if (lastLocationTimes.size() >= SPLINE_LENGTH) { lastLocationTimes.popFirst(); }

                recreateSpline();

                Log.i(TAG, "Getting Location over <span class=\"posthilit\">GPS</span> " + currentLocation.toString());
            }

            public void onProviderDisabled(String provider) {
            }

            public void onProviderEnabled(String provider) {
            }

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

        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, gpsLocationListener);
    }

    public static float getSpeed()
    {
        float time = SystemClock.uptimeMillis() * 0.001f;
        float extraSpeed = spline.interpolate(time);

        return extraSpeed;
    }

    private void seedLocations(){
        Location location = new Location("");//provider name is unnecessary
        location.setSpeed(0.0f);
        long currentTime = SystemClock.uptimeMillis() - SPLINE_LENGTH * 1000; // shifting time back by SPLINE_LENGTH seconds

        for (int i = 0; i < SPLINE_LENGTH; i++) {
            lastLocations.add(location);
            lastLocationTimes.add(currentTime + i * 1000);
        }
    }

    private static void recreateSpline() {
        final float[] speed = new float[SPLINE_LENGTH + 1];
        final float[] time = new float[SPLINE_LENGTH + 1];
       
        for (int i = 0; i < lastLocations.size(); i++) {
            speed.add(lastLocations[i].getSpeed());
            time.add(lastLocationTimespi[i] * 0.0001f);
        }

        float extraSpeed = speed[SPLINE_LENGTH - 1];
        float extraTime = time[SPLINE_LENGTH - 1] + 10.0f;
        speed[SPLINE_LENGTH] = extraSpeed;
        time[SPLINE_LENGTH] = extraTime;

        spline = SplineInterpolator.createMonotoneCubicSpline(time, speed);
    }
   
    @Override
    protected void onCreate(Bundle myBundle) {
        super.onCreate(myBundle);
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        seedLocations();
        startLocationListeners();
    }

    @Override
    protected void onResume() {
        if (Config.DEBUG)
            Log.d(TAG, "onResume");
        super.onResume();
        startLocationListeners();
    }

    @Override
    protected void onPause()
    {
        locationManager.removeUpdates(gpsLocationListener);
        super.onPause();
    }

    @Override
    protected void onStop() {
        if (Config.DEBUG)
            Log.d(TAG, "onStop");
        locationManager.removeUpdates(gpsLocationListener);
        super.onStop();
    }
}

public class SplineInterpolator {

        private final List<Float> mX;
        private final List<Float> mY;
        private final float[] mM;

        private SplineInterpolator(List<Float> x, List<Float> y, float[] m) {
                mX = x;
                mY = y;
                mM = m;
        }

        public static SplineInterpolator createMonotoneCubicSpline(float[] x, float[] y) {
                if (x == null || y == null || x.length != y.length || x.length < 2) {
                        throw new IllegalArgumentException("There must be at least two control "
                                        + "points and the arrays must be of equal length.");
                }

                final int n = x.length;
                float[] d = new float[n - 1];
                float[] m = new float[n];

                // Compute slopes of secant lines between successive points.
                for (int i = 0; i < n - 1; i++) {
                        float h = x[i + 1] - x[i];
                        if (h <= 0f) {
                                throw new IllegalArgumentException("The control points must all "
                                                + "have strictly increasing X values.");
                        }
                        d[i] = (y[i + 1] - y[i]) / h;
                }

                // Initialize the tangents as the average of the secants.
                m[0] = d[0];
                for (int i = 1; i < n - 1; i++) {
                        m[i] = (d[i - 1] + d[i]) * 0.5f;
                }
                m[n - 1] = d[n - 2];

                // Update the tangents to preserve monotonicity.
                for (int i = 0; i < n - 1; i++) {
                        if (d[i] == 0f) { // successive Y values are equal
                                m[i] = 0f;
                                m[i + 1] = 0f;
                        } else {
                                float a = m[i] / d[i];
                                float b = m[i + 1] / d[i];
                                float h = (float) Math.hypot(a, b);
                                if (h > 9f) {
                                        float t = 3f / h;
                                        m[i] = t * a * d[i];
                                        m[i + 1] = t * b * d[i];
                                }
                        }
                }
                return new SplineInterpolator(x, y, m);
        }

        /**
         * Interpolates the value of Y = f(X) for given X. Clamps X to the domain of the spline.
         *
         * @param x
         *            The X value.
         * @return The interpolated Y = f(X) value.
         */
        public float interpolate(float x) {
                // Handle the boundary cases.
                final int n = mX.size();
                if (Float.isNaN(x)) {
                        return x;
                }
                if (x <= mX.get(0)) {
                        return mY.get(0);
                }
                if (x >= mX.get(n - 1)) {
                        return mY.get(n - 1);
                }

                // Find the index 'i' of the last point with smaller X.
                // We know this will be within the spline due to the boundary tests.
                int i = 0;
                while (x >= mX.get(i + 1)) {
                        i += 1;
                        if (x == mX.get(i)) {
                                return mY.get(i);
                        }
                }

                // Perform cubic Hermite spline interpolation.
                float h = mX.get(i + 1) - mX.get(i);
                float t = (x - mX.get(i)) / h;
                return (mY.get(i) * (1 + 2 * t) + h * mM[i] * t) * (1 - t) * (1 - t)
                                + (mY.get(i + 1) * (3 - 2 * t) + h * mM[i + 1] * (t - 1)) * t * t;
        }
}