Java Android地图-跳过帧！应用程序可能在其主线程上做了太多工作

我正在开发一个E-com应用程序，我必须获得用户的位置。我使用谷歌地图的PlacesPickerAPI来完成这些任务。有一段时间一切正常，但现在我突然收到以下错误消息：

我/编舞（691）：跳过了55帧！应用程序可能在其主线程上做了太多工作

前两个活动工作正常，错误消息仅在映射活动开始时出现。地图屏幕开始闪烁，应用程序返回到主活动。错误是随机发生的，并非总是发生。有时它工作得很好，有时它会出问题

在这里，我把我的整个地图代码：

  public class LocationActivity extends AppCompatActivity implements OnMapReadyCallback,GoogleApiClient.OnConnectionFailedListener{

        ArrayList<Products> products_list;
        //products_list =

SharedPrefManager.getInstance(getApplicationContext()).GetCart();

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

}

@Override
public void onMapReady(GoogleMap googleMap) {
    Log.i(TAG, "onMapReady: Map is ready");
    Toast.makeText(this, "Map is Ready", Toast.LENGTH_SHORT).show();
    mMap = googleMap;

    if (mLocationPermissionGranted) {
        getDeviceLocation();

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

            return;
        }
        mMap.setMyLocationEnabled(true);
        mMap.getUiSettings().setMyLocationButtonEnabled(false);
        Init();
    }
}

private static final String TAG = "MapActivity";
private static final String FINE_LOCATION=Manifest.permission.ACCESS_FINE_LOCATION;
private static final String COARSE_LOCATION=Manifest.permission.ACCESS_COARSE_LOCATION;
private static final int mLocationPermissionRequestCode = 1234;
private static final float DEFAULT_ZOOM = 15f;
protected GeoDataClient mGeoDataClient;
private static final LatLngBounds LAT_LNG_BOUNDS = new LatLngBounds(new LatLng(5,79),new LatLng(10,82));
private static final int PLACE_PICKER_REQUEST = 1;

//widgets
private AutoCompleteTextView mSearch_text;
private ImageView mGps,mPicker;
private Button button;

//vars
private Boolean mLocationPermissionGranted = false;
private GoogleMap mMap;
private FusedLocationProviderClient mFusedLocationProviderClient;
private PlaceAutocompleteAdapter placeAutocompleteAdapter;
private GoogleApiClient mGoogleApiClient;
private LatLng selectedLatLng;
private String selectedname;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_location);

    // Construct a GeoDataClient.
    mGeoDataClient = Places.getGeoDataClient(this, null);

    button=findViewById(R.id.btn_confirm);
    mSearch_text = findViewById(R.id.search_text);
    mGps = findViewById(R.id.ic_gps);
    mPicker = findViewById(R.id.ic_picker);


    getPermissionAccess();

}


private void Init(){
    Log.i(TAG, "Init: Initializing");

    mGoogleApiClient = new GoogleApiClient
            .Builder(this)
            .addApi(Places.GEO_DATA_API)
            .addApi(Places.PLACE_DETECTION_API)
            .enableAutoManage(this, this)
            .build();

    mSearch_text.setOnItemClickListener(mAutocompleteAdapterViewListener);


    placeAutocompleteAdapter = new PlaceAutocompleteAdapter(this,mGeoDataClient,LAT_LNG_BOUNDS,null);

    mSearch_text.setAdapter(placeAutocompleteAdapter);

    mSearch_text.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if(actionId == EditorInfo.IME_ACTION_SEARCH
                    || actionId == EditorInfo.IME_ACTION_DONE
                    || event.getAction() == event.ACTION_DOWN
                    || event.getAction() == event.KEYCODE_ENTER){
                //Method for search
                geoLocate();

            }
            return false;
        }
    });
    mGps.setOnClickListener(new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            Log.i(TAG, "onClick: gps icon clicked");
            getDeviceLocation();
        }
    });

    mPicker.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            PlacePicker.IntentBuilder builder = new PlacePicker.IntentBuilder();

            try {
                startActivityForResult(builder.build(LocationActivity.this), PLACE_PICKER_REQUEST);
            } catch (GooglePlayServicesRepairableException e) {
                e.printStackTrace();
            } catch (GooglePlayServicesNotAvailableException e) {
                e.printStackTrace();
            }
        }
    });

    button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            NextActivity();
        }
    });

}

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == PLACE_PICKER_REQUEST) {
        if (resultCode == RESULT_OK) {
            Place place = PlacePicker.getPlace(this,data);
            String toastMsg = String.format("Place: %s", place.getName());
            Toast.makeText(this, toastMsg, Toast.LENGTH_LONG).show();

            PendingResult<PlaceBuffer>  placeResult = Places.GeoDataApi.getPlaceById(mGoogleApiClient,place.getId());
            placeResult.setResultCallback(mUpdatePlaceDetailsCallback);
        }
    }
}

private void geoLocate(){
    Log.i(TAG, "geoLocate: geolocating");
    String searchstring = mSearch_text.getText().toString();
    Geocoder geocoder = new Geocoder(LocationActivity.this);
    List<Address> list = new ArrayList<>();
    try{
        list = geocoder.getFromLocationName(searchstring,1);
    }catch (IOException e)
    {
        Log.i(TAG, "geoLocate: IOException"+ e.getMessage());
    }
    if(list.size()>0){
        Address address = list.get(0);
        Log.i(TAG, "geoLocate: Found LocationActivity"+ address.toString());
        MoveCamera(new LatLng(address.getLatitude(),address.getLongitude()),DEFAULT_ZOOM,
                address.getAddressLine(0));

    }
}

private void getDeviceLocation(){
    Log.i(TAG, "getDeviceLocation: Getting Device LocationActivity");
    mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
    try{
        if(mLocationPermissionGranted){
            Task location =mFusedLocationProviderClient.getLastLocation();
            location.addOnCompleteListener(new OnCompleteListener() {
                @Override
                public void onComplete(@NonNull Task task) {
                    if(task.isSuccessful()){
                        Log.i(TAG, "onComplete: LocationActivity Found");
                        android.location.Location currentLocation = (android.location.Location) task.getResult();

                        MoveCamera(new LatLng(currentLocation.getLatitude(),currentLocation.getLongitude()),DEFAULT_ZOOM
                                ,"My LocationActivity");

                    }
                    else {
                        Log.i(TAG, "onComplete: LocationActivity Null");
                        Toast.makeText(LocationActivity.this, "Unable to get LocationActivity", Toast.LENGTH_SHORT).show();
                    }
                }
            });
        }

    } catch (SecurityException e){
        Log.i(TAG, "getDeviceLocation: SecurityException: "+e.getMessage());
    }


}

private void MoveCamera(LatLng latLng , float zoom, String title){
    Log.i(TAG, "MoveCamera: Moving Camera to lat: "+latLng.latitude+" ,lng: "+latLng.longitude);
    mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng,zoom));

    mMap.clear();

    if(!title.equals("My LocationActivity")){
        MarkerOptions markerOptions = new MarkerOptions()
                .position(latLng)
                .title(title);
        mMap.addMarker(markerOptions);
    }



}

private void InitMap(){
    Log.i(TAG, "InitMap: Initilizing Map");
    SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
    mapFragment.getMapAsync(LocationActivity.this);
}

private void getPermissionAccess(){
    Log.i(TAG, "getPermissionAccess: Getting LocationActivity permissions");
    String[] permissions = {FINE_LOCATION,COARSE_LOCATION};
    if(ContextCompat.checkSelfPermission(this.getApplicationContext(),FINE_LOCATION) == PackageManager.PERMISSION_GRANTED){
        if(ContextCompat.checkSelfPermission(this.getApplicationContext(),COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED){
            mLocationPermissionGranted = true;
            InitMap();
        } else {
            ActivityCompat.requestPermissions(this,permissions,mLocationPermissionRequestCode);
        }
    } else {
        ActivityCompat.requestPermissions(this,permissions,mLocationPermissionRequestCode);
    }

}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    Log.i(TAG, "onRequestPermissionsResult: Called");
    mLocationPermissionGranted = false;
    switch (requestCode){
        case mLocationPermissionRequestCode:{
            if(grantResults.length>0){
                for(int i=0; i<grantResults.length; i++){
                    if(grantResults[i]!= PackageManager.PERMISSION_GRANTED){
                        mLocationPermissionGranted=false;
                        Log.i(TAG, "onRequestPermissionsResult: Permission Denied.");
                        Log.i(TAG, "onRequestPermissionsResult:"+grantResults[i]);
                        return;
                    }
                }
                mLocationPermissionGranted=true;
                Log.i(TAG, "onRequestPermissionsResult: Permission Granted");
                //initialization of Map
                InitMap();
            }
        }
    }
}

/*
 google places api auto complete */

private AdapterView.OnItemClickListener mAutocompleteAdapterViewListener = new AdapterView.OnItemClickListener() {
    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {

        final AutocompletePrediction item = placeAutocompleteAdapter.getItem(position);
        final String placeid = item.getPlaceId();

        PendingResult<PlaceBuffer> placeResult = Places.GeoDataApi.getPlaceById(mGoogleApiClient,placeid);
        placeResult.setResultCallback(mUpdatePlaceDetailsCallback);

    }
};

private ResultCallback<PlaceBuffer> mUpdatePlaceDetailsCallback = new ResultCallback<PlaceBuffer>() {
    @Override
    public void onResult(@NonNull PlaceBuffer places) {

        if(!places.getStatus().isSuccess()){
            Log.i(TAG, "onResult: Place query did not complete"+places.getStatus().toString());
            places.release();
        }
        final Place place = places.get(0);
        Log.i(TAG, "onResult: Name:"+place.getName());
        Log.i(TAG, "onResult: Latitude:"+place.getLatLng().latitude);
        Log.i(TAG, "onResult: Longtitude:"+place.getLatLng().longitude);

        selectedname=place.getName().toString();
        selectedLatLng=place.getLatLng();

        MoveCamera(selectedLatLng,DEFAULT_ZOOM,selectedname);
        places.release();
        Log.i(TAG, "onResult: Name:"+selectedname);
        Log.i(TAG, "onResult: Selected LAtLng"+selectedLatLng);
    }

};

private void NextActivity(){
    if(selectedLatLng!=null && !selectedname.equals("")){
        Intent intent = new Intent(getApplicationContext(),CheckoutActivity.class);
        SharedPrefManager.getInstance(getApplicationContext()).SaveLocation(selectedname,selectedLatLng);
        startActivity(intent);
    }
    else{
        showErrorMsg("Location Cannot be Empty");
    }
}
public void showErrorMsg(String message){
    new AlertDialog.Builder(this)
            .setTitle("Oops")
            .setMessage(message)
            .setPositiveButton(android.R.string.ok,null)
            .show();
}
}

