Googleロケーションサービスは更新されません

Question

私はこれを過去48時間にわたって把握しようとしましたが、私は馬鹿でなければなりません。私は、この天気アプリの位置を認識させるために、Googleのドキュメントに従っています。問題は、onLocationChanged（）を実行する方法や、いつ実行するのかを知ることではないということです。それが実行されない場合、私は緯度0と経度0からデータを取得する要求を送信します。私はすべての適切な権限を有効にしました。助けてください...

package com.brennanglynn.brennanweather.ui; 

import android.Manifest; 
import android.app.Activity; 
import android.content.Context; 
import android.content.Intent; 
import android.content.pm.PackageManager; 
import android.graphics.drawable.Drawable; 
import android.graphics.drawable.GradientDrawable; 
import android.location.Location; 
import android.net.ConnectivityManager; 
import android.net.NetworkInfo; 
import android.os.Bundle; 
import android.support.v4.app.ActivityCompat; 
import android.support.v4.content.res.ResourcesCompat; 
import android.util.Log; 
import android.view.View; 
import android.widget.ImageView; 
import android.widget.ProgressBar; 
import android.widget.RelativeLayout; 
import android.widget.TextView; 

import com.brennanglynn.brennanweather.R; 
import com.brennanglynn.brennanweather.weather.Current; 
import com.brennanglynn.brennanweather.weather.Day; 
import com.brennanglynn.brennanweather.weather.Forecast; 
import com.brennanglynn.brennanweather.weather.Hour; 
import com.google.android.gms.common.ConnectionResult; 
import com.google.android.gms.common.api.GoogleApiClient; 
import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks; 
import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener; 
import com.google.android.gms.location.LocationListener; 
import com.google.android.gms.location.LocationRequest; 
import com.google.android.gms.location.LocationServices; 

import org.json.JSONArray; 
import org.json.JSONException; 
import org.json.JSONObject; 

import java.io.IOException; 
import java.text.DateFormat; 
import java.util.Date; 

import butterknife.BindView; 
import butterknife.ButterKnife; 
import butterknife.OnClick; 
import okhttp3.Call; 
import okhttp3.Callback; 
import okhttp3.OkHttpClient; 
import okhttp3.Request; 
import okhttp3.Response; 


public class MainActivity extends Activity implements ConnectionCallbacks, OnConnectionFailedListener, LocationListener { 

    public static final long UPDATE_INTERVAL_IN_MILLISECONDS = 10000; 
    public static final long FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS = UPDATE_INTERVAL_IN_MILLISECONDS/2; 
    public static final String TAG = MainActivity.class.getSimpleName(); 
    protected final static String REQUESTING_LOCATION_UPDATES_KEY = "requesting-location-updates-key"; 
    protected final static String LOCATION_KEY = "location-key"; 
    protected final static String LAST_UPDATED_TIME_STRING_KEY = "last-updated-time-string-key"; 
    public static final String DAILY_FORECAST = "DAILY_FORECAST"; 
    public static final String HOURLY_FORECAST = "HOURLY_FORECAST"; 
    public static final String BG_GRADIENT = "BG_GRADIENT"; 

    private Forecast mForecast; 
    private ColorWheel mColorWheel; 
    private int[] mBackground; 

    protected GoogleApiClient mGoogleApiClient; 
    protected LocationRequest mLocationRequest; 
    protected Location mCurrentLocation; 
    protected Boolean mRequestingLocationUpdates; 
    protected String mLastUpdateTime; 

    private double mLatitude; 
    private double mLongitude;// = -116.2296; 

    @BindView(R.id.layoutBackground) 
    RelativeLayout mLayoutBackground; 
    @BindView(R.id.timeLabel) 
    TextView mTimeLabel; 
    @BindView(R.id.temperatureLabel) 
    TextView mTemperatureLabel; 
    @BindView(R.id.humidityValue) 
    TextView mHumidityValue; 
    @BindView(R.id.precipValue) 
    TextView mPrecipValue; 
    @BindView(R.id.summaryLabel) 
    TextView mSummaryLabel; 
    @BindView(R.id.iconImageView) 
    ImageView mIconImageView; 
    @BindView(R.id.refreshImageView) 
    ImageView mRefreshImageView; 
    @BindView(R.id.progressBar) 
    ProgressBar mProgressBar; 
    @BindView(R.id.locationLabel) 
    TextView mLocationLabel; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     ButterKnife.bind(this); 

