Java tutorial
/* * Copyright 2017 Google Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.wspa.dm.eopiekun; import android.Manifest; import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; import android.location.Geocoder; import android.location.Location; import android.net.Uri; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.ResultReceiver; import android.provider.Settings; import android.support.annotation.NonNull; import android.support.design.widget.Snackbar; import android.support.v4.app.ActivityCompat; import android.support.v7.app.AppCompatActivity; import android.text.TextUtils; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.ProgressBar; import android.widget.TextView; import android.widget.Toast; import com.google.android.gms.location.FusedLocationProviderClient; import com.google.android.gms.location.LocationServices; import com.google.android.gms.tasks.OnFailureListener; import com.google.android.gms.tasks.OnSuccessListener; import com.google.firebase.auth.FirebaseAuth; import com.google.firebase.auth.FirebaseUser; import com.google.firebase.database.DatabaseReference; import com.google.firebase.database.FirebaseDatabase; /** * Getting the Location Address. * * Demonstrates how to use the {@link Geocoder} API and reverse geocoding to * display a device's location as an address. Uses an IntentService to fetch the location address, * and a ResultReceiver to process results sent by the IntentService. * * Android has two location request settings: * {@code ACCESS_COARSE_LOCATION} and {@code ACCESS_FINE_LOCATION}. These settings control * the accuracy of the current location. This sample uses ACCESS_FINE_LOCATION, as defined in * the AndroidManifest.xml. * * For a starter example that displays the last known location of a device using a longitude and latitude, * see https://github.com/googlesamples/android-play-location/tree/master/BasicLocation. * * For an example that shows location updates using the Fused Location Provider API, see * https://github.com/googlesamples/android-play-location/tree/master/LocationUpdates. */ public class GetLocationAdress extends AppCompatActivity { private static final String TAG = GetLocationAdress.class.getSimpleName(); private static final int REQUEST_PERMISSIONS_REQUEST_CODE = 34; private static final String ADDRESS_REQUESTED_KEY = "address-request-pending"; private static final String LOCATION_ADDRESS_KEY = "location-address"; /** * Provides access to the Fused Location Provider API. */ private FusedLocationProviderClient mFusedLocationClient; /** * Represents a geographical location. */ private Location mLastLocation; /** * Tracks whether the user has requested an address. Becomes true when the user requests an * address and false when the address (or an error message) is delivered. */ private boolean mAddressRequested; /** * The formatted location address. */ private String mAddressOutput; /** * Receiver registered with this activity to get the response from FetchAddressIntentService. */ private AddressResultReceiver mResultReceiver; /** * Displays the location address. */ private TextView mLocationAddressTextView; /** * Visible while the address is being fetched. */ private ProgressBar mProgressBar; /** * Kicks off the request to fetch an address when pressed. */ private Button mFetchAddressButton; //fireb static Context context; String finaladresstring; private FirebaseAuth auth; private FirebaseAuth.AuthStateListener authListener; private DatabaseReference mDatabase; String uid; //fireb/ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.get_location_adress_activity); GetLocation.context = getApplicationContext(); //fireb mDatabase = FirebaseDatabase.getInstance().getReference(); //get firebase auth instance auth = FirebaseAuth.getInstance(); //get current user final FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); uid = user.getUid(); authListener = new FirebaseAuth.AuthStateListener() { @Override public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) { FirebaseUser user = firebaseAuth.getCurrentUser(); if (user == null) { // user auth state is changed - user is null // launch login activity startActivity(new Intent(GetLocationAdress.this, LoginActivity.class)); finish(); } } }; //fireb/ mResultReceiver = new AddressResultReceiver(new Handler()); mLocationAddressTextView = (TextView) findViewById(R.id.location_address_view); mProgressBar = (ProgressBar) findViewById(R.id.progress_bar); mFetchAddressButton = (Button) findViewById(R.id.fetch_address_button); // Set defaults, then update using values stored in the Bundle. mAddressRequested = false; mAddressOutput = ""; updateValuesFromBundle(savedInstanceState); mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this); updateUIWidgets(); } @Override public void onStart() { super.onStart(); if (!checkPermissions()) { requestPermissions(); } else { getAddress(); } } /** * Updates fields based on data stored in the bundle. */ private void updateValuesFromBundle(Bundle savedInstanceState) { if (savedInstanceState != null) { // Check savedInstanceState to see if the address was previously requested. if (savedInstanceState.keySet().contains(ADDRESS_REQUESTED_KEY)) { mAddressRequested = savedInstanceState.getBoolean(ADDRESS_REQUESTED_KEY); } // Check savedInstanceState to see if the location address string was previously found // and stored in the Bundle. If it was found, display the address string in the UI. if (savedInstanceState.keySet().contains(LOCATION_ADDRESS_KEY)) { mAddressOutput = savedInstanceState.getString(LOCATION_ADDRESS_KEY); displayAddressOutput(); } } } /** * Runs when user clicks the Fetch Address button. */ // @SuppressWarnings("unused") public void fetchAddressButtonHandler(View view) { if (isLocationEnabled(getApplicationContext()) == false)//!!!! { showToast("Enable localization first!"); } else { if (mLastLocation != null) { startIntentService(); return; } // If we have not yet retrieved the user location, we process the user's request by setting // mAddressRequested to true. As far as the user is concerned, pressing the Fetch Address button // immediately kicks off the process of getting the address. mAddressRequested = true; updateUIWidgets(); } } /** * Creates an intent, adds location data to it as an extra, and starts the intent service for * fetching an address. */ private void startIntentService() { // 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(Constants.RECEIVER, mResultReceiver); // Pass the location data as an extra to the service. intent.putExtra(Constants.LOCATION_DATA_EXTRA, mLastLocation); // 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); } /** * Gets the address for the last known location. */ @SuppressWarnings("MissingPermission") private void getAddress() { mFusedLocationClient.getLastLocation().addOnSuccessListener(this, new OnSuccessListener<Location>() { @Override public void onSuccess(Location location) { if (location == null) { Log.w(TAG, "onSuccess:null"); return; } mLastLocation = location; // Determine whether a Geocoder is available. if (!Geocoder.isPresent()) { showSnackbar(getString(R.string.no_geocoder_available)); return; } // If the user pressed the fetch address button before we had the location, // this will be set to true indicating that we should kick off the intent // service after fetching the location. if (mAddressRequested) { startIntentService(); } } }).addOnFailureListener(this, new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "getLastLocation:onFailure", e); } }); } /** * Updates the address in the UI. */ private void displayAddressOutput() { mLocationAddressTextView.setText(mAddressOutput); } /** * Toggles the visibility of the progress bar. Enables or disables the Fetch Address button. */ private void updateUIWidgets() { if (mAddressRequested) { mProgressBar.setVisibility(ProgressBar.VISIBLE); mFetchAddressButton.setEnabled(false); } else { mProgressBar.setVisibility(ProgressBar.GONE); mFetchAddressButton.setEnabled(true); } } /** * Shows a toast with the given text. */ private void showToast(String text) { Toast.makeText(this, text, Toast.LENGTH_SHORT).show(); } @Override public void onSaveInstanceState(Bundle savedInstanceState) { // Save whether the address has been requested. savedInstanceState.putBoolean(ADDRESS_REQUESTED_KEY, mAddressRequested); // Save the address string. savedInstanceState.putString(LOCATION_ADDRESS_KEY, mAddressOutput); super.onSaveInstanceState(savedInstanceState); } /** * Receiver for data sent from FetchAddressIntentService. */ private class AddressResultReceiver extends ResultReceiver { AddressResultReceiver(Handler handler) { super(handler); } /** * Receives data sent from FetchAddressIntentService and updates the UI in GetLocationAdress. */ @Override protected void onReceiveResult(int resultCode, Bundle resultData) { // Display the address string or an error message sent from the intent service. mAddressOutput = resultData.getString(Constants.RESULT_DATA_KEY); displayAddressOutput(); // Show a toast message if an address was found. if (resultCode == Constants.SUCCESS_RESULT) { showToast(getString(R.string.address_found)); //!!!!!!!! senddb(mAddressOutput); } // Reset. Enable the Fetch Address button and stop showing the progress bar. mAddressRequested = false; updateUIWidgets(); startActivity(new Intent(GetLocationAdress.this, MainPage.class)); finish(); } } /** * Shows a {@link Snackbar} using {@code text}. * * @param text The Snackbar text. */ private void showSnackbar(final String text) { View container = findViewById(android.R.id.content); if (container != null) { Snackbar.make(container, text, Snackbar.LENGTH_LONG).show(); } } /** * Shows a {@link Snackbar}. * * @param mainTextStringId The id for the string resource for the Snackbar text. * @param actionStringId The text of the action item. * @param listener The listener associated with the Snackbar action. */ private void showSnackbar(final int mainTextStringId, final int actionStringId, View.OnClickListener listener) { Snackbar.make(findViewById(android.R.id.content), getString(mainTextStringId), Snackbar.LENGTH_INDEFINITE) .setAction(getString(actionStringId), listener).show(); } /** * Return the current state of the permissions needed. */ private boolean checkPermissions() { int permissionState = ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION); return permissionState == PackageManager.PERMISSION_GRANTED; } private void requestPermissions() { boolean shouldProvideRationale = ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION); // Provide an additional rationale to the user. This would happen if the user denied the // request previously, but didn't check the "Don't ask again" checkbox. if (shouldProvideRationale) { Log.i(TAG, "Displaying permission rationale to provide additional context."); showSnackbar(R.string.permission_rationale, android.R.string.ok, new View.OnClickListener() { @Override public void onClick(View view) { // Request permission ActivityCompat.requestPermissions(GetLocationAdress.this, new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, REQUEST_PERMISSIONS_REQUEST_CODE); } }); } else { Log.i(TAG, "Requesting permission"); // Request permission. It's possible this can be auto answered if device policy // sets the permission in a given state or the user denied the permission // previously and checked "Never ask again". ActivityCompat.requestPermissions(GetLocationAdress.this, new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, REQUEST_PERMISSIONS_REQUEST_CODE); } } /** * Callback received when a permissions request has been completed. */ @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { Log.i(TAG, "onRequestPermissionResult"); if (requestCode == REQUEST_PERMISSIONS_REQUEST_CODE) { if (grantResults.length <= 0) { // If user interaction was interrupted, the permission request is cancelled and you // receive empty arrays. Log.i(TAG, "User interaction was cancelled."); } else if (grantResults[0] == PackageManager.PERMISSION_GRANTED) { // Permission granted. getAddress(); } else { // Permission denied. // Notify the user via a SnackBar that they have rejected a core permission for the // app, which makes the Activity useless. In a real app, core permissions would // typically be best requested during a welcome-screen flow. // Additionally, it is important to remember that a permission might have been // rejected without asking the user for permission (device policy or "Never ask // again" prompts). Therefore, a user interface affordance is typically implemented // when permissions are denied. Otherwise, your app could appear unresponsive to // touches or interactions which have required permissions. showSnackbar(R.string.permission_denied_explanation, R.string.settings, new View.OnClickListener() { @Override public void onClick(View view) { // Build intent that displays the App settings screen. Intent intent = new Intent(); intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS); Uri uri = Uri.fromParts("package", BuildConfig.APPLICATION_ID, null); intent.setData(uri); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); startActivity(intent); } }); } } } 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 senddb(String data) { mDatabase.child("users").child(uid).push().setValue(data); } }