Fatal编程技术网
  • android/
  • Android 等待未连接的呼叫，以获取位置

Android 等待未连接的呼叫，以获取位置

android

Android 等待未连接的呼叫，以获取位置,android,location,android-googleapiclient,Android,Location,Android Googleapiclient,所以，我有一个定制的位置服务类，我想从中得到最后一个已知的位置。有可能，我可以在连接GoogleAppClient之前调用getLastKnownLocation（），因此我必须等待它，然后调用getLastKnownLocation（），但我不知道如何管理它。我认为RXJava2可以帮助我解决这个问题，但我还不熟悉这个框架。这是我目前的课程： import android.Manifest; import android.app.Activity; import android.content

所以，我有一个定制的位置服务类，我想从中得到最后一个已知的位置。有可能，我可以在连接GoogleAppClient之前调用
getLastKnownLocation（）
，因此我必须等待它，然后调用
getLastKnownLocation（）
，但我不知道如何管理它。我认为RXJava2可以帮助我解决这个问题，但我还不熟悉这个框架。这是我目前的课程：

import android.Manifest;
import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.util.Log;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.model.LatLng;

import javax.inject.Inject;

import pl.pancor.android.air.base.FragmentScope;

@FragmentScope
public class LocationService implements Location.Service,
        GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener,
        ActivityCompat.OnRequestPermissionsResultCallback {

    private static final String TAG = LocationService.class.getSimpleName();
    private static final int PERMISSIONS_REQUEST = 13;

    private GoogleApiClient mGoogleApiClient;

    private Activity mActivity;

    private android.location.Location mLastLocation;

    private Location.Receiver mReceiver;

    @Inject
    LocationService(Activity activity) {

        mActivity = activity;
    }

    @Override
    public void getLastKnownLocation() {

        if (isPermissionsGranted(true))
            getLocation();

    }

    /**
     * @param request if permissions aren't granted and {@param request} is true,
     *                then request permissions
     * @return true if location permissions are granted
     */
    private boolean isPermissionsGranted(boolean request) {

        if (ActivityCompat.checkSelfPermission(mActivity,
                Manifest.permission.ACCESS_FINE_LOCATION) !=
                PackageManager.PERMISSION_GRANTED &&
                ActivityCompat.checkSelfPermission(mActivity,
                        Manifest.permission.ACCESS_COARSE_LOCATION) !=
                        PackageManager.PERMISSION_GRANTED) {

            if (request) {
                ActivityCompat.requestPermissions(mActivity,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION,
                                Manifest.permission.ACCESS_COARSE_LOCATION},
                        PERMISSIONS_REQUEST);
            }
            return false;
        }
        return true;
    }

    private void getLocation() {

        if (mGoogleApiClient != null)

            mLastLocation = LocationServices.FusedLocationApi
                .getLastLocation(mGoogleApiClient);

        if (mLastLocation != null) {

            LatLng latLng = new LatLng(mLastLocation.getLatitude(),
                    mLastLocation.getLongitude());
            mReceiver.lastKnownLocation(latLng);
        } else {

            Log.e(TAG, "NULLLLLLLLLLLLLLLLLLLLLLL");
        }
    }

    @Override
    public void onConnected(@Nullable Bundle bundle) {

    }

    @Override
    public void onConnectionSuspended(int i) {


    }

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

    }

    @Override
    public void setupReceiver(Location.Receiver receiver) {

        mReceiver = receiver;
    }

    @Override
    public void onStart() {

        if (mGoogleApiClient != null){

            mGoogleApiClient.connect();
        } else {

            mGoogleApiClient = getGoogleApiClient();
            mGoogleApiClient.connect();
        }
    }

    @Override
    public void onStop() {

        if (mGoogleApiClient != null)
            mGoogleApiClient.disconnect();
    }

    private GoogleApiClient getGoogleApiClient(){

        return new GoogleApiClient.Builder(mActivity)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API)
                .build();
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {

        switch (requestCode){

            case PERMISSIONS_REQUEST:

                if (grantResults.length > 0 &&
                        grantResults[0] == PackageManager.PERMISSION_GRANTED){

                    getLastKnownLocation();
                } else {

                }
        }
    }
}
我需要以某种方式检查mGoogleApiClient是否已连接（
mGoogleApiClient.isConnected（）
），如果未连接，请等待连接，然后从FusedLocationApi获取位置，但我不想将方法放入
onConnected（）
，因为它有时会返回位置，当我不想返回位置时。