     mRequestingLocationUpdates = false; 
     mLastUpdateTime = ""; 

     updateValuesFromBundle(savedInstanceState); 
     buildGoogleApiClient(); 

     mColorWheel = new ColorWheel(); 
     mProgressBar.setVisibility(View.INVISIBLE); 
    } 

    private void updateValuesFromBundle(Bundle savedInstanceState) { 
     Log.i(TAG, "Updating values from bundle"); 
     if (savedInstanceState != null) { 
      // Update the value of mRequestingLocationUpdates from the Bundle, and make sure that 
      // the Start Updates and Stop Updates buttons are correctly enabled or disabled. 
      if (savedInstanceState.keySet().contains(REQUESTING_LOCATION_UPDATES_KEY)) { 
       mRequestingLocationUpdates = savedInstanceState.getBoolean(
         REQUESTING_LOCATION_UPDATES_KEY); 
      } 

      // Update the value of mCurrentLocation from the Bundle and update the UI to show the 
      // correct latitude and longitude. 
      if (savedInstanceState.keySet().contains(LOCATION_KEY)) { 
       // Since LOCATION_KEY was found in the Bundle, we can be sure that mCurrentLocation 
       // is not null. 
       mCurrentLocation = savedInstanceState.getParcelable(LOCATION_KEY); 
      } 

      // Update the value of mLastUpdateTime from the Bundle and update the UI. 
      if (savedInstanceState.keySet().contains(LAST_UPDATED_TIME_STRING_KEY)) { 
       mLastUpdateTime = savedInstanceState.getString(LAST_UPDATED_TIME_STRING_KEY); 
      } 
      updateDisplay(); 
     } 
    } 

    protected synchronized void buildGoogleApiClient() { 
     Log.i(TAG, "Building GoogleApiClient"); 
     mGoogleApiClient = new GoogleApiClient.Builder(this) 
       .addConnectionCallbacks(this) 
       .addOnConnectionFailedListener(this) 
       .addApi(LocationServices.API) 
       .build(); 
     createLocationRequest(); 
    } 

    private void setBackgroundGradient() { 
     mBackground = mColorWheel.getColors(); 

     GradientDrawable gd = new GradientDrawable(
       GradientDrawable.Orientation.TOP_BOTTOM, 
       new int[]{mBackground[0], mBackground[1]}); 
     gd.setCornerRadius(0f); 

     mLayoutBackground.setBackground(gd); 
    } 

    private void getForecast(double latitude, double longitude) { 
     String apiKey = "50e826df5889d0d215cdcbae50d182e3"; 
     String forecastUrl = "https://api.forecast.io/forecast/" + apiKey + 
       "/" + latitude + "," + longitude; 

     if (isNetworkAvailable()) { 
      toggleRefresh(); 

      OkHttpClient client = new OkHttpClient(); 
      Request request = new Request.Builder() 
        .url(forecastUrl) 
        .build(); 

      Call call = client.newCall(request); 
      call.enqueue(new Callback() { 
       @Override 
       public void onFailure(Call call, IOException e) { 
        runOnUiThread(new Runnable() { 
         @Override 
         public void run() { 
          toggleRefresh(); 
         } 
        }); 
        alertUserAboutError(); 
       } 

       @Override 
       public void onResponse(Call call, Response response) throws IOException { 
        runOnUiThread(new Runnable() { 
         @Override 
         public void run() { 
          toggleRefresh(); 
         } 
        }); 
        try { 
         String jsonData = response.body().string(); 
         Log.v(TAG, jsonData); 
         if (response.isSuccessful()) { 
          mForecast = parseForecastDetails(jsonData); 
          runOnUiThread(new Runnable() { 
           @Override 
           public void run() { 
            updateDisplay(); 
           } 
          }); 
         } else { 
          alertUserAboutError(); 
         } 
        } catch (IOException | JSONException e) { 
         Log.e(TAG, "Exception caught: ", e); 
        } 
       } 
      }); 
     } else { 
      alertUserAboutError(); 
     } 
     Log.i(TAG, forecastUrl); 
    } 

    private void toggleRefresh() { 
     if (mProgressBar.getVisibility() == View.INVISIBLE) { 
      mProgressBar.setVisibility(View.VISIBLE); 
      mRefreshImageView.setVisibility(View.INVISIBLE); 
     } else { 
      mProgressBar.setVisibility(View.INVISIBLE); 
      mRefreshImageView.setVisibility(View.VISIBLE); 
     } 
    } 

    private Forecast parseForecastDetails(String jsonData) throws JSONException { 
     Forecast forecast = new Forecast(); 

     forecast.setCurrentForecast(getCurrentDetails(jsonData)); 
     forecast.setHourlyForecast(getHourlyForecast(jsonData)); 
     forecast.setDailyForecast(getDailyForecast(jsonData)); 

     return forecast; 
    } 

    private Day[] getDailyForecast(String jsonData) throws JSONException { 
     JSONObject forecast = new JSONObject(jsonData); 
     String timezone = forecast.getString("timezone"); 
     JSONObject daily = forecast.getJSONObject("daily"); 
     JSONArray data = daily.getJSONArray("data"); 

     Day[] days = new Day[data.length()]; 

     for (int i = 0; i < data.length(); i++) { 
      JSONObject jsonHour = data.getJSONObject(i); 
      Day day = new Day(); 
      day.setTime(jsonHour.getLong("time")); 
      day.setSummary(jsonHour.getString("summary")); 
      day.setTemperatureMax(jsonHour.getInt("temperatureMax")); 
      day.setTimezone(timezone); 
      day.setIcon(jsonHour.getString("icon")); 

      days[i] = day; 
     } 

     return days; 
    } 

    private Hour[] getHourlyForecast(String jsonData) throws JSONException { 
     JSONObject forecast = new JSONObject(jsonData); 
     String timezone = forecast.getString("timezone"); 
     JSONObject hourly = forecast.getJSONObject("hourly"); 
     JSONArray data = hourly.getJSONArray("data"); 

     Hour[] hours = new Hour[data.length()]; 

     for (int i = 0; i < data.length(); i++) { 
      JSONObject jsonHour = data.getJSONObject(i); 
      Hour hour = new Hour(); 
      hour.setTime(jsonHour.getLong("time")); 
      hour.setSummary(jsonHour.getString("summary")); 
      hour.setTemperature(jsonHour.getInt("temperature")); 
      hour.setTimezone(timezone); 
      hour.setIcon(jsonHour.getString("icon")); 

      hours[i] = hour; 
     } 

     return hours; 
    } 

    private Current getCurrentDetails(String jsonData) throws JSONException { 
     JSONObject forecast = new JSONObject(jsonData); 
     String timezone = forecast.getString("timezone"); 

     JSONObject currently = forecast.getJSONObject("currently"); 

     Current current = new Current(
       currently.getString("icon"), 
       currently.getLong("time"), 
       currently.getDouble("temperature"), 
       currently.getDouble("humidity"), 
       currently.getDouble("precipProbability"), 
       currently.getString("summary"), 
       forecast.getString("timezone") 
     ); 
     Log.i(TAG, current.toString()); 
     return current; 
    } 

    private boolean isNetworkAvailable() { 
     ConnectivityManager manager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 
     NetworkInfo networkInfo = manager.getActiveNetworkInfo(); 
     boolean isAvailable = false; 
     if (networkInfo != null && networkInfo.isConnected()) { 
      isAvailable = true; 
     } 
     return isAvailable; 
    } 

    private void alertUserAboutError() { 
     AlertDialogFragment dialog = new AlertDialogFragment(); 
     dialog.show(getFragmentManager(), "error_dialog"); 
    } 

    @OnClick(R.id.refreshImageView) 
    public void refreshPage(View view) { 
     mRequestingLocationUpdates = true; 
     getForecast(mLatitude, mLongitude); 
     setBackgroundGradient(); 

    } 

    @OnClick(R.id.dailyButton) 
    public void startDailyActivity(View view) { 
     Intent intent = new Intent(this, DailyForecastActivity.class); 
     intent.putExtra(DAILY_FORECAST, mForecast.getDailyForecast()); 
     if (mBackground != null) { 
      intent.putExtra(BG_GRADIENT, mBackground); 
     } 
     startActivity(intent); 
    } 

    @OnClick(R.id.hourButton) 
    public void startHourlyActivity(View view) { 
     Intent intent = new Intent(this, HourlyForecastActivity.class); 
     intent.putExtra(HOURLY_FORECAST, mForecast.getHourlyForecast()); 
     if (mBackground != null) { 
      intent.putExtra(BG_GRADIENT, mBackground); 
     } 
     startActivity(intent); 
    } 

    protected void createLocationRequest() { 
     mLocationRequest = new LocationRequest(); 
     mLocationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS); 
     mLocationRequest.setFastestInterval(FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS); 
     mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); 
    } 

    public void startUpdatesButtonHandler(View view) { 
     if (!mRequestingLocationUpdates) { 
      mRequestingLocationUpdates = true; 
      startLocationUpdates(); 
     } 
    } 

    public void stopUpdatesButtonHandler(View view) { 
     if (mRequestingLocationUpdates) { 
      mRequestingLocationUpdates = false; 
      stopLocationUpdates(); 
     } 
    } 

    protected void startLocationUpdates() { 
     // The final argument to {@code requestLocationUpdates()} is a LocationListener 
     // (http://developer.android.com/reference/com/google/android/gms/location/LocationListener.html). 
     if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
      // TODO: Consider calling 
      // ActivityCompat#requestPermissions 
      // here to request the missing permissions, and then overriding 
      // public void onRequestPermissionsResult(int requestCode, String[] permissions, 
      //           int[] grantResults) 
      // to handle the case where the user grants the permission. See the documentation 
      // for ActivityCompat#requestPermissions for more details. 
      return; 
     } 
     LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, MainActivity.this); 
    } 

    protected void stopLocationUpdates() { 
     // It is a good practice to remove location requests when the activity is in a paused or 
     // stopped state. Doing so helps battery performance and is especially 
     // recommended in applications that request frequent location updates. 

     // The final argument to {@code requestLocationUpdates()} is a LocationListener 
     // (http://developer.android.com/reference/com/google/android/gms/location/LocationListener.html). 
     LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this); 
    } 

    private void updateDisplay() { 
     Current current = mForecast.getCurrentForecast(); 
     mTemperatureLabel.setText(current.getTemperature() + ""); 
     mTimeLabel.setText("The time is " + current.getFormattedTime()); 
     mHumidityValue.setText(current.getHumidity() + ""); 
     mPrecipValue.setText(current.getPrecipChance() + "%"); 
     mSummaryLabel.setText(current.getSummary()); 
     Drawable drawable = ResourcesCompat.getDrawable(getResources(), current.getIconId(), null); 
     mIconImageView.setImageDrawable(drawable); 
    } 


    @Override 
    protected void onStart() { 
     super.onStart(); 
     mGoogleApiClient.connect(); 
    } 

    @Override 
    public void onResume() { 
     super.onResume(); 
     // Within {@code onPause()}, we pause location updates, but leave the 
     // connection to GoogleApiClient intact. Here, we resume receiving 
     // location updates if the user has requested them. 

     if (mGoogleApiClient.isConnected() && mRequestingLocationUpdates) { 
      startLocationUpdates(); 
     } 
    } 

    @Override 
    protected void onPause() { 
     super.onPause(); 
     // Stop location updates to save battery, but don't disconnect the GoogleApiClient object. 
     if (mGoogleApiClient.isConnected()) { 
      stopLocationUpdates(); 
     } 
    } 

    @Override 
    protected void onStop() { 
     mGoogleApiClient.disconnect(); 
     super.onStop(); 
    } 

    @Override 
    public void onConnected(Bundle connectionHint) { 
     Log.i(TAG, "Connected to GoogleApiClient"); 

     // If the initial location was never previously requested, we use 
     // FusedLocationApi.getLastLocation() to get it. If it was previously requested, we store 
     // its value in the Bundle and check for it in onCreate(). We 
     // do not request it again unless the user specifically requests location updates by pressing 
     // the Start Updates button. 
     // 
     // Because we cache the value of the initial location in the Bundle, it means that if the 
     // user launches the activity, 
     // moves to a new location, and then changes the device orientation, the original location 
     // is displayed as the activity is re-created. 
     if (mCurrentLocation == null) { 
      if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
       // TODO: Consider calling 
       // ActivityCompat#requestPermissions 
       // here to request the missing permissions, and then overriding 
       // public void onRequestPermissionsResult(int requestCode, String[] permissions, 
       //           int[] grantResults) 
       // to handle the case where the user grants the permission. See the documentation 
       // for ActivityCompat#requestPermissions for more details. 
       return; 
      } 
      mCurrentLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient); 
      mLastUpdateTime = DateFormat.getTimeInstance().format(new Date()); 
     } 

     if (mRequestingLocationUpdates) { 
      startLocationUpdates(); 
     } 
    } 

    @Override 
    public void onLocationChanged(Location location) { 
     Log.i(TAG, "location changed"); 
     mCurrentLocation = location; 
     mLatitude = mCurrentLocation.getLatitude(); 
     mLongitude = mCurrentLocation.getLongitude(); 
     mLastUpdateTime = DateFormat.getTimeInstance().format(new Date()); 
     getForecast(mCurrentLocation.getLatitude(), mCurrentLocation.getLongitude()); 
     updateDisplay(); 
    } 

    @Override 
    public void onConnectionSuspended(int cause) { 
     // The connection to Google Play services was lost for some reason. We call connect() to 
     // attempt to re-establish the connection. 
     Log.i(TAG, "Connection suspended"); 
     mGoogleApiClient.connect(); 
    } 

    @Override 
    public void onConnectionFailed(ConnectionResult result) { 
     // Refer to the javadoc for ConnectionResult to see what error codes might be returned in 
     // onConnectionFailed. 
     Log.i(TAG, "Connection failed: ConnectionResult.getErrorCode() = " + result.getErrorCode()); 
    } 

    public void onSaveInstanceState(Bundle savedInstanceState) { 
     savedInstanceState.putBoolean(REQUESTING_LOCATION_UPDATES_KEY, mRequestingLocationUpdates); 
     savedInstanceState.putParcelable(LOCATION_KEY, mCurrentLocation); 
     savedInstanceState.putString(LAST_UPDATED_TIME_STRING_KEY, mLastUpdateTime); 
     super.onSaveInstanceState(savedInstanceState); 
    } 
} 

