| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * 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.example.android.wearable.agendadata; |
| |
| import static com.example.android.wearable.agendadata.Constants.TAG; |
| |
| import android.Manifest; |
| import android.content.Intent; |
| import android.content.IntentSender; |
| import android.content.pm.PackageManager; |
| import android.net.Uri; |
| import android.os.Bundle; |
| 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.util.Log; |
| import android.view.View; |
| import android.widget.ScrollView; |
| import android.widget.TextView; |
| |
| import com.google.android.gms.common.ConnectionResult; |
| import com.google.android.gms.common.api.GoogleApiClient; |
| import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks; |
| import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener; |
| import com.google.android.gms.common.api.ResultCallback; |
| import com.google.android.gms.wearable.DataApi; |
| import com.google.android.gms.wearable.DataItem; |
| import com.google.android.gms.wearable.DataItemBuffer; |
| import com.google.android.gms.wearable.Wearable; |
| |
| /** |
| * Syncs or deletes calendar events (event time, description, and background image) to your |
| * Wearable via the Wearable DataApi at the click of a button. Includes code to handle dynamic M+ |
| * permissions as well. |
| */ |
| public class MainActivity extends AppCompatActivity implements |
| ConnectionCallbacks, |
| OnConnectionFailedListener, |
| ActivityCompat.OnRequestPermissionsResultCallback { |
| |
| /* Request code for launching the Intent to resolve Google Play services errors. */ |
| private static final int REQUEST_RESOLVE_ERROR = 1000; |
| |
| /* Id to identify calendar and contact permissions request. */ |
| private static final int REQUEST_CALENDAR_AND_CONTACTS = 0; |
| |
| |
| private GoogleApiClient mGoogleApiClient; |
| private boolean mResolvingError = false; |
| |
| private View mLayout; |
| |
| private TextView mLogTextView; |
| private ScrollView mScroller; |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| |
| setContentView(R.layout.main); |
| mLayout = findViewById(R.id.main_layout); |
| |
| mLogTextView = (TextView) findViewById(R.id.log); |
| mScroller = (ScrollView) findViewById(R.id.scroller); |
| |
| mGoogleApiClient = new GoogleApiClient.Builder(this) |
| .addApi(Wearable.API) |
| .addConnectionCallbacks(this) |
| .addOnConnectionFailedListener(this) |
| .build(); |
| } |
| |
| @Override |
| protected void onStart() { |
| super.onStart(); |
| if (!mResolvingError) { |
| mGoogleApiClient.connect(); |
| } |
| } |
| |
| @Override |
| protected void onStop() { |
| if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) { |
| mGoogleApiClient.disconnect(); |
| } |
| |
| super.onStop(); |
| } |
| |
| public void onGetEventsClicked(View view) { |
| |
| Log.i(TAG, "onGetEventsClicked(): Checking permission."); |
| |
| // BEGIN_INCLUDE(calendar_and_contact_permissions) |
| // Check if the Calendar permission is already available. |
| boolean calendarApproved = |
| ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_CALENDAR) |
| == PackageManager.PERMISSION_GRANTED; |
| |
| boolean contactsApproved = |
| ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) |
| == PackageManager.PERMISSION_GRANTED; |
| |
| if (!calendarApproved || !contactsApproved) { |
| // Calendar and/or Contact permissions have not been granted. |
| requestCalendarAndContactPermissions(); |
| |
| } else { |
| // Calendar permissions is already available, start service |
| Log.i(TAG, "Permissions already granted. Starting service."); |
| pushCalendarToWear(); |
| } |
| // END_INCLUDE(calendar_and_contact_permissions) |
| |
| } |
| |
| /* |
| * Requests Calendar and Contact permissions. |
| * If the permission has been denied previously, a SnackBar will prompt the user to grant the |
| * permission, otherwise it is requested directly. |
| */ |
| private void requestCalendarAndContactPermissions() { |
| Log.i(TAG, "CALENDAR permission has NOT been granted. Requesting permission."); |
| |
| // BEGIN_INCLUDE(calendar_and_contact_permissions_request) |
| |
| boolean showCalendarPermissionRationale = |
| ActivityCompat.shouldShowRequestPermissionRationale(this, |
| Manifest.permission.READ_CALENDAR); |
| boolean showContactsPermissionRationale = |
| ActivityCompat.shouldShowRequestPermissionRationale(this, |
| Manifest.permission.READ_CONTACTS); |
| |
| if (showCalendarPermissionRationale || showContactsPermissionRationale) { |
| /* |
| * Provide an additional rationale to the user if the permission was not granted and |
| * the user would benefit from additional context for the use of the permission. For |
| * example, if the user has previously denied the permission. |
| */ |
| Log.i(TAG, "Display calendar & contact permissions rationale for additional context."); |
| |
| Snackbar.make(mLayout, R.string.permissions_rationale, |
| Snackbar.LENGTH_INDEFINITE) |
| .setAction(R.string.ok, new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| ActivityCompat.requestPermissions(MainActivity.this, |
| new String[] { |
| Manifest.permission.READ_CALENDAR, |
| Manifest.permission.READ_CONTACTS}, |
| REQUEST_CALENDAR_AND_CONTACTS); |
| } |
| }) |
| .show(); |
| |
| |
| } else { |
| |
| // Calendar/Contact permissions have not been granted yet. Request it directly. |
| ActivityCompat.requestPermissions( |
| this, |
| new String[]{ |
| Manifest.permission.READ_CALENDAR, |
| Manifest.permission.READ_CONTACTS |
| }, |
| REQUEST_CALENDAR_AND_CONTACTS); |
| } |
| // END_INCLUDE(calendar_and_contact_permissions_request) |
| } |
| |
| private void pushCalendarToWear() { |
| startService(new Intent(this, CalendarQueryService.class)); |
| } |
| |
| public void onDeleteEventsClicked(View view) { |
| if (mGoogleApiClient.isConnected()) { |
| Wearable.DataApi.getDataItems(mGoogleApiClient) |
| .setResultCallback(new ResultCallback<DataItemBuffer>() { |
| @Override |
| public void onResult(DataItemBuffer result) { |
| try { |
| if (result.getStatus().isSuccess()) { |
| deleteDataItems(result); |
| } else { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onDeleteEventsClicked(): failed to get Data " |
| + "Items"); |
| } |
| } |
| } finally { |
| result.release(); |
| } |
| } |
| }); |
| } else { |
| Log.e(TAG, "Failed to delete data items" |
| + " - Client disconnected from Google Play Services"); |
| } |
| } |
| |
| private void deleteDataItems(final DataItemBuffer dataItemList) { |
| if (mGoogleApiClient.isConnected()) { |
| for (final DataItem dataItem : dataItemList) { |
| final Uri dataItemUri = dataItem.getUri(); |
| /* |
| * In a real calendar application, this might delete the corresponding calendar |
| * events from the calendar data provider. However, we simply delete the DataItem, |
| * but leave the phone's calendar data intact for this simple sample. |
| */ |
| Wearable.DataApi.deleteDataItems(mGoogleApiClient, dataItemUri) |
| .setResultCallback(new ResultCallback<DataApi.DeleteDataItemsResult>() { |
| @Override |
| public void onResult(DataApi.DeleteDataItemsResult deleteResult) { |
| if (deleteResult.getStatus().isSuccess()) { |
| appendLog("Successfully deleted data item: " + dataItemUri); |
| } else { |
| appendLog("Failed to delete data item:" + dataItemUri); |
| } |
| } |
| }); |
| } |
| } else { |
| Log.e(TAG, "Failed to delete data items" |
| + " - Client disconnected from Google Play Services"); |
| } |
| } |
| |
| @Override |
| public void onConnected(Bundle connectionHint) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Connected to Google Api Service."); |
| } |
| mResolvingError = false; |
| } |
| |
| @Override |
| public void onConnectionSuspended(int cause) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onConnectionSuspended(): Cause id: " + cause); |
| } |
| } |
| |
| @Override |
| public void onConnectionFailed(ConnectionResult result) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Disconnected from Google Api Service"); |
| } |
| |
| if (mResolvingError) { |
| // Already attempting to resolve an error. |
| return; |
| } else if (result.hasResolution()) { |
| try { |
| mResolvingError = true; |
| result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR); |
| } catch (IntentSender.SendIntentException e) { |
| // There was an error with the resolution intent. Try again. |
| mResolvingError = false; |
| mGoogleApiClient.connect(); |
| } |
| } else { |
| mResolvingError = false; |
| } |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| super.onActivityResult(requestCode, resultCode, data); |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onActivityResult request/result codes: " + requestCode + "/" + resultCode); |
| } |
| |
| if (requestCode == REQUEST_RESOLVE_ERROR) { |
| mResolvingError = false; |
| if (resultCode == RESULT_OK) { |
| // Make sure the app is not already connected or attempting to connect |
| if (!mGoogleApiClient.isConnecting() && !mGoogleApiClient.isConnected()) { |
| mGoogleApiClient.connect(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Callback received when a permissions request has been completed. |
| */ |
| @Override |
| public void onRequestPermissionsResult( |
| int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { |
| |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "onRequestPermissionsResult(): " + permissions); |
| } |
| |
| if (requestCode == REQUEST_CALENDAR_AND_CONTACTS) { |
| // BEGIN_INCLUDE(permissions_result) |
| // Received permission result for calendar permission. |
| Log.i(TAG, "Received response for Calendar permission request."); |
| |
| // Check if all required permissions have been granted. |
| if ((grantResults.length == 2) |
| && (grantResults[0] == PackageManager.PERMISSION_GRANTED) |
| && (grantResults[1] == PackageManager.PERMISSION_GRANTED)) { |
| // Calendar/Contact permissions have been granted, pull all calendar events |
| Log.i(TAG, "All permission has now been granted. Showing preview."); |
| Snackbar.make(mLayout, R.string.permisions_granted, Snackbar.LENGTH_SHORT).show(); |
| |
| pushCalendarToWear(); |
| |
| } else { |
| Log.i(TAG, "CALENDAR and/or CONTACT permissions were NOT granted."); |
| Snackbar.make(mLayout, R.string.permissions_denied, Snackbar.LENGTH_SHORT).show(); |
| } |
| // END_INCLUDE(permissions_result) |
| |
| } else { |
| super.onRequestPermissionsResult(requestCode, permissions, grantResults); |
| } |
| } |
| |
| private void appendLog(final String s) { |
| mLogTextView.post(new Runnable() { |
| @Override |
| public void run() { |
| mLogTextView.append(s); |
| mLogTextView.append("\n"); |
| mScroller.fullScroll(View.FOCUS_DOWN); |
| } |
| }); |
| } |
| } |