在您在评论部分的解释之后，我会这样做：

  • 在Receiver/Fragment类中，我将在LocationService类中放置一些逻辑，将变量“updateUI”设置为true，此时onConnected可以调用
    mReceiver.lastKnownLocation（latLng）
    方法。默认值将为false，如果在接收器准备就绪之前调用onConnected，则方法
    mReceiver.lastnownlocation（latLng）
    不会被叫的

  • 另一种方法是在SharedReferences（或至少在
    onPause
    方法中）中始终存储最后一个已知位置。然后，您总是可以在第一次需要位置时使用它，然后等待更精确的位置，但这种方法在开始时不会如此精确

    • 所以，过了一段时间，我成功了，也完成了我的整个课程，我想和你们分享我所做的

    public interface Location {

    interface Service extends BaseLocation<Receiver>{

        void onStart();

        void onStop();

        void onActivityResult(int requestCode, int resultCode);

        void getLastKnownLocation();
    }

    interface Receiver{

        void lastKnownLocation(double latitude, double longitude);

        void userRefusedToSendLocation();

        void unableToObtainLocation();
    }
}



import android.Manifest;
import android.app.Activity;
import android.content.IntentSender;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.Handler;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.util.Log;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.PendingResult;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.common.api.Status;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.LocationSettingsRequest;
import com.google.android.gms.location.LocationSettingsResult;
import com.google.android.gms.location.LocationSettingsStatusCodes;

import javax.inject.Inject;

import pl.pancor.android.air.base.FragmentScope;