Answer 1

こんにちは、あなたのAPIはうまくいきます、私はチェックしました。現在の緯度と経度で問題があります。だから、私はあなたのための1つのソリューションを持っています。

私のアプリとその動作にどのように使用しているのかを確認してください。融合したapiを使用しています。

ステップ1. GoogleLocationService.java

public class GoogleLocationService { 
private GoogleServicesCallbacks callbacks = new GoogleServicesCallbacks(); 
LocationUpdateListener locationUpdateListener; 
Context activity; 
protected GoogleApiClient mGoogleApiClient; 
protected LocationRequest mLocationRequest; 

public static final long UPDATE_INTERVAL_IN_MILLISECONDS = 30000; 


public GoogleLocationService(Context activity, LocationUpdateListener locationUpdateListener) { 
    this.locationUpdateListener = locationUpdateListener; 
    this.activity = activity; 
    buildGoogleApiClient(); 
} 

protected synchronized void buildGoogleApiClient() { 
    //Log.i(TAG, "Building GoogleApiClient"); 
    mGoogleApiClient = new GoogleApiClient.Builder(activity) 
      .addConnectionCallbacks(callbacks) 
      .addOnConnectionFailedListener(callbacks) 
      .addApi(LocationServices.API) 
      .build(); 
    createLocationRequest(); 
    mGoogleApiClient.connect(); 
} 

protected void createLocationRequest() { 
    mLocationRequest = new LocationRequest(); 
    mLocationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS); 
    mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); 

} 

