升级程序的Android API

Question

我的教授有一个程序，我试图帮助hime升级，不幸的是我对Android非常新。它是一个程序，应该抓住你的Android的位置，并定期发送到服务器（大约每5秒）。但升级后使用API​​ 21（它是10-14），它只会返回我的位置0.0。有谁知道这可能导致了什么？

这是Main

import java.text.DecimalFormat;
import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Color;
import android.location.LocationManager;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity
{
protected Button panic;
protected Button track;

private TextView latText;
private TextView lngText;
private TextView addressText;

private boolean panicking;
private boolean tracking;

protected Context mContext;
private Timer locTimer;
private final String TAG = "MainActivity";
protected Sender send;

private int trackingOn;
private int trackingOff;
private int panicOn;
private int panicOff;


@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);
    tracking = false;
    panicking = false;

    //colors
    trackingOff = Color.rgb(100, 255, 100);
    trackingOn = Color.rgb(255, 255, 100);
    panicOff = Color.rgb(255, 50, 50);
    panicOn = Color.rgb(255, 127, 0);

    setupSender();
    setupView();
    //createGPS();
    checkGPS();
    //create GPS service
    Intent trackIntent = new Intent(MainActivity.this, TrackingService.class);
    startService(trackIntent);

    createTimer();
}

@Override
public boolean onCreateOptionsMenu(Menu menu)
{
    getMenuInflater().inflate(R.menu.activity_main, menu);
    return true;
}

@Override
public void onDestroy()
{
    locTimer.cancel();
    super.onDestroy();
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
    if(keyCode == KeyEvent.KEYCODE_BACK)
    {
        Log.d(TAG, "Back pressed");

        //create dialog to turn off GPS
        //if not then ask the user to turn it on
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setMessage("Would you like to turn off the GPS?");
        builder.setCancelable(false);

        //yes
        builder.setPositiveButton("Disable GPS in device settings", new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                Intent callGPSSettingIntent = new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                startActivity(callGPSSettingIntent);
                finish();
            }
        });

        //no
        builder.setNegativeButton("No", new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                dialog.cancel();
                finish();
            }
        });

        AlertDialog gpsAlert = builder.create();
        gpsAlert.show();
    }

    return super.onKeyDown(keyCode, event);
}

private void setupSender()
{
    //get MAC address
    WifiManager wifiMan = (WifiManager) this.getSystemService(Context.WIFI_SERVICE);
    WifiInfo wifiInf = wifiMan.getConnectionInfo();
    String macAddr = wifiInf.getMacAddress();

    //get phone Number
    TelephonyManager teleMan = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE);
    String phoneNumber = teleMan.getLine1Number();

    Log.d(TAG, "My mac: " + macAddr + "    My number: " + phoneNumber);

    send = new Sender(macAddr, phoneNumber);
}

private class SendTracking extends AsyncTask<String, String, String>
{
    @Override
    protected String doInBackground(String... arg0)
    {
        send.sendTrack(Values.lat, Values.lng, Values.myAddress, Values.acc);
        return null;
    }
}

private class SendPanic extends AsyncTask<String, String, String>
{
    @Override
    protected String doInBackground(String... arg0)
    {
        send.sendPanic(Values.lat, Values.lng, Values.myAddress, Values.acc);
        return null;
    }
}

private void setupView()
{
    latText = (TextView)findViewById(R.id.lattitude);
    lngText = (TextView)findViewById(R.id.longitude);
    addressText = (TextView)findViewById(R.id.address);

    // create tracking button
    track = (Button)findViewById(R.id.trackMe);
    track.setBackgroundColor(trackingOff);
    track.setOnClickListener(new OnClickListener()
    {
        public void onClick(View arg0)
        {
            tracking = !tracking;
            Log.w(TAG, "Tracking button pressed");

            if(tracking)
            {
                track.setBackgroundColor(trackingOn);
                track.setText(getResources().getString(R.string.stopTrack));
                Values.interval = Values.TRACK_INTERVAL; //set it so it sends right away
            }
            else
            {
                new SendTracking().execute();
                track.setBackgroundColor(trackingOff);
                track.setText(getResources().getString(R.string.tracker));
            }
        }
    });

    // create panic button
    panic = (Button) findViewById(R.id.panic);
    panic.setBackgroundColor(panicOff);
    panic.setOnClickListener(new OnClickListener()
    {
        @Override
        public void onClick(View arg0)
        {
            Log.w(TAG, "Panic Pressed");
            panicking = !panicking;

            //send.sendPanic(Values.lat, Values.lng, Values.myAddress, Values.acc);
            if(panicking)
            {
                panic.setBackgroundColor(panicOn);
                panic.setText(getResources().getString(R.string.stopPanic));
                Values.interval = Values.TRACK_INTERVAL; //set it so it sends right away
            }
            else
            {
                panic.setBackgroundColor(panicOff);
                panic.setText(getResources().getString(R.string.panic));
            }
        }
    });
}