@FragmentScope
public class LocationService implements Location.Service,
        GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener,
        ActivityCompat.OnRequestPermissionsResultCallback, LocationListener,
        ResultCallback<LocationSettingsResult>{

    private static final int PERMISSIONS_REQUEST = 13;
    private static final int SETTINGS_CHECK = 23;
    private static final int GOOGLE_API_CLIENT_ERROR = 33;

    private static final int LOCATION_EXPIRATION_TIME = 10 * 1000;
    private static final int LOCATION_INTERVAL = 2 * 1000;

    private GoogleApiClient mGoogleApiClient;

    private Activity mActivity;

    private LocationRequest mLocationRequest;
    private android.location.Location mLastLocation;

    private Location.Receiver mReceiver;

    private Handler mHandler;
    private final Runnable mExpiredLocationUpdate = new Runnable() {
        @Override
        public void run() {
            mReceiver.unableToObtainLocation();
        }
    };

    private boolean isWaitingForConnect = false;

    @Inject
    LocationService(Activity activity) {

        mActivity = activity;
    }

    @Override
    public void getLastKnownLocation() {

        if (isPermissionsGranted(true))
            checkLocationSettings();
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode) {

        resolveProblems(requestCode, resultCode);
    }

    @Override
    public void onLocationChanged(android.location.Location location) {

        if (mLastLocation == null) {

            mLastLocation = location;
            sendLatLngToReceiver();
        }

        LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
        mHandler.removeCallbacks(mExpiredLocationUpdate);
    }

    @Override
    public void onConnected(@Nullable Bundle bundle) {

        if (isWaitingForConnect)
            getLastKnownLocation();
    }

    @Override
    public void onConnectionSuspended(int i) {

        //mGoogleApiClient will automatically try to reconnect
    }

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

        if (!result.hasResolution()){
            mReceiver.unableToObtainLocation();
            GoogleApiAvailability.getInstance()
                    .getErrorDialog(mActivity, result.getErrorCode(), 0).show();
            return;
        }
        if (mActivity.hasWindowFocus()) {
            try {
                result.startResolutionForResult(mActivity, GOOGLE_API_CLIENT_ERROR);
            } catch (IntentSender.SendIntentException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void setupReceiver(Location.Receiver receiver) {

        mReceiver = receiver;
    }

    @Override
    public void onStart() {

        mHandler = new Handler();

        if (mGoogleApiClient != null){

            mGoogleApiClient.connect();
        } else {

            mGoogleApiClient = getGoogleApiClient();
            mGoogleApiClient.connect();
        }
    }

    @Override
    public void onStop() {

        if (mGoogleApiClient != null) {
            LocationServices.FusedLocationApi.removeLocationUpdates(
                    mGoogleApiClient, this);

            mGoogleApiClient.disconnect();
        }
        mHandler.removeCallbacks(mExpiredLocationUpdate);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {

        switch (requestCode){
            case PERMISSIONS_REQUEST:

                if (grantResults.length > 0 &&
                        grantResults[0] == PackageManager.PERMISSION_GRANTED){

                    getLastKnownLocation();
                } else {

                    mReceiver.userRefusedToSendLocation();
                }
        }
    }

    @Override
    public void onResult(@NonNull LocationSettingsResult result) {

        final Status status = result.getStatus();
        switch (status.getStatusCode()){
            case LocationSettingsStatusCodes.SUCCESS:

                getLocation();
                break;
            case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:

                if (mActivity.hasWindowFocus()) {
                    try {
                        status.startResolutionForResult(mActivity, SETTINGS_CHECK);
                    } catch (IntentSender.SendIntentException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case  LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:

                mReceiver.unableToObtainLocation();
                break;
        }
    }

    private void checkLocationSettings() {

        if (mGoogleApiClient != null){

            mLocationRequest = new LocationRequest()
                    .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
                    .setFastestInterval(LOCATION_INTERVAL / 2)
                    .setInterval(LOCATION_INTERVAL)
                    .setNumUpdates(1);

            LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
                    .addLocationRequest(mLocationRequest);

            PendingResult<LocationSettingsResult> result = LocationServices
                    .SettingsApi.checkLocationSettings(mGoogleApiClient, builder.build());
            result.setResultCallback(this);
        }
    }

    private void getLocation(){

        if (mGoogleApiClient != null)
            mLastLocation = LocationServices.FusedLocationApi
                    .getLastLocation(mGoogleApiClient);

        sendLatLngToReceiver();
    }

    private void sendLatLngToReceiver(){

        if (mLastLocation != null) {

            mReceiver.lastKnownLocation(mLastLocation.getLatitude(),
                    mLastLocation.getLongitude());
            mHandler.removeCallbacks(mExpiredLocationUpdate);
        } else {

            requestLocation();
        }
    }

    private void requestLocation(){

        if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {

            LocationServices.FusedLocationApi.requestLocationUpdates(
                    mGoogleApiClient, mLocationRequest, this);
            mHandler.postDelayed(mExpiredLocationUpdate, LOCATION_EXPIRATION_TIME);
        } else {

            isWaitingForConnect = true;
        }
    }

    /**
     * @param request if permissions aren't granted and {@param request} is true,
     *                then request permissions
     * @return true if location permissions are granted
     */
    private boolean isPermissionsGranted(boolean request) {

        if (ActivityCompat.checkSelfPermission(mActivity,
                Manifest.permission.ACCESS_FINE_LOCATION) !=
                PackageManager.PERMISSION_GRANTED &&
                ActivityCompat.checkSelfPermission(mActivity,
                        Manifest.permission.ACCESS_COARSE_LOCATION) !=
                        PackageManager.PERMISSION_GRANTED) {

            if (request) {
                ActivityCompat.requestPermissions(mActivity,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION,
                                Manifest.permission.ACCESS_COARSE_LOCATION},
                        PERMISSIONS_REQUEST);
            }
            return false;
        }
        return true;
    }

    private GoogleApiClient getGoogleApiClient(){

        return new GoogleApiClient.Builder(mActivity)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API)
                .build();
    }

    private void resolveProblems(int requestCode, int resultCode){

        switch (requestCode){
            case SETTINGS_CHECK:
                switch (resultCode){
                    case Activity.RESULT_OK:
                        getLastKnownLocation();
                        break;
                    case Activity.RESULT_CANCELED:
                        mReceiver.userRefusedToSendLocation();
                        break;
                }
                break;
            case GOOGLE_API_CLIENT_ERROR:
                switch (resultCode) {
                    case Activity.RESULT_OK:
                        mGoogleApiClient.connect();
                        break;
                    case Activity.RESULT_CANCELED:
                        mReceiver.unableToObtainLocation();
                        break;
                }
        }
    }
}

    公共接口位置{
接口服务扩展了BaseLocation{
void onStart（）；
void onStop（）；
activityresult无效（int请求代码、int结果代码）；
void getLastKnownLocation（）；
}
接口接收器{
无效位置（双纬度、双经度）；
void userrefuredtosendlocation（）；
void unableToObtainLocation（）；
}
}
导入android.Manifest；
导入android.app.Activity；
导入android.content.IntentSender；
导入android.content.pm.PackageManager；
导入android.os.Bundle；
导入android.os.Handler；
导入android.support.annotation.NonNull；
导入android.support.annotation.Nullable；
导入android.support.v4.app.ActivityCompat；
导入android.util.Log；
导入com.google.android.gms.common.ConnectionResult；
导入com.google.android.gms.common.GoogleAppAvailability；
导入com.google.android.gms.common.api.GoogleAppClient；
导入com.google.android.gms.common.api.pendingreult；
导入com.google.android.gms.common.api.ResultCallback；
导入com.google.android.gms.common.api.Status；
导入com.google.android.gms.location.LocationListener；
导入com.google.android.gms.location.LocationRequest；
导入com.google.android.gms.location.LocationServices；
导入com.google.android.gms.location.LocationSettingsRequest；
导入com.google.android.gms.location.LocationSettingsResult；
导入com.google.android.gms.location.LocationSettingsStatusCodes；
导入javax.inject.inject；
导入pl.pancor.android.air.base.FragmentScope；
@碎片镜
公共类LocationService实现Location.Service，
GoogleAppClient.ConnectionCallbacks，GoogleAppClient.OnConnectionFailedListener，
ActivityCompat.OnRequestPermissionsResultCallback，LocationListener，
结果回拨{
私有静态最终int权限\u请求=13；
专用静态最终整数设置\u检查=23；
私有静态最终int谷歌API客户端错误=33；
私有静态最终整数位置\到期\时间=10*1000；
专用静态最终整数位置_间隔=2*1000；
私人GoogleapClient MGoogleapClient；
私人活动能力；
私人位置请求mLocationRequest；
私有android.location.location mLastLocation；
私人位置。接收人/接收人；
私人经理人；
private final Runnable mExpiredLocationUpdate=new Runnable（）{
@凌驾
公开募捐{
mReceiver.unableToObtainLocation（）；
}
};
私有布尔值isWaitingForConnect=false；
@注入
位置服务（活动）{
活动性=活动性；
}
@凌驾
public void getLastKnownLocation（）{
如果（isPermissionsGranted（true））
checkLocationSettings（）；
}
@凌驾
ActivityResult上的公共void（int请求代码、int结果代码）{
解决问题（请求代码、结果代码）；
}
@凌驾
public void onLocation已更改（android.location.location）{
如果（mLastLocation==null）{
mLastLocation=位置；
sendLatLngToReceiver（）；
}
LocationServices.FusedLocationApi.RemovelocationUpdate（mgoogleapClient，this）；
mHandler.removeCallbacks（mExpiredLocationUpdate）；
}
@凌驾
未连接的公共无效（@Nullable Bundle）{
如果（正在等待连接）
getLastKnownLocation（）；
}
@凌驾
公共空间连接暂停（int i）{
//MGooGleapClient将自动尝试重新连接
}
@凌驾
public void onconnection失败（@NonNull ConnectionResult）{
如果（！result.hasResolution（））{
mReceiver.unableToObtainLocation（）；
GoogleApiAvailability.getInstance（）
.getErrorDialog（mActivity，result.getErrorCode（），0）.show（）；
返回；
}
if（mActivity.hasWindowFocus（））{
试一试{
result.StartResult解决方案（MacActivity、GOOGLE\u API\u CLIENT\u错误）；
}catch（IntentSender.sendtintentexe）{
e、 printStackTrace（）；
}
}
}
@凌驾
公用接收器（Location.Receiver）{
姆雷奇