private class GoogleServicesCallbacks implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener { 

    @Override 
    public void onConnected(Bundle bundle) { 
     startLocationUpdates(); 
    } 

    @Override 
    public void onConnectionSuspended(int i) { 
     mGoogleApiClient.connect(); 
    } 

    @Override 
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { 

     if (connectionResult.getErrorCode() == ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED) { 
      Toast.makeText(activity, "Google play service not updated", Toast.LENGTH_LONG).show(); 

     } 
     locationUpdateListener.cannotReceiveLocationUpdates(); 
    } 

    @Override 
    public void onLocationChanged(Location location) { 
     if (location.hasAccuracy()) { 
      if (location.getAccuracy() < 30) { 
       locationUpdateListener.updateLocation(location); 
      } 
     } 
    } 
} 

private static boolean locationEnabled(Context context) { 
    boolean gps_enabled = false; 
    LocationManager lm = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE); 
    try { 
     gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER); 
    } catch (Exception ex) { 
     ex.printStackTrace(); 
    } 
    return gps_enabled; 
} 

private boolean servicesConnected(Context context) { 
    return isPackageInstalled(GooglePlayServicesUtil.GOOGLE_PLAY_STORE_PACKAGE, context); 
} 

private boolean isPackageInstalled(String packagename, Context context) { 
    PackageManager pm = context.getPackageManager(); 
    try { 
     pm.getPackageInfo(packagename, PackageManager.GET_ACTIVITIES); 
     return true; 
    } catch (PackageManager.NameNotFoundException e) { 
     e.printStackTrace(); 
     return false; 
    } 
} 


