/*
* 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);
}
}