title: not able to zoom at current location in google maps android
body: <p>Below is the code for map activity, i am not able to zoom at current location.I want that when a user opens the app, map should gets zooms at the current location.Please correct me where i am wrong. </p>
  
  <p>Thanks</p>
  
  <pre><code>public class MapActivity extends BaseActivty implements
          OnMapReadyCallback, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, com.google.android.gms.location.LocationListener {
      private GoogleMap mMap;
      private GoogleApiClient mGoogleApiClient;
      private final static int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;
      private static String TAG = "MAP LOCATION";
      Context mContext;
      TextView mLocationMarkerText;
      private LatLng mCenterLatLong;
  
      LocationManager locationManager;
      private AddressResultReceiver mResultReceiver;
      private ImageView mMarker;
      DatabaseReference databaseMediCare;
  
      protected String mAddressOutput;
      protected String mAreaOutput;
      protected String mCityOutput;
      protected String mStateOutput;
      EditText mLocationAddress;
      TextView mLocationText;
      private static final int REQUEST_CODE_AUTOCOMPLETE = 1;
  
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_map);
          mContext = this;
          // Obtain the SupportMapFragment and get notified when the map is ready to be used.
          SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                  .findFragmentById(map);
  
          mLocationMarkerText = (TextView) findViewById(R.id.locationMarkertext);
          mLocationAddress = (EditText) findViewById(R.id.Address);
          mMarker= (ImageView)findViewById(R.id.imageMarker);
            mLocationText = (TextView) findViewById(R.id.Locality);
  
          mLocationText.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
  
                  openAutocompleteActivity();
  
              }
  
          });
          mapFragment.getMapAsync(this);
          mResultReceiver = new AddressResultReceiver(new Handler());
  
          if (checkPlayServices()) {
              // If this check succeeds, proceed with normal processing.
              // Otherwise, prompt user to get valid Play Services APK.
              if (!AppUtils.isLocationEnabled(mContext)) {
                  // notify user
                  AlertDialog.Builder dialog = new AlertDialog.Builder(mContext);
                  dialog.setMessage("Location not enabled!");
                  dialog.setPositiveButton("Open location settings", new DialogInterface.OnClickListener() {
                      @Override
                      public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                          Intent myIntent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                          startActivity(myIntent);
                      }
                  });
                  dialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
  
                      @Override
                      public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                          // TODO Auto-generated method stub
  
                      }
                  });
                  dialog.show();
              }
              buildGoogleApiClient();
          } else {
              Toast.makeText(mContext, "Location not supported in this device", Toast.LENGTH_SHORT).show();
          }
  
        }
  
  
  
      /**
       * Manipulates the map once available.
       * This callback is triggered when the map is ready to be used.
       * This is where we can add markers or lines, add listeners or move the camera. In this case,
       * we just add a marker near Sydney, Australia.
       * If Google Play services is not installed on the device, the user will be prompted to install
       * it inside the SupportMapFragment. This method will only be triggered once the user has
       * installed Google Play services and returned to the app.
       */
  
      @Override
      public void onMapReady(GoogleMap googleMap) {
          Log.d(TAG, "OnMapReady");
          mMap = googleMap;
  
          mMap.setOnCameraChangeListener(new GoogleMap.OnCameraChangeListener() {
              @Override
              public void onCameraChange(CameraPosition cameraPosition) {
                  //Log.d("Camera postion change" + "", cameraPosition + "");
                  mCenterLatLong = cameraPosition.target;
                  String fullAddress = "";
  
                  mMap.clear();
  
                  try {
  
                      Location mLocation = new Location("");
                      mLocation.setLatitude(mCenterLatLong.latitude);
                      mLocation.setLongitude(mCenterLatLong.longitude);
                      startIntentService(mLocation);
                      // handleNewLocation(mLocation);
                      getCurrentLocation();
                      fullAddress =getCompleteAddressString(mLocation.getLatitude(),mLocation.getLongitude());
                      mLocationMarkerText.setText(fullAddress);
                      //mLocationMarkerText.setText("Lat : " + mCenterLatLong.latitude + "," + "Long : " + mCenterLatLong.longitude);
  
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          });
          if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &amp;&amp; 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;
          }
  //        mMap.setMyLocationEnabled(true);
  //        mMap.getUiSettings().setMyLocationButtonEnabled(true);
  //
  //        // Add a marker in current location and move the camera
  
      }
  
  
  
  
      @Override
      public void onConnected(Bundle bundle) {
          if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &amp;&amp; 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;
          }
          Location mLastLocation = LocationServices.FusedLocationApi.getLastLocation(
                  mGoogleApiClient);
          if (mLastLocation != null) {
              changeMap(mLastLocation);
              Log.d(TAG, "ON connected");
  
          } else
              try {
                  LocationServices.FusedLocationApi.removeLocationUpdates(
                          mGoogleApiClient, this);
  
              } catch (Exception e) {
                  e.printStackTrace();
              }
          try {
              LocationRequest mLocationRequest = new LocationRequest();
              mLocationRequest.setInterval(10000);
              mLocationRequest.setFastestInterval(5000);
              mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
              LocationServices.FusedLocationApi.requestLocationUpdates(
                      mGoogleApiClient, mLocationRequest, this);
  
          } catch (Exception e) {
              e.printStackTrace();
          }
  
      }
  
      @Override
      public void onConnectionSuspended(int i) {
          Log.i(TAG, "Connection suspended");
          mGoogleApiClient.connect();
      }
  
      @Override
      public void onLocationChanged(Location location) {
          try {
              if (location != null)
                  changeMap(location);
              LocationServices.FusedLocationApi.removeLocationUpdates(
                      mGoogleApiClient, this);
  
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      @Override
      public void onConnectionFailed(ConnectionResult connectionResult) {
  
      }
  
  
      protected synchronized void buildGoogleApiClient() {
          mGoogleApiClient = new GoogleApiClient.Builder(this)
                  .addConnectionCallbacks(this)
                  .addOnConnectionFailedListener(this)
                  .addApi(LocationServices.API)
                  .build();
      }
  
      @Override
      public void onStart() {
          super.onStart();
          try {
              mGoogleApiClient.connect();
  
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      @Override
      protected void onStop() {
          super.onStop();
          try {
  
          } catch (RuntimeException e) {
              e.printStackTrace();
          }
          if (mGoogleApiClient != null &amp;&amp; mGoogleApiClient.isConnected()) {
              mGoogleApiClient.disconnect();
          }
      }
  
      private boolean checkPlayServices() {
          int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
          if (resultCode != ConnectionResult.SUCCESS) {
              if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
                  GooglePlayServicesUtil.getErrorDialog(resultCode, this,
                          PLAY_SERVICES_RESOLUTION_REQUEST).show();
              } else {
                  //finish();
              }
              return false;
          }
          return true;
      }
  
      private void changeMap(Location location) {
  
          Log.d(TAG, "Reaching map" + mMap);
  
  
          if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &amp;&amp; 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;
          }
  
  
  
          // check if map is created successfully or not
          if (mMap != null) {
              mMap.getUiSettings().setZoomControlsEnabled(true);
              LatLng latLong;
              String fullAddress = "";
  
              latLong = new LatLng(location.getLatitude(), location.getLongitude());
  
              CameraPosition cameraPosition = new CameraPosition.Builder()
                      .target(latLong).zoom(19f).tilt(0).build();
  
              mMap.setMyLocationEnabled(true);
              mMap.getUiSettings().setMyLocationButtonEnabled(true);
              mMap.animateCamera(CameraUpdateFactory
                      .newCameraPosition(cameraPosition));
  
              //mMap.moveCamera( CameraUpdateFactory.newLatLngZoom(new LatLng(20.5937,78.9629) , 19f) );
  
              mLocationMarkerText.setText("Lat : " + location.getLatitude() + "," + "Long : " + location.getLongitude());
              fullAddress =getCompleteAddressString(location.getLatitude(),location.getLongitude());
              mLocationMarkerText.setText(fullAddress);
              startIntentService(location);
              // showToast("hii" + getCompleteAddressString(location.getLatitude(),location.getLongitude()));
  
          } else {
              Toast.makeText(getApplicationContext(),
                      "Sorry! unable to create maps", Toast.LENGTH_SHORT)
                      .show();
          }
  
      }
  
  
  
      /**
       * Receiver for data sent from FetchAddressIntentService.
       */
  
      class AddressResultReceiver extends ResultReceiver {
          public AddressResultReceiver(Handler handler) {
              super(handler);
          }
  
  
          /**
           * Receives data sent from FetchAddressIntentService and updates the UI in MainActivity.
           */
  
          @Override
          protected void onReceiveResult(int resultCode, Bundle resultData) {
  
              // Display the address string or an error message sent from the intent service.
              mAddressOutput = resultData.getString(AppUtils.LocationConstants.RESULT_DATA_KEY);
  
              mAreaOutput = resultData.getString(AppUtils.LocationConstants.LOCATION_DATA_AREA);
  
              mCityOutput = resultData.getString(AppUtils.LocationConstants.LOCATION_DATA_CITY);
              mStateOutput = resultData.getString(AppUtils.LocationConstants.LOCATION_DATA_STREET);
  
              displayAddressOutput();
  
              // Show a toast message if an address was found.
              if (resultCode == AppUtils.LocationConstants.SUCCESS_RESULT) {
                  //  showToast(getString(R.string.address_found));
  
  
              }
  
  
          }
  
      }
  
  
      /**
       * Updates the address in the UI.
       */
  
      protected void displayAddressOutput() {
          // mLocationAddressTextView.setText(mAddressOutput);
          try {
              if (mAreaOutput != null)
                  mLocationText.setText(mAreaOutput+ "");
  
              mLocationAddress.setText(mAddressOutput);
              mLocationText.setText(mAreaOutput);
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
  
      /**
       * Creates an intent, adds location data to it as an extra, and starts the intent service for
       * fetching an address.
       */
  
      protected void startIntentService(Location mLocation) {
          // Create an intent for passing to the intent service responsible for fetching the address.
          Intent intent = new Intent(this, FetchAddressIntentService.class);
  
          // Pass the result receiver as an extra to the service.
          intent.putExtra(AppUtils.LocationConstants.RECEIVER, mResultReceiver);
  
          // Pass the location data as an extra to the service.
          intent.putExtra(AppUtils.LocationConstants.LOCATION_DATA_EXTRA, mLocation);
  
          // Start the service. If the service isn't already running, it is instantiated and started
          // (creating a process for it if needed); if it is running then it remains running. The
          // service kills itself automatically once all intents are processed.
          startService(intent);
      }
  
  
      private void openAutocompleteActivity() {
          try {
              // The autocomplete activity requires Google Play Services to be available. The intent
              // builder checks this and throws an exception if it is not the case.
              Intent intent = new PlaceAutocomplete.IntentBuilder(PlaceAutocomplete.MODE_FULLSCREEN)
                      .build(this);
              startActivityForResult(intent, REQUEST_CODE_AUTOCOMPLETE);
          } catch (GooglePlayServicesRepairableException e) {
              // Indicates that Google Play Services is either not installed or not up to date. Prompt
              // the user to correct the issue.
              GoogleApiAvailability.getInstance().getErrorDialog(this, e.getConnectionStatusCode(),
                      0 /* requestCode */).show();
              e.printStackTrace();
  
          } catch (GooglePlayServicesNotAvailableException e) {
              // Indicates that Google Play Services is not available and the problem is not easily
              // resolvable.
              e.printStackTrace();
              String message = "Google Play Services is not available: " +
                      GoogleApiAvailability.getInstance().getErrorString(e.errorCode);
  
              Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
          }
      }
  
  
      /**
       * Called after the autocomplete activity has finished to return its result.
       */
  
      @Override
      public void onActivityResult(int requestCode, int resultCode, Intent data) {
          super.onActivityResult(requestCode, resultCode, data);
  
          // Check that the result was from the autocomplete widget.
          if (requestCode == REQUEST_CODE_AUTOCOMPLETE) {
              if (resultCode == RESULT_OK) {
                  // Get the user's selected place from the Intent.
                  Place place = PlaceAutocomplete.getPlace(mContext, data);
  
                  // TODO call location based filter
  
  
                  LatLng latLong;
  
  
                  latLong = place.getLatLng();
  
                  mLocationText.setText(place.getName() + "");
  
                  CameraPosition cameraPosition = new CameraPosition.Builder()
                          .target(latLong).zoom(19f).tilt(70).build();
  
  
                  if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &amp;&amp; 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;
                  }
                  mMap.setMyLocationEnabled(true);
                  mMap.animateCamera(CameraUpdateFactory
                          .newCameraPosition(cameraPosition));
  
  
              }
  
  
          } else if (resultCode == PlaceAutocomplete.RESULT_ERROR) {
              Status status = PlaceAutocomplete.getStatus(mContext, data);
          } else if (resultCode == RESULT_CANCELED) {
              // Indicates that the activity closed before a selection was made. For example if
              // the user pressed the back button.
          }
      }
      private String getCompleteAddressString(double LATITUDE, double LONGITUDE) {
          String strAdd = "";
          Geocoder geocoder = new Geocoder(this, Locale.getDefault());
          try {
              List&lt;Address&gt; addresses = geocoder.getFromLocation(LATITUDE, LONGITUDE, 1);
              if (addresses != null) {
                  Address returnedAddress = addresses.get(0);
                  StringBuilder strReturnedAddress = new StringBuilder("");
  
                  for (int i = 0; i &lt; returnedAddress.getMaxAddressLineIndex(); i++) {
                      strReturnedAddress.append(returnedAddress.getAddressLine(i)).append("\n");
                  }
                  strAdd = strReturnedAddress.toString();
                  //Log.w("My Current loction address", "" + strReturnedAddress.toString());
              } else {
  //                Log.w("My Current loction address", "No Address returned!");
              }
          } catch (Exception e) {
              e.printStackTrace();
  //            Log.w("My Current loction address", "Canont get Address!");
          }
          return strAdd;
      }
  }
  </code></pre>