public void startUpdates() { 
    /* 
    * Connect the client. Don't re-start any requests here; instead, wait 
    * for onResume() 
    */ 
    if (servicesConnected(activity)) { 
     if (locationEnabled(activity)) { 
      locationUpdateListener.canReceiveLocationUpdates(); 
      startLocationUpdates(); 
     } else { 
      locationUpdateListener.cannotReceiveLocationUpdates(); 
      Toast.makeText(activity, "Unable to get your location.Please turn on your device Gps", Toast.LENGTH_LONG).show(); 
     } 
    } else { 
     locationUpdateListener.cannotReceiveLocationUpdates(); 
     Toast.makeText(activity, "Google play service not available", Toast.LENGTH_LONG).show(); 
    } 
} 

//stop location updates 
public void stopUpdates() { 
    stopLocationUpdates(); 
} 

//start location updates 
private void startLocationUpdates() { 

    if (checkSelfPermission(activity, ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && checkSelfPermission(activity, ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
     return; 
    } 
    if (mGoogleApiClient.isConnected()) { 
     LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, callbacks); 
    } 
} 

public void stopLocationUpdates() { 
    if (mGoogleApiClient.isConnected()) { 
     LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, callbacks); 
    } 
} 

public void startGoogleApi() { 
    mGoogleApiClient.connect(); 
} 

