Java tutorial
package com.adevani.mytube; /* * Copyright 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. */ import android.Manifest; import android.content.DialogInterface; import android.content.Intent; import android.content.IntentSender; import android.content.pm.PackageManager; import android.os.Bundle; import android.support.annotation.NonNull; import android.support.design.widget.Snackbar; import android.support.v4.app.ActivityCompat; import android.support.v4.content.ContextCompat; import android.support.v7.app.AppCompatActivity; import android.util.Log; import android.view.View; import android.widget.TextView; import android.widget.Toast; import com.adevani.helper.FetchToken; import com.google.android.gms.common.ConnectionResult; import com.google.android.gms.common.GoogleApiAvailability; import com.google.android.gms.common.Scopes; import com.google.android.gms.common.SignInButton; import com.google.android.gms.common.api.GoogleApiClient; import com.google.android.gms.common.api.Scope; import com.google.android.gms.plus.Plus; import com.google.android.gms.plus.model.people.Person; import com.google.api.services.youtube.YouTubeScopes; /** * Minimal activity demonstrating basic Google Sign-In. */ public class MainActivity extends AppCompatActivity implements View.OnClickListener, ActivityCompat.OnRequestPermissionsResultCallback, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener { private static final String TAG = "MainActivity"; /* RequestCode for resolutions involving sign-in */ private static final int RC_SIGN_IN = 1; /* RequestCode for resolutions to get GET_ACCOUNTS permission on M */ private static final int RC_PERM_GET_ACCOUNTS = 2; /* Keys for persisting instance variables in savedInstanceState */ private static final String KEY_IS_RESOLVING = "is_resolving"; private static final String KEY_SHOULD_RESOLVE = "should_resolve"; /* Client for accessing Google APIs */ private GoogleApiClient mGoogleApiClient; /* View to display current status (signed-in, signed-out, disconnected, etc) */ private TextView mStatus; // [START resolution_variables] /* Is there a ConnectionResult resolution in progress? */ private boolean mIsResolving = false; /* Should we automatically resolve ConnectionResults when possible? */ private boolean mShouldResolve = false; // [END resolution_variables] public static String FETCH_TOKEN; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Restore from saved instance state // [START restore_saved_instance_state] if (savedInstanceState != null) { mIsResolving = savedInstanceState.getBoolean(KEY_IS_RESOLVING); mShouldResolve = savedInstanceState.getBoolean(KEY_SHOULD_RESOLVE); } // [END restore_saved_instance_state] // Set up button click listeners findViewById(R.id.sign_in_button).setOnClickListener(this); findViewById(R.id.sign_out_button).setOnClickListener(this); findViewById(R.id.disconnect_button).setOnClickListener(this); // Large sign-in ((SignInButton) findViewById(R.id.sign_in_button)).setSize(SignInButton.SIZE_WIDE); // Start with sign-in button disabled until sign-in either succeeds or fails findViewById(R.id.sign_in_button).setEnabled(false); // Set up view instances mStatus = (TextView) findViewById(R.id.status); // [START create_google_api_client] // Build GoogleApiClient with access to basic profile mGoogleApiClient = new GoogleApiClient.Builder(this).addConnectionCallbacks(this) .addOnConnectionFailedListener(this).addApi(Plus.API).addScope(new Scope(Scopes.PROFILE)) .addScope(new Scope(Scopes.EMAIL)).addScope(new Scope(YouTubeScopes.YOUTUBE)).build(); // [END create_google_api_client] } private void updateUI(boolean isSignedIn) { if (isSignedIn) { Person currentPerson = Plus.PeopleApi.getCurrentPerson(mGoogleApiClient); if (currentPerson != null) { // Show signed-in user's name String name = currentPerson.getDisplayName(); //mStatus.setText(getString(R.string.signed_in_fmt, name)); // Show users' email address (which requires GET_ACCOUNTS permission) //Get the FetchToken if (checkAccountsPermission()) { String currentAccount = Plus.AccountApi.getAccountName(mGoogleApiClient); ((TextView) findViewById(R.id.email)).setText(currentAccount); FetchToken ft = new FetchToken(currentAccount, getApplicationContext()); ft.execute(); } } else { // If getCurrentPerson returns null there is generally some error with the // configuration of the application (invalid Client ID, Plus API not enabled, etc). Log.w(TAG, getString(R.string.error_null_person)); //mStatus.setText(getString(R.string.signed_in_err)); } // Set button visibility findViewById(R.id.sign_in_button).setVisibility(View.GONE); findViewById(R.id.sign_out_and_disconnect).setVisibility(View.VISIBLE); Intent myIntent = new Intent(MainActivity.this, HomeActivity.class); MainActivity.this.startActivity(myIntent); } else { // Show signed-out message and clear email field //mStatus.setText(R.string.signed_out); ((TextView) findViewById(R.id.email)).setText(""); // Set button visibility findViewById(R.id.sign_in_button).setEnabled(true); findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE); findViewById(R.id.sign_out_and_disconnect).setVisibility(View.GONE); } } /** * Check if we have the GET_ACCOUNTS permission and request it if we do not. * @return true if we have the permission, false if we do not. */ private boolean checkAccountsPermission() { final String perm = Manifest.permission.GET_ACCOUNTS; int permissionCheck = ContextCompat.checkSelfPermission(this, perm); if (permissionCheck == PackageManager.PERMISSION_GRANTED) { // We have the permission return true; } else if (ActivityCompat.shouldShowRequestPermissionRationale(this, perm)) { // Need to show permission rationale, display a snackbar and then request // the permission again when the snackbar is dismissed. Snackbar.make(findViewById(R.id.main_layout), R.string.contacts_permission_rationale, Snackbar.LENGTH_INDEFINITE).setAction(android.R.string.ok, new View.OnClickListener() { @Override public void onClick(View v) { // Request the permission again. ActivityCompat.requestPermissions(MainActivity.this, new String[] { perm }, RC_PERM_GET_ACCOUNTS); } }).show(); return false; } else { // No explanation needed, we can request the permission. ActivityCompat.requestPermissions(this, new String[] { perm }, RC_PERM_GET_ACCOUNTS); return false; } } private void showSignedInUI() { updateUI(true); } private void showSignedOutUI() { updateUI(false); } // [START on_start_on_stop] @Override protected void onStart() { super.onStart(); mGoogleApiClient.connect(); } @Override protected void onStop() { super.onStop(); mGoogleApiClient.disconnect(); } // [END on_start_on_stop] // [START on_save_instance_state] @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putBoolean(KEY_IS_RESOLVING, mIsResolving); outState.putBoolean(KEY_SHOULD_RESOLVE, mShouldResolve); } // [END on_save_instance_state] // [START on_activity_result] @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); Log.d(TAG, "onActivityResult:" + requestCode + ":" + resultCode + ":" + data); if (requestCode == RC_SIGN_IN) { // If the error resolution was not successful we should not resolve further. if (resultCode != RESULT_OK) { mShouldResolve = false; } mIsResolving = false; mGoogleApiClient.connect(); } } // [END on_activity_result] @Override public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) { Log.d(TAG, "onRequestPermissionsResult:" + requestCode); if (requestCode == RC_PERM_GET_ACCOUNTS) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { showSignedInUI(); } else { Log.d(TAG, "GET_ACCOUNTS Permission Denied."); } } } // [START on_connected] @Override public void onConnected(Bundle bundle) { // onConnected indicates that an account was selected on the device, that the selected // account has granted any requested permissions to our app and that we were able to // establish a service connection to Google Play services. Log.d(TAG, "onConnected:" + bundle); mShouldResolve = false; // Show the signed-in UI showSignedInUI(); } // [END on_connected] @Override public void onConnectionSuspended(int i) { // The connection to Google Play services was lost. The GoogleApiClient will automatically // attempt to re-connect. Any UI elements that depend on connection to Google APIs should // be hidden or disabled until onConnected is called again. Log.w(TAG, "onConnectionSuspended:" + i); } // [START on_connection_failed] @Override public void onConnectionFailed(ConnectionResult connectionResult) { // Could not connect to Google Play Services. The user needs to select an account, // grant permissions or resolve an error in order to sign in. Refer to the javadoc for // ConnectionResult to see possible error codes. Log.d(TAG, "onConnectionFailed:" + connectionResult); if (!mIsResolving && mShouldResolve) { if (connectionResult.hasResolution()) { try { connectionResult.startResolutionForResult(this, RC_SIGN_IN); mIsResolving = true; } catch (IntentSender.SendIntentException e) { Log.e(TAG, "Could not resolve ConnectionResult.", e); mIsResolving = false; mGoogleApiClient.connect(); } } else { // Could not resolve the connection result, show the user an // error dialog. showErrorDialog(connectionResult); } } else { // Show the signed-out UI showSignedOutUI(); } } // [END on_connection_failed] private void showErrorDialog(ConnectionResult connectionResult) { GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance(); int resultCode = apiAvailability.isGooglePlayServicesAvailable(this); if (resultCode != ConnectionResult.SUCCESS) { if (apiAvailability.isUserResolvableError(resultCode)) { apiAvailability .getErrorDialog(this, resultCode, RC_SIGN_IN, new DialogInterface.OnCancelListener() { @Override public void onCancel(DialogInterface dialog) { mShouldResolve = false; showSignedOutUI(); } }).show(); } else { Log.w(TAG, "Google Play Services Error:" + connectionResult); String errorString = apiAvailability.getErrorString(resultCode); Toast.makeText(this, errorString, Toast.LENGTH_SHORT).show(); mShouldResolve = false; showSignedOutUI(); } } } // [START on_click] @Override public void onClick(View v) { switch (v.getId()) { case R.id.sign_in_button: onSignInClicked(); break; case R.id.sign_out_button: onSignOutClicked(); break; case R.id.disconnect_button: onDisconnectClicked(); break; } } // [END on_click] // [START on_sign_in_clicked] private void onSignInClicked() { // User clicked the sign-in button, so begin the sign-in process and automatically // attempt to resolve any errors that occur. mShouldResolve = true; mGoogleApiClient.connect(); // Show a message to the user that we are signing in. mStatus.setText(""); } // [END on_sign_in_clicked] // [START on_sign_out_clicked] private void onSignOutClicked() { // Clear the default account so that GoogleApiClient will not automatically // connect in the future. if (mGoogleApiClient.isConnected()) { Plus.AccountApi.clearDefaultAccount(mGoogleApiClient); mGoogleApiClient.disconnect(); } showSignedOutUI(); } // [END on_sign_out_clicked] // [START on_disconnect_clicked] private void onDisconnectClicked() { // Revoke all granted permissions and clear the default account. The user will have // to pass the consent screen to sign in again. if (mGoogleApiClient.isConnected()) { Plus.AccountApi.clearDefaultAccount(mGoogleApiClient); Plus.AccountApi.revokeAccessAndDisconnect(mGoogleApiClient); mGoogleApiClient.disconnect(); } showSignedOutUI(); } // [END on_disconnect_clicked] }