Editor

MainPhoneActivity.java

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