boxSize泄漏到全球范围内

时间:2017-10-05 09:40:11

标签: javascript global-scope

控制台日志两次但它只需要显示第一个console.log(boxSize)

public class PlacesAutoCompleteActivity extends AppCompatActivity implements
        GoogleApiClient.ConnectionCallbacks,
        GoogleApiClient.OnConnectionFailedListener,
        View.OnClickListener, OnMapReadyCallback,
        LocationListener {
    protected GoogleApiClient mGoogleApiClient;
    private boolean executeOnStart = false;
    LocationRequest mLocationRequest;
    private static final LatLngBounds BOUNDS_INDIA = new LatLngBounds(
            new LatLng(-0, 0), new LatLng(0, 0));
    public GoogleMap mMap;
    Location mLastLocation;
    Marker mCurrLocationMarker;
    private String mapAddress = null;
    private ImageView imageView;
    private Button checkAvailability;
    private StringBuilder sb = null;
    private EditText mAutocompleteView;
    private Geocoder geocoder;
    private MarkerOptions markerOptions;
    private LatLng latLng;
    private boolean availabilityCheck = false;
    private Marker marker;
    private RecyclerView mRecyclerView;
    private LinearLayoutManager mLinearLayoutManager;
    private PlacesAutoCompleteAdapter mAutoCompleteAdapter;
    PlacesAutoCompleteAdapter.PlaceAutocomplete item;
    String featureName, locality, countryName;
    String placeId;
    ImageView delete;
    SupportMapFragment mapFragment;
    private boolean allowEditTextChangeListener = true; // disable google maps autocomplete when user clicks on map to avoid fetching location of chosen place
    private LatLng pos;
    static boolean invalidLocation = false; // this value confirms whether we are able to deliver to users location
    private LinearLayout linearLayout;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        buildGoogleApiClient();
        setContentView(R.layout.activity_search);


        mAutocompleteView = (EditText) findViewById(R.id.autocomplete_places);

        mapFragment = (SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map);
        mapFragment.getMapAsync(PlacesAutoCompleteActivity.this);

        linearLayout = (LinearLayout) findViewById(R.id.linear_layout);

        geocoder = new Geocoder(this, Locale.getDefault());
        markerOptions = new MarkerOptions();

        buildGoogleApiClient();
        delete = (ImageView) findViewById(R.id.cross);

        mAutoCompleteAdapter = new PlacesAutoCompleteAdapter(this, R.layout.searchview_adapter,
                mGoogleApiClient, BOUNDS_INDIA, null);

        mRecyclerView = (RecyclerView) findViewById(R.id.recyclerView);
        mLinearLayoutManager = new LinearLayoutManager(this);
        mRecyclerView.setLayoutManager(mLinearLayoutManager);
        mRecyclerView.setAdapter(mAutoCompleteAdapter);
       // mRecyclerView.setLayoutFrozen(true);
        delete.setOnClickListener(this);

        if (allowEditTextChangeListener) {
            Log.d("allowEditTextChangz1",allowEditTextChangeListener + "");
            mAutocompleteView.addTextChangedListener(new TextWatcher() {
                public void onTextChanged(CharSequence s, int start, int before,
                                          int count) {
                    Log.d("allowEditTextChangz1","jo");
                    if (!s.toString().equals("") && mGoogleApiClient.isConnected()) {
                        Log.d("allowEditTextChangzQ",s.toString());
                        mAutoCompleteAdapter.getFilter().filter(s.toString());
                    } else if (!mGoogleApiClient.isConnected()) {
                        checkAvailability.setEnabled(false);
                        checkAvailability.setAlpha(0.3f);
                        Toast.makeText(getApplicationContext(), Constants.API_NOT_CONNECTED, Toast.LENGTH_SHORT).show();
                        Log.e(Constants.PlacesTag, Constants.API_NOT_CONNECTED);
                    }

                }

                public void beforeTextChanged(CharSequence s, int start, int count,
                                              int after) {

                }

                public void afterTextChanged(Editable s) {

                }
            });
        }
        mRecyclerView.addOnItemTouchListener(
                new RecyclerItemClickListener(this, new RecyclerItemClickListener.OnItemClickListener() {
                    @Override
                    public void onItemClick(View view, int position) {
                        item = mAutoCompleteAdapter.getItem(position);
                        placeId = String.valueOf(item.placeId);

                        PendingResult<PlaceBuffer> placeResult = Places.GeoDataApi
                                .getPlaceById(mGoogleApiClient, placeId);
                        placeResult.setResultCallback(new ResultCallback<PlaceBuffer>() {
                            @Override
                            public void onResult(PlaceBuffer places) {
                                if (places.getCount() == 1) {
                                    mAutoCompleteAdapter.clear();
                                    mAutocompleteView.setText("");
                                    String country = "";

                                    try {
                                        List<Address> addresses = geocoder.getFromLocation(places.get(0).getLatLng().latitude,
                                                places.get(0).getLatLng().longitude, 1);
                                        sb = new StringBuilder();
                                        if (addresses.size() > 0) {
                                            android.location.Address address = addresses.get(0);

                                            featureName = address.getFeatureName();
                                            locality = address.getLocality();
                                            countryName = address.getCountryName();


                                            Log.d("featureName ",  featureName + "||" +
                                                    locality +"||" + countryName);
                                            if (featureName == null) {
                                                mapAddress = address.getLocality() + " " + address.getCountryName();
                                            } else if (locality == null) {
                                                mapAddress = address.getFeatureName() + ", " + address.getCountryName();
                                            } else if (countryName == null) {
                                                mapAddress = address.getFeatureName() + ", " + address.getLocality();
                                            } else {
                                                mapAddress = address.getFeatureName() + ", " + address.getLocality() + " " + address.getCountryName();
                                                country = address.getCountryName();
                                                Log.d("counttryy", "sasa"+country);
                                            }
                                        }
                                        Log.d("mpaddress", "kaka "+mapAddress + "||" + country);

                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                    CameraPosition cameraPosition = new CameraPosition.Builder()
                                            .target(places.get(0).getLatLng())      // Sets the center of the map to Mountain View
                                            .zoom(12)                   // Sets the zoom
                                            .bearing(90)                // Sets the orientation of the camera to east
                                            .tilt(30)                   // Sets the tilt of the camera to 30 degrees
                                            .build();                   // Creates a CameraPosition from the builder

                                    marker.remove(); // remove any marker from maponclick or maponlonclick
                                    marker = mMap.addMarker(new MarkerOptions().position(places.get(0).getLatLng())
                                            .title("My Location"));
                                    mMap.setTrafficEnabled(true);
                                    mMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
                                    if (countryName.toLowerCase().equals("kenya")){
                                        availabilityCheck = true;
                                        checkAvailability.setEnabled(true);
                                        confirmPosition();
                                    } else {
                                    }
                                } else {
                                    Toast.makeText(getApplicationContext(), Constants.SOMETHING_WENT_WRONG, Toast.LENGTH_SHORT).show();
                                }
                            }
                        });
                    }
                })
        );

        imageView = (ImageView) findViewById(R.id.maps_close);
        imageView.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                Log.d("close", "close");
                if (mAutoCompleteAdapter.getItemCount() != 0){
                    mAutoCompleteAdapter.clear();
                }
                mAutocompleteView.setText("");
            }
        });

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            checkLocationPermission();
        }
    }

    @Override
    public void onMapReady(GoogleMap googleMap) {
        mMap = googleMap;
        mMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (ContextCompat.checkSelfPermission(this,
                    Manifest.permission.ACCESS_FINE_LOCATION)
                    == PackageManager.PERMISSION_GRANTED) {
                buildGoogleApiClient();
                mMap.setMyLocationEnabled(true);

            }
        } else {
            buildGoogleApiClient();
             mMap.setMyLocationEnabled(true);

        }

    }

    @Override
    public void onLocationChanged(Location location) {

        mLastLocation = location;

        if (mCurrLocationMarker != null) {
            mCurrLocationMarker.remove();
        }
        //mMap.getUiSettings().setZoomControlsEnabled(true);

        final Double lat = location.getLatitude();
        final Double lng = location.getLongitude();
        Log.d("LATLANGz", lat + "|" + lng);
        latLng = new LatLng(lat, lng);
        markerOptions = new MarkerOptions();
        markerOptions.position(latLng);
        markerOptions.title("Current Positionn");
        markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_MAGENTA));
        marker = mMap.addMarker(markerOptions);

        //move map camera_main
        mMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
        mMap.animateCamera(CameraUpdateFactory.zoomTo(11));


        //stop location updates
        if (mGoogleApiClient != null) {
            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
        }


        try {
            List<Address> addresses = geocoder.getFromLocation(lat, lng, 1);
            sb = new StringBuilder();
            if (addresses.size() > 0) {
                android.location.Address address = addresses.get(0);

                String featureName = address.getFeatureName();
                String locality = address.getLocality();
                String countryName = address.getCountryName();

                System.out.println("featureName " + featureName + "||" + locality +"||" + countryName);
                if (featureName == null) {
                    mapAddress = address.getLocality() + " " + address.getCountryName();
                } else if (locality == null) {
                    mapAddress = address.getFeatureName() + ", " + address.getCountryName();
                } else if (countryName == null) {
                    mapAddress = address.getFeatureName() + ", " + address.getLocality();
                } else {
                    mapAddress = address.getFeatureName() + ", " + address.getLocality() + " " + address.getCountryName();
                }
            }
            System.out.println("mpaddress " + mapAddress + "||" );
            mAutocompleteView.setText(mapAddress);
        } catch (IOException e) {
            e.printStackTrace();
        }

        mMap.setOnMyLocationButtonClickListener(new GoogleMap.OnMyLocationButtonClickListener(){
            @Override
            public boolean onMyLocationButtonClick() {
                // Toast.makeText(getApplicationContext(), "2> "+mapAddress + lat + lng, Toast.LENGTH_LONG).show();
                return false;
            }});
    }

    protected synchronized void buildGoogleApiClient() {
        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API)
                .addApi(Places.GEO_DATA_API)
                .build();
        mGoogleApiClient.connect();
    }

    @Override
    public void onConnectionSuspended(int i) {
        Log.v("Google API Callback", "Connection Suspended");
        Log.v("Code", String.valueOf(i));
    }

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {
        Log.v("Google API Callback","Connection Failed");
        Log.v("Error Code", String.valueOf(connectionResult.getErrorCode()));
        Toast.makeText(this, Constants.API_NOT_CONNECTED, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onClick(View v) {
        if(v==delete){
            mAutocompleteView.setText("");
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        if (!mGoogleApiClient.isConnected() && !mGoogleApiClient.isConnecting()){
            Log.v("Google API","Connecting");
            mGoogleApiClient.connect();
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        if(mGoogleApiClient.isConnected()){
            Log.v("Google API","Dis-Connecting");
            mGoogleApiClient.disconnect();
        }
    }

    @Override
    public void onBackPressed() {
        super.onBackPressed();
    }

    public static final int MY_PERMISSIONS_REQUEST_LOCATION = 99;
    public boolean checkLocationPermission(){
        if (ContextCompat.checkSelfPermission(this,
                Manifest.permission.ACCESS_FINE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {
            Log.d("permission","permission");
            // Asking user if explanation is needed
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                    Manifest.permission.ACCESS_FINE_LOCATION)) {
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                        MY_PERMISSIONS_REQUEST_LOCATION);


            } else {
                Log.d("permission2","permission2");
                // No explanation needed, we can request the permission.
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                        MY_PERMISSIONS_REQUEST_LOCATION);
            }
            return false;
        } else {
            return true;
        }
    }

    @Override
    public void onConnected(Bundle bundle) {

        mLocationRequest = new LocationRequest();
        mLocationRequest.setInterval(1000);
        mLocationRequest.setFastestInterval(1000);
        mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);

        if (mGoogleApiClient.isConnected()){
            if (ContextCompat.checkSelfPermission(this,
                    Manifest.permission.ACCESS_FINE_LOCATION)
                    == PackageManager.PERMISSION_GRANTED) {
                LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
            }
        }
    }
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        switch (requestCode) {
            case MY_PERMISSIONS_REQUEST_LOCATION: {
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                    if (ContextCompat.checkSelfPermission(this,
                            Manifest.permission.ACCESS_FINE_LOCATION)
                            == PackageManager.PERMISSION_GRANTED) {

                        if (mGoogleApiClient == null) {
                            buildGoogleApiClient();
                        }
//                        mMap.setMyLocationEnabled(true);
                    }

                } else {
                    Toast.makeText(this, "permission denied", Toast.LENGTH_LONG).show();
                }
                return;
            }
        }
    }

    @Override
    public void onStart(){
        super.onStart();
        buildGoogleApiClient();
        if (isNetworkAvailable() == true){
            if (isLocationEnabled(getApplicationContext())){
                //  Toast.makeText(getApplicationContext(), "enabled", Toast.LENGTH_LONG).show();
                if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                    checkLocationPermission();
                }
                // Obtain the SupportMapFragment and get notified when the map is ready to be used.
                SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                        .findFragmentById(R.id.map);
                mapFragment.getMapAsync(this);
            } else{
                Display.displaySnackbar(getApplicationContext(), linearLayout, "YOUR GPS IS CURRENTLY DISABLED");
                showLocationDialog();
            }
        } else {
            Display.displaySnackbar(getApplicationContext(), linearLayout, "YOU ARE CURRENTLY OFFLINE");
            showInternetDialog();
        }

    }

    public void showInternetDialog(){
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setMessage("Please turn on mobile network or Wi-Fi in Settings.")
                .setTitle("WIFI Disabled")
                .setCancelable(false)
                .setPositiveButton("Settings",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                Intent i = new Intent(Settings.ACTION_WIRELESS_SETTINGS);
                                startActivity(i);
                            }
                        }
                )
                .setNegativeButton("Cancel",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                PlacesAutoCompleteActivity.this.finish();
                            }
                        }
                );
        AlertDialog alert = builder.create();
        alert.show();
    }

    public boolean isNetworkAvailable() {
        ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager
                .getActiveNetworkInfo();
        return activeNetworkInfo != null;
    }

    public static boolean isLocationEnabled(Context context) {
        int locationMode = 0;
        String locationProviders;

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){
            try {
                locationMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE);

            } catch (Settings.SettingNotFoundException e) {
                e.printStackTrace();
                return false;
            }

            return locationMode != Settings.Secure.LOCATION_MODE_OFF;

        }else{
            locationProviders = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
            return !TextUtils.isEmpty(locationProviders);
        }
    }

    public void showLocationDialog(){
        executeOnStart = true;
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setMessage(R.string.gps_not_found_message)
                .setTitle(R.string.gps_not_found_title)
                .setCancelable(false)
                .setPositiveButton("Settings",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                Intent i = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                                startActivity(i);
                            }
                        }
                )
                .setNegativeButton("Cancel",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dg, int id) {
                                // dialog.dismiss();
                                // SignIn.dialog.dismiss();
                                PlacesAutoCompleteActivity.this.finish();

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

}