public void closeGoogleApi() { 
    mGoogleApiClient.disconnect(); 
} 

} 

ステップ2をこのクラス してください。 LocationUpdateListener.java

public interface LocationUpdateListener { 

/** 
* Called immediately the service starts if the service can obtain location 
*/ 
void canReceiveLocationUpdates(); 

/** 
* Called immediately the service tries to start if it cannot obtain location - eg the user has disabled wireless and 
*/ 
void cannotReceiveLocationUpdates(); 

/** 
* Called whenever the location has changed (at least non-trivially) 
* @param location 
*/ 
void updateLocation(Location location); 

/** 
* Called when GoogleLocationServices detects that the device has moved to a new location. 
* @param localityName The name of the locality (somewhere below street but above area). 
*/ 
void updateLocationName(String localityName, Location location); 
} 

OnCreateのか、場所

プライベートGoogleLocationService googleLocationServiceを取得したいあなたのクラスでは、ステップ3を呼び出し、このこのインターフェイスを作成します。

googleLocationService = new GoogleLocationService(context, new LocationUpdateListener() { 
    @Override 
    public void canReceiveLocationUpdates() { 
    } 

    @Override 
    public void cannotReceiveLocationUpdates() { 
    } 

    //update location to our servers for tracking purpose 
    @Override 
    public void updateLocation(Location location) { 
     if (location != null) { 
      Timber.e("updated location %1$s %2$s", location.getLatitude(), location.getLongitude()); 

     } 
    } 

    @Override 
    public void updateLocationName(String localityName, Location location) { 

     googleLocationService.stopLocationUpdates(); 
    } 
}); 
googleLocationService.startUpdates(); 


and call this onDestroy 
if (googleLocationService != null) { 
    googleLocationService.stopLocationUpdates(); 
} 

希望すると、問題を解決するのに役立ちます。