| /* |
| * Copyright (C) 2015 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.example.android.wearable.runtimepermissions; |
| |
| import android.Manifest; |
| import android.app.Activity; |
| import android.content.Intent; |
| import android.content.pm.PackageManager; |
| import android.os.Environment; |
| import android.os.Looper; |
| import android.support.v4.app.ActivityCompat; |
| import android.support.v7.app.AppCompatActivity; |
| import android.os.Bundle; |
| import android.util.Log; |
| import android.view.View; |
| import android.widget.Button; |
| import android.widget.TextView; |
| |
| import com.example.android.wearable.runtimepermissions.common.Constants; |
| |
| import com.google.android.gms.common.ConnectionResult; |
| import com.google.android.gms.common.api.GoogleApiClient; |
| import com.google.android.gms.common.api.PendingResult; |
| import com.google.android.gms.common.api.ResultCallback; |
| import com.google.android.gms.wearable.CapabilityApi; |
| import com.google.android.gms.wearable.CapabilityInfo; |
| import com.google.android.gms.wearable.DataMap; |
| import com.google.android.gms.wearable.MessageApi; |
| import com.google.android.gms.wearable.MessageEvent; |
| import com.google.android.gms.wearable.Node; |
| import com.google.android.gms.wearable.Wearable; |
| |
| import java.io.File; |
| import java.util.Set; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Displays data that requires runtime permissions both locally (READ_EXTERNAL_STORAGE) and |
| * remotely on wear (BODY_SENSORS). |
| * |
| * The class also handles sending back the results of a permission request from a remote wear device |
| * when the permission has not been approved yet on the phone (uses EXTRA as trigger). In that case, |
| * the IncomingRequestPhoneService launches the splash Activity (PhonePermissionRequestActivity) to |
| * inform user of permission request. After the user decides what to do, it falls back to this |
| * Activity (which has all the GoogleApiClient code) to handle sending data across and keeps user |
| * in app experience. |
| */ |
| public class MainPhoneActivity extends AppCompatActivity implements |
| GoogleApiClient.ConnectionCallbacks, |
| GoogleApiClient.OnConnectionFailedListener, |
| CapabilityApi.CapabilityListener, |
| MessageApi.MessageListener, |
| ResultCallback<MessageApi.SendMessageResult> { |
| |
| private static final String TAG = "MainPhoneActivity"; |
| |
| /* |
| * Alerts Activity that the initial request for permissions came from wear, and the Activity |
| * needs to send back the results (data or permission rejection). |
| */ |
| public static final String EXTRA_PROMPT_PERMISSION_FROM_WEAR = |
| "com.example.android.wearable.runtimepermissions.extra.PROMPT_PERMISSION_FROM_WEAR"; |
| |
| private static final int REQUEST_WEAR_PERMISSION_RATIONALE = 1; |
| |
| private boolean mWearBodySensorsPermissionApproved; |
| private boolean mPhoneStoragePermissionApproved; |
| |
| private boolean mWearRequestingPhoneStoragePermission; |
| |
| private Button mWearBodySensorsPermissionButton; |
| private Button mPhoneStoragePermissionButton; |
| private TextView mOutputTextView; |
| |
| private Set<Node> mWearNodeIds; |
| |
| private GoogleApiClient mGoogleApiClient; |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| Log.d(TAG, "onCreate()"); |
| super.onCreate(savedInstanceState); |
| |
| /* |
| * Since this is a remote permission, we initialize it to false and then check the remote |
| * permission once the GoogleApiClient is connected. |
| */ |
| mWearBodySensorsPermissionApproved = false; |
| |
| setContentView(R.layout.activity_main); |
| |
| // Checks if wear app requested phone permission (permission request opens later if true). |
| mWearRequestingPhoneStoragePermission = |
| getIntent().getBooleanExtra(EXTRA_PROMPT_PERMISSION_FROM_WEAR, false); |
| |
| mPhoneStoragePermissionButton = |
| (Button) findViewById(R.id.phoneStoragePermissionButton); |
| |
| mWearBodySensorsPermissionButton = |
| (Button) findViewById(R.id.wearBodySensorsPermissionButton); |
| |
| mOutputTextView = (TextView) findViewById(R.id.output); |
| |
| mGoogleApiClient = new GoogleApiClient.Builder(this) |
| .addApi(Wearable.API) |
| .addConnectionCallbacks(this) |
| .addOnConnectionFailedListener(this) |
| .build(); |
| } |
| |
| public void onClickWearBodySensors(View view) { |
| |
| logToUi("Requested info from wear device(s). New approval may be required."); |
| |
| DataMap dataMap = new DataMap(); |
| dataMap.putInt(Constants.KEY_COMM_TYPE, Constants.COMM_TYPE_REQUEST_DATA); |
| sendMessage(dataMap); |
| } |
| |
| public void onClickPhoneStorage(View view) { |
| |
| if (mPhoneStoragePermissionApproved) { |
| logToUi(getPhoneStorageInformation()); |
| |
| } else { |
| // On 23+ (M+) devices, Storage permission not granted. Request permission. |
| Intent startIntent = new Intent(this, PhonePermissionRequestActivity.class); |
| startActivity(startIntent); |
| } |
| } |
| |
| @Override |
| protected void onPause() { |
| Log.d(TAG, "onPause()"); |
| super.onPause(); |
| if ((mGoogleApiClient != null) && (mGoogleApiClient.isConnected())) { |
| Wearable.CapabilityApi.removeCapabilityListener( |
| mGoogleApiClient, |
| this, |
| Constants.CAPABILITY_WEAR_APP); |
| Wearable.MessageApi.removeListener(mGoogleApiClient, this); |
| mGoogleApiClient.disconnect(); |
| } |
| } |
| |
| @Override |
| protected void onResume() { |
| Log.d(TAG, "onResume()"); |
| super.onResume(); |
| |
| /* Enables app to handle 23+ (M+) style permissions. It also covers user changing |
| * permission in settings and coming back to the app. |
| */ |
| mPhoneStoragePermissionApproved = |
| ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) |
| == PackageManager.PERMISSION_GRANTED; |
| |
| if (mPhoneStoragePermissionApproved) { |
| mPhoneStoragePermissionButton.setCompoundDrawablesWithIntrinsicBounds( |
| R.drawable.ic_permission_approved, 0, 0, 0); |
| } |
| |
| if (mGoogleApiClient != null) { |
| mGoogleApiClient.connect(); |
| } |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| Log.d(TAG, "onActivityResult()"); |
| if (requestCode == REQUEST_WEAR_PERMISSION_RATIONALE) { |
| |
| if (resultCode == Activity.RESULT_OK) { |
| logToUi("Requested permission on wear device(s)."); |
| |
| DataMap dataMap = new DataMap(); |
| dataMap.putInt(Constants.KEY_COMM_TYPE, |
| Constants.COMM_TYPE_REQUEST_PROMPT_PERMISSION); |
| sendMessage(dataMap); |
| } |
| } |
| } |
| |
| @Override |
| public void onConnected(Bundle bundle) { |
| Log.d(TAG, "onConnected()"); |
| |
| // Set up listeners for capability and message changes. |
| Wearable.CapabilityApi.addCapabilityListener( |
| mGoogleApiClient, |
| this, |
| Constants.CAPABILITY_WEAR_APP); |
| Wearable.MessageApi.addListener(mGoogleApiClient, this); |
| |
| // Initial check of capabilities to find the wear nodes. |
| PendingResult<CapabilityApi.GetCapabilityResult> pendingResult = |
| Wearable.CapabilityApi.getCapability( |
| mGoogleApiClient, |
| Constants.CAPABILITY_WEAR_APP, |
| CapabilityApi.FILTER_REACHABLE); |
| |
| pendingResult.setResultCallback(new ResultCallback<CapabilityApi.GetCapabilityResult>() { |
| @Override |
| public void onResult(CapabilityApi.GetCapabilityResult getCapabilityResult) { |
| |
| CapabilityInfo capabilityInfo = getCapabilityResult.getCapability(); |
| String capabilityName = capabilityInfo.getName(); |
| |
| boolean wearSupportsSampleApp = |
| capabilityName.equals(Constants.CAPABILITY_WEAR_APP); |
| |
| if (wearSupportsSampleApp) { |
| mWearNodeIds = capabilityInfo.getNodes(); |
| |
| /* |
| * Upon getting all wear nodes, we now need to check if the original request to |
| * launch this activity (and PhonePermissionRequestActivity) was initiated by |
| * a wear device. If it was, we need to send back the permission results (data |
| * or rejection of permission) to the wear device. |
| * |
| * Also, note we set variable to false, this enables the user to continue |
| * changing permissions without sending updates to the wear every time. |
| */ |
| if (mWearRequestingPhoneStoragePermission) { |
| mWearRequestingPhoneStoragePermission = false; |
| sendWearPermissionResults(); |
| } |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void onConnectionSuspended(int i) { |
| Log.d(TAG, "onConnectionSuspended(): connection to location client suspended"); |
| } |
| |
| @Override |
| public void onConnectionFailed(ConnectionResult connectionResult) { |
| Log.e(TAG, "onConnectionFailed(): connection to location client failed"); |
| } |
| |
| |
| public void onCapabilityChanged(CapabilityInfo capabilityInfo) { |
| Log.d(TAG, "onCapabilityChanged(): " + capabilityInfo); |
| |
| mWearNodeIds = capabilityInfo.getNodes(); |
| } |
| |
| public void onMessageReceived(MessageEvent messageEvent) { |
| Log.d(TAG, "onMessageReceived(): " + messageEvent); |
| |
| String messagePath = messageEvent.getPath(); |
| |
| if (messagePath.equals(Constants.MESSAGE_PATH_PHONE)) { |
| DataMap dataMap = DataMap.fromByteArray(messageEvent.getData()); |
| |
| int commType = dataMap.getInt(Constants.KEY_COMM_TYPE, 0); |
| |
| if (commType == Constants.COMM_TYPE_RESPONSE_PERMISSION_REQUIRED) { |
| mWearBodySensorsPermissionApproved = false; |
| updateWearButtonOnUiThread(); |
| |
| /* Because our request for remote data requires a remote permission, we now launch |
| * a splash activity informing the user we need those permissions (along with |
| * other helpful information to approve). |
| */ |
| Intent wearPermissionRationale = |
| new Intent(this, WearPermissionRequestActivity.class); |
| startActivityForResult(wearPermissionRationale, REQUEST_WEAR_PERMISSION_RATIONALE); |
| |
| } else if (commType == Constants.COMM_TYPE_RESPONSE_USER_APPROVED_PERMISSION) { |
| mWearBodySensorsPermissionApproved = true; |
| updateWearButtonOnUiThread(); |
| logToUi("User approved permission on remote device, requesting data again."); |
| DataMap outgoingDataRequestDataMap = new DataMap(); |
| outgoingDataRequestDataMap.putInt(Constants.KEY_COMM_TYPE, |
| Constants.COMM_TYPE_REQUEST_DATA); |
| sendMessage(outgoingDataRequestDataMap); |
| |
| } else if (commType == Constants.COMM_TYPE_RESPONSE_USER_DENIED_PERMISSION) { |
| mWearBodySensorsPermissionApproved = false; |
| updateWearButtonOnUiThread(); |
| logToUi("User denied permission on remote device."); |
| |
| } else if (commType == Constants.COMM_TYPE_RESPONSE_DATA) { |
| mWearBodySensorsPermissionApproved = true; |
| String storageDetails = dataMap.getString(Constants.KEY_PAYLOAD); |
| updateWearButtonOnUiThread(); |
| logToUi(storageDetails); |
| |
| } else { |
| Log.d(TAG, "Unrecognized communication type received."); |
| } |
| } |
| } |
| |
| @Override |
| public void onResult(MessageApi.SendMessageResult sendMessageResult) { |
| if (!sendMessageResult.getStatus().isSuccess()) { |
| Log.d(TAG, "Sending message failed, onResult: " + sendMessageResult); |
| updateWearButtonOnUiThread(); |
| logToUi("Sending message failed."); |
| |
| } else { |
| Log.d(TAG, "Message sent."); |
| } |
| } |
| |
| private void sendMessage(DataMap dataMap) { |
| Log.d(TAG, "sendMessage(): " + mWearNodeIds); |
| |
| if ((mWearNodeIds != null) && (!mWearNodeIds.isEmpty())) { |
| |
| PendingResult<MessageApi.SendMessageResult> pendingResult; |
| |
| for (Node node : mWearNodeIds) { |
| |
| pendingResult = Wearable.MessageApi.sendMessage( |
| mGoogleApiClient, |
| node.getId(), |
| Constants.MESSAGE_PATH_WEAR, |
| dataMap.toByteArray()); |
| |
| pendingResult.setResultCallback(this, Constants.CONNECTION_TIME_OUT_MS, |
| TimeUnit.SECONDS); |
| } |
| } else { |
| // Unable to retrieve node with proper capability |
| mWearBodySensorsPermissionApproved = false; |
| updateWearButtonOnUiThread(); |
| logToUi("Wear devices not available to send message."); |
| } |
| } |
| |
| private void updateWearButtonOnUiThread() { |
| runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| if (mWearBodySensorsPermissionApproved) { |
| mWearBodySensorsPermissionButton.setCompoundDrawablesWithIntrinsicBounds( |
| R.drawable.ic_permission_approved, 0, 0, 0); |
| } else { |
| mWearBodySensorsPermissionButton.setCompoundDrawablesWithIntrinsicBounds( |
| R.drawable.ic_permission_denied, 0, 0, 0); |
| } |
| } |
| }); |
| } |
| |
| /* |
| * Handles all messages for the UI coming on and off the main thread. Not all callbacks happen |
| * on the main thread. |
| */ |
| private void logToUi(final String message) { |
| |
| boolean mainUiThread = (Looper.myLooper() == Looper.getMainLooper()); |
| |
| if (mainUiThread) { |
| |
| if (!message.isEmpty()) { |
| Log.d(TAG, message); |
| mOutputTextView.setText(message); |
| } |
| |
| } else { |
| if (!message.isEmpty()) { |
| |
| runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| |
| Log.d(TAG, message); |
| mOutputTextView.setText(message); |
| } |
| }); |
| } |
| } |
| } |
| |
| private String getPhoneStorageInformation() { |
| |
| StringBuilder stringBuilder = new StringBuilder(); |
| |
| String state = Environment.getExternalStorageState(); |
| boolean isExternalStorageReadable = Environment.MEDIA_MOUNTED.equals(state) |
| || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state); |
| |
| if (isExternalStorageReadable) { |
| File externalStorageDirectory = Environment.getExternalStorageDirectory(); |
| String[] fileList = externalStorageDirectory.list(); |
| |
| if (fileList.length > 0) { |
| |
| stringBuilder.append("List of files\n"); |
| for (String file : fileList) { |
| stringBuilder.append(" - " + file + "\n"); |
| } |
| |
| } else { |
| stringBuilder.append("No files in external storage."); |
| } |
| |
| } else { |
| stringBuilder.append("No external media is available."); |
| } |
| |
| return stringBuilder.toString(); |
| } |
| |
| private void sendWearPermissionResults() { |
| |
| Log.d(TAG, "sendWearPermissionResults()"); |
| |
| DataMap dataMap = new DataMap(); |
| |
| if (mPhoneStoragePermissionApproved) { |
| dataMap.putInt(Constants.KEY_COMM_TYPE, |
| Constants.COMM_TYPE_RESPONSE_USER_APPROVED_PERMISSION); |
| } else { |
| dataMap.putInt(Constants.KEY_COMM_TYPE, |
| Constants.COMM_TYPE_RESPONSE_USER_DENIED_PERMISSION); |
| } |
| sendMessage(dataMap); |
| } |
| } |