private void createTimer()
{
    //decimal formatter
    final DecimalFormat format = new DecimalFormat("#.###");

    // create runnable for timer
    final Runnable updateLoc = new Runnable()
    {
        @Override
        public void run()
        {
            Log.i(TAG, "Updating loc");

            latText.setText("" + format.format(Values.lat));
            lngText.setText("" + format.format(Values.lng));
            addressText.setText(Values.myAddress);

            //send to DB if tracking is on and enough time has passed since last update
            if(tracking)
            {
                if (Values.interval >= Values.TRACK_INTERVAL)
                {
                    new SendTracking().execute();
                    Values.interval = 0;
                }
                else
                {
                    Values.interval++;
                }
            }
            else if(panicking)
            {
                if (Values.interval >= Values.TRACK_INTERVAL)
                {
                    new SendPanic().execute();
                    Values.interval = 0;
                }
                else
                {
                    Values.interval++;
                }
            }
        }
    };

    // create timer that will check for location
    locTimer = new Timer("LocTimer");

    locTimer.scheduleAtFixedRate(new TimerTask()
    {
        @Override
        public void run()
        {
            runOnUiThread(updateLoc);
        }
    }, Values.UPDATE_TIMER / 2, Values.UPDATE_TIMER);
}

private void checkGPS()
{
    LocationManager manager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
    //check to see if GPS is enabled
    if(!manager.isProviderEnabled(LocationManager.GPS_PROVIDER))
    {
        //if not then ask the user to turn it on
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setMessage("GPS is currently disabled.  Please turn it on");
        builder.setCancelable(false);

        //yes
        builder.setPositiveButton("Enabled GPS in device settings", new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                Intent callGPSSettingIntent = new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                startActivity(callGPSSettingIntent);
            }
        });

        //no
        builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                dialog.cancel();
            }
        });

        AlertDialog gpsAlert = builder.create();
        gpsAlert.show();
    }
}
}

这是跟踪服务

import java.io.IOException;
import java.util.List;
import java.util.Locale;

import android.Manifest;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.location.Address;
import android.location.Geocoder;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Build;
import android.os.Bundle;
import android.os.IBinder;
import android.support.v4.app.ActivityCompat;
import android.util.Log;

public class TrackingService extends Service {
    private LocationManager manager;
    private LocationListener listener;

    private final String TAG = "TrackingService";

    public class LocalBinder extends Binder {
        TrackingService getService() {
            return TrackingService.this;
        }
    }

    public IBinder onBind(Intent arg0) {
        return new LocalBinder();
    }

    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand");

        // We want this service to continue running until it is explicitly
        // stopped, so return sticky.
        return START_STICKY;
    }


    public void onStart(Intent intent, int startId) {
        Log.d(TAG, "Starting service");
        this.onStart(intent, startId);
    }

    public void onCreate() {
        Log.d(TAG, "Creating service");
        this.createGPS();
    }

    public void onDestroy() {
        Log.d(TAG, "Killing service");
        manager.removeUpdates(listener);
        super.onDestroy();
    }

    private LocationManager createGPS() {
        // create GPS service
        manager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);

        //context
        final Context context = this;

        // make listener
        listener = new LocationListener() {
            @Override
            public void onLocationChanged(Location location) {
                Log.d(TAG, "GPS udpate");

                Values.lat = location.getLatitude();
                Values.lng = location.getLongitude();
                Values.acc = location.getAccuracy();

                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && Geocoder.isPresent()) {
                    // Since the geocoding API is synchronous and may take a while.  You don't want to lock
                    // up the UI thread.  Invoking reverse geocoding in an AsyncTask.
                    (new ReverseGeocodingTask(context)).execute(new Location[]{location});
                }
            }

            @Override
            public void onProviderDisabled(String provider) {
            }

            @Override
            public void onProviderEnabled(String provider) {
            }

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

        // register listener
        manager.requestLocationUpdates(LocationManager.GPS_PROVIDER, Values.UPDATE_TIMER, 10f, listener);
        manager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, Values.UPDATE_TIMER, 10f, listener);

        return manager;
    }



    // AsyncTask encapsulating the reverse-geocoding API.  Since the geocoder API is blocked,
    // we do not want to invoke it from the UI thread.
    private class ReverseGeocodingTask extends AsyncTask<Location, Void, Void>
    {
        Context mContext;

        public ReverseGeocodingTask(Context context)
        {
            super();
            mContext = context;
        }

        @Override
        protected Void doInBackground(Location... params)
        {
            Geocoder geocoder = new Geocoder(mContext, Locale.getDefault());

            Location loc = params[0];
            List<Address> addresses = null;
            try
            {
                // Call the synchronous getFromLocation() method by passing in the lat/long values.
                addresses = geocoder.getFromLocation(loc.getLatitude(), loc.getLongitude(), 1);
            }
            catch (IOException e)
            {
                e.printStackTrace();
                // Update UI field with the exception.
                //Message.obtain(mHandler, UPDATE_ADDRESS, e.toString()).sendToTarget();
                Log.e("ReverseGeoCoder", "error: " + e.toString());
            }
            if (addresses != null && addresses.size() > 0)
            {
                Address address = addresses.get(0);
                // Format the first line of address (if available), city, and country name.
                String addressText = String.format("%s, %s, %s",
                        address.getMaxAddressLineIndex() > 0 ? address.getAddressLine(0) : "",
                        address.getLocality(),
                        address.getCountryName());
                // Update the UI via a message handler.
                //Message.obtain(mHandler, UPDATE_ADDRESS, addressText).sendToTarget();
                Log.d("ReverseGeoCoder", "address: " + addressText);
                Values.myAddress = addressText;
            }
            return null;
        }
    }
}

以前工作得很好，我看过跟踪日志，但现在它只返回0.0。