3 个答案:

答案 0 :(得分:2)

这是Javascript中名为吊装的行为。

  

Hoisting是一种JavaScript机制,其中包含变量和函数   声明在代码之前移动到其作用域的顶部   执行。

javascript中的

var不是块作用域。 您可以在ES6中使用关键字letconst来声明仅在声明的块中可用的变量。

var size = 100;
if (size > 50) {
    let boxSize = size * 5;
    console.log(boxSize);
}
console.log(boxSize);// Uncaught ReferenceError: boxSize is not defined

答案 1 :(得分:0)

我建议使用let over var

  

区别在于范围界定。 var的范围限定为最近的功能块,并且将范围限定为最近的封闭块,该封闭块可以小于功能块。如果在任何区块之外,两者都是全球性的。

src:https://stackoverflow.com/a/11444416/4891666

示例:

&#13;
&#13;
var size = 100;

/* Using Var */
if (size > 50) {
  var varExample = size * 5;
  console.log("With var inner: " + varExample);
}
console.log("With var outer: " + varExample);

/* Using Let */
if (size > 50) {
  let letExample = size * 5;
  console.log("With let inner: " + letExample);
}
console.log("With let outer: " + letExample);
&#13;
&#13;
&#13;

答案 2 :(得分:0)

let size = 100;
if (size > 50) {
  let boxSize = size * 5;
    console.log(boxSize);
}
console.log(boxSize);
/* Es6 let declers a block scope
  local variable(not function level scope like var)
  */
  //trying to access the variable in the block before the variable declaration resulsts in a ReferenceError