公共类LocationActivity扩展了AppCompativeActivity在MapreadyCallback、GoogleAppClient.OnConnectionFailedListener上的实现{
ArrayList产品列表；
//产品目录=
getInstance（getApplicationContext（））.GetCart（）；
@凌驾
public void onconnection失败（@NonNull ConnectionResult ConnectionResult）{
}
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
Log.i（标记“onMapReady:Map is ready”）；
Toast.makeText（这是“地图准备就绪”，Toast.LENGTH_SHORT）.show（）；
mMap=谷歌地图；
如果（已授予位置许可）{
getDeviceLocation（）；
if（ActivityCompat.checkSelfPermission（这是Manifest.permission.ACCESS\u FINE\u位置）
！=PackageManager.PERMISSION\u已授予和&ActivityCompat.checkSelfPermission（此，
Manifest.permission.ACCESS\u\u位置）！=PackageManager.permission\u已授予）{
返回；
}
mMap.setMyLocationEnabled（真）；
mMap.getUiSettings（）.setMyLocationButtonEnabled（false）；
Init（）；
}
}
私有静态最终字符串TAG=“MapActivity”；
私有静态最终字符串FINE\u LOCATION=Manifest.permission.ACCESS\u FINE\u LOCATION；
私有静态最终字符串粗略\u位置=Manifest.permission.ACCESS\u粗略\u位置；
私有静态最终int mLocationPermissionRequestCode=1234；
私有静态最终浮动默认值_缩放=15f；
受保护的地理数据客户端mGeoDataClient；
私有静态最终LatLngBounds LAT_LNG_BOUNDS=新LatLngBounds（新Latlngs（5,79），新Latlngs（10,82））；
私有静态最终整数位置\u选择器\u请求=1；
//小部件
私有自动完成文本视图mSearch_文本；
私有ImageView mGps，mPicker；
私人按钮；
//瓦尔斯
私有布尔值mlocationpermissiongrated=false；
私有谷歌地图；
私有FusedLocationProviderClient mFusedLocationProviderClient；
私人配售自动补足配售自动补足配售；
私人GoogleapClient MGoogleapClient；
选择私人车床；
私有字符串selectedname；
@凌驾
创建时受保护的void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_位置）；
//构造一个GeoDataClient。
mGeoDataClient=Places.getGeoDataClient（这个，null）；
按钮=findViewById（R.id.btn\u确认）；
mSearch_text=findviewbyd（R.id.search_text）；
mGps=findViewById（R.id.ic\U gps）；
mPicker=findviewbyd（R.id.ic\u选择器）；
getPermissionAccess（）；
}
私有void Init（）{
Log.i（标记“Init:initialization”）；
mgoogleapclient=新的Googleapclient
.Builder（本）
.addApi（Places.GEO_数据_API）
.addApi（Places.PLACE\u DETECTION\u API）
.enableAutoManage（这个，这个）
.build（）；
mSearch_text.setOnItemClickListener（mAutocompleteAdapterViewListener）；
placeAutocompleteAdapter=新的placeAutocompleteAdapter（这个，mGeoDataClient，LAT_LNG_BOUNDS，null）；
mSearch_text.setAdapter（placeautocompletedadapter）；
mSearch_text.setOnEditorActionListener（新的TextView.OnEditorActionListener（）{
@凌驾
公共布尔onEditorAction（TextView v、int actionId、KeyEvent事件）{
如果（actionId==EditorInfo.IME\u操作\u搜索
||actionId==EditorInfo.IME\u操作\u完成
||event.getAction（）==event.ACTION\u向下
||event.getAction（）==event.KEYCODE\u ENTER）{
//搜索方法
地理定位（）；
}
返回false；
}
});
mGps.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
Log.i（标记“onClick:gps图标已单击”）；
getDeviceLocation（）；
}
});
mPicker.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
PlacePicker.IntentBuilder生成器=新的PlacePicker.IntentBuilder（）；
试一试{
startActivityForResult（builder.build（LocationActivity.this），PLACE\u PICKER\u REQUEST）；
}捕获（谷歌游戏服务可修复例外）{
e、 printStackTrace（）；
}捕获（谷歌PlayServicesNotAvailableException）{
e、 printStackTrace（）；
}
}
});
setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
下触觉（）；
}
});
}
受保护的void onActivityResult（int请求代码、int结果代码、意图数据）{
if（requestCode==PLACE\u PICKER\u REQUEST）{
if（resultCode==RESULT\u OK）{
Place-Place=PlacePicker.getPlace（这个，数据）；
String toastMsg=String.format（“位置：%s”，Place.getName（））；
Toast.makeText（this，toastMsg，Toast.LENGTH_LONG）.show（）；
Pendingreult placeResult=Places.GeoDataApi.getPlaceById（mGoogleApiClient，place.getId（））；
placeResult.setResultCallback（mUpdatePlaceDetailsCallback）；
}
}
}
私有void geologite（）{
Log.i（标签“地理定位：地理定位”）；
String searchstring=mSearch_text.getText（）.toString（）；
Geocoder Geocoder=新的Geocoder（LocationActivity.this）；
利斯
private Thread thread = null;
private final Runnable thread_DoWork = new Runnable() {
    @Override public void run() {
        // Your code here or call some function to run for the thread
        someHeavyLiftingFunction();
    }
};

// Check if already created/started
if (thread == null) {
    // Create new thread
    thread = new Thread(thread_DoWork);
    // Start Thread in background
    thread.start();
}