Build initial Permissions Settings UI page for Wear

This is a first pass to build a functional settings UI page
for Permissions on Android Wear.  The user flow is a little
different than the phone version, so there are some nuances
that need to be adjusted from the normal flow.

I have forked off of the AppPermissionsFragment and created
a Wear version for us to use.  Rather than try to link
the Wearable-Support lib into AOSP code, I have made a
duplicate of the few files I needed.

This change adds a Wear layout version of the Settings UI
page.  The UI is fully functional for most cases, but there
are some tweaks still needed for full parity.  The tweaks
are primarily around UI and special edge case functions.

BUG: 23080561
Change-Id: I8477f6b966cacaae9e77aa0fb61b4b1e621a9ead

6 files changed, 599 insertions, 3 deletions

diff --git a/src/android/support/wearable/view/CircledImageView.java b/src/android/support/wearable/view/CircledImageView.java
index 132f6b5c..71b68a1d 100644
--- a/src/android/support/wearable/view/CircledImageView.java
+++ b/src/android/support/wearable/view/CircledImageView.java
@@ -33,11 +33,11 @@ import android.graphics.RectF;
 import android.graphics.Shader;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
-import android.support.wearable.R;
 import android.util.AttributeSet;
 import android.view.View;
 
 import java.util.Objects;
+import com.android.packageinstaller.R;
 
 /**
  * An image view surrounded by a circle.
diff --git a/src/com/android/packageinstaller/permission/ui/ManagePermissionsActivity.java b/src/com/android/packageinstaller/permission/ui/ManagePermissionsActivity.java
index 8ba6b127..a61a862d 100644
--- a/src/com/android/packageinstaller/permission/ui/ManagePermissionsActivity.java
+++ b/src/com/android/packageinstaller/permission/ui/ManagePermissionsActivity.java
@@ -21,6 +21,9 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.util.Log;
 
+import com.android.packageinstaller.permission.ui.wear.AppPermissionsFragmentWear;
+import com.android.packageinstaller.DeviceUtils;
+
 public final class ManagePermissionsActivity extends OverlayTouchActivity {
     private static final String LOG_TAG = "ManagePermissionsActivity";
 
@@ -47,7 +50,12 @@ public final class ManagePermissionsActivity extends OverlayTouchActivity {
                     finish();
                     return;
                 }
-                fragment = AppPermissionsFragment.newInstance(packageName);
+
+                if (DeviceUtils.isWatch(this)) {
+                    fragment = AppPermissionsFragmentWear.newInstance(packageName);
+                } else {
+                    fragment = AppPermissionsFragment.newInstance(packageName);
+                }
             } break;
 
             case Intent.ACTION_MANAGE_PERMISSION_APPS: {
diff --git a/src/com/android/packageinstaller/permission/ui/wear/AppPermissionsFragmentWear.java b/src/com/android/packageinstaller/permission/ui/wear/AppPermissionsFragmentWear.java
new file mode 100644
index 00000000..9e54c7d5
--- /dev/null
+++ b/src/com/android/packageinstaller/permission/ui/wear/AppPermissionsFragmentWear.java
@@ -0,0 +1,262 @@
+/*
+* Copyright (C) 2015 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.android.packageinstaller.permission.ui.wear;
+
+import android.annotation.Nullable;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Fragment;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.support.wearable.view.WearableListView;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Toast;
+
+import com.android.packageinstaller.R;
+import com.android.packageinstaller.permission.model.AppPermissionGroup;
+import com.android.packageinstaller.permission.model.AppPermissions;
+import com.android.packageinstaller.permission.ui.OverlayTouchActivity;
+import com.android.packageinstaller.permission.ui.wear.settings.PermissionsSettingsAdapter;
+import com.android.packageinstaller.permission.ui.wear.settings.SettingsAdapter;
+import com.android.packageinstaller.permission.utils.LocationUtils;
+import com.android.packageinstaller.permission.utils.SafetyNetLogger;
+import com.android.packageinstaller.permission.utils.Utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class AppPermissionsFragmentWear extends TitledSettingsFragment {
+
+    private static final String LOG_TAG = "ManagePermsFragment";
+
+    private List<AppPermissionGroup> mToggledGroups;
+    private AppPermissions mAppPermissions;
+    private PermissionsSettingsAdapter mAdapter;
+
+    private boolean mHasConfirmedRevoke;
+
+    public static AppPermissionsFragmentWear newInstance(String packageName) {
+        return setPackageName(new AppPermissionsFragmentWear(), packageName);
+    }
+
+    private static <T extends Fragment> T setPackageName(T fragment, String packageName) {
+        Bundle arguments = new Bundle();
+        arguments.putString(Intent.EXTRA_PACKAGE_NAME, packageName);
+        fragment.setArguments(arguments);
+        return fragment;
+
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        String packageName = getArguments().getString(Intent.EXTRA_PACKAGE_NAME);
+        Activity activity = getActivity();
+        PackageManager pm = activity.getPackageManager();
+        PackageInfo packageInfo;
+
+        try {
+            packageInfo = pm.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.i(LOG_TAG, "No package:" + activity.getCallingPackage(), e);
+            packageInfo = null;
+        }
+
+        if (packageInfo == null) {
+            Toast.makeText(activity, R.string.app_not_found_dlg_title, Toast.LENGTH_LONG).show();
+            activity.finish();
+            return;
+        }
+
+        mAppPermissions = new AppPermissions(activity, packageInfo, null, true, new Runnable() {
+            @Override
+            public void run() {
+                getActivity().finish();
+            }
+        });
+
+        mAdapter = new PermissionsSettingsAdapter(getContext());
+
+        initializePermissionGroupList();
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.settings, container, false);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mAppPermissions.refresh();
+
+        // Also refresh the UI
+        final int count = mAdapter.getItemCount();
+        for (int i = 0; i < count; ++i) {
+            updatePermissionGroupSetting(i);
+        }
+    }
+
+    @Override
+    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        if (mAppPermissions != null) {
+            initializeLayout(mAdapter);
+            bindUi(mAppPermissions.getPackageInfo());
+        }
+    }
+
+    private void bindUi(PackageInfo packageInfo) {
+        Activity activity = getActivity();
+        PackageManager pm = activity.getPackageManager();
+        ApplicationInfo appInfo = packageInfo.applicationInfo;
+        CharSequence label = appInfo.loadLabel(pm);
+        mHeader.setText(label);
+    }
+
+    private void initializePermissionGroupList() {
+        final String packageName = mAppPermissions.getPackageInfo().packageName;
+        List<AppPermissionGroup> groups = mAppPermissions.getPermissionGroups();
+        final int count = groups.size();
+        for (int i = 0; i < count; ++i) {
+            final AppPermissionGroup group = groups.get(i);
+            if (!Utils.shouldShowPermission(group, packageName)) {
+                continue;
+            }
+
+            SettingsAdapter.Setting<AppPermissionGroup> setting =
+                    new SettingsAdapter.Setting<AppPermissionGroup>(
+                            group.getLabel(),
+                            getPermissionGroupIcon(group),
+                            i);
+            setting.data = group;
+            mAdapter.addSetting(setting);
+        }
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        logToggledGroups();
+    }
+
+    @Override
+    public void onClick(WearableListView.ViewHolder view) {
+        final int index = view.getPosition();
+        SettingsAdapter.Setting<AppPermissionGroup> setting = mAdapter.get(index);
+        final AppPermissionGroup group = setting.data;
+
+        if (group == null) {
+            Log.e(LOG_TAG, "Error: AppPermissionGroup is null");
+            return;
+        }
+
+        // The way WearableListView is designed, there is no way to avoid this click handler
+        // Since the policy is fixed, ignore the click as the user is not able to change the state
+        // of this permission group
+        if (group.isPolicyFixed()) {
+            return;
+        }
+
+        OverlayTouchActivity activity = (OverlayTouchActivity) getActivity();
+        if (activity.isObscuredTouch()) {
+            activity.showOverlayDialog();
+            return;
+        }
+
+        addToggledGroup(group);
+
+        if (LocationUtils.isLocationGroupAndProvider(group.getName(), group.getApp().packageName)) {
+            LocationUtils.showLocationDialog(getContext(), mAppPermissions.getAppLabel());
+            return;
+        }
+
+        if (!group.areRuntimePermissionsGranted()) {
+            group.grantRuntimePermissions(false);
+        } else {
+            final boolean grantedByDefault = group.hasGrantedByDefaultPermission();
+            if (grantedByDefault || (!group.hasRuntimePermission() && !mHasConfirmedRevoke)) {
+                new AlertDialog.Builder(getContext())
+                        .setMessage(grantedByDefault ? R.string.system_warning
+                                : R.string.old_sdk_deny_warning)
+                        .setNegativeButton(R.string.cancel, null)
+                        .setPositiveButton(R.string.grant_dialog_button_deny,
+                                new OnClickListener() {
+                            @Override
+                            public void onClick(DialogInterface dialog, int which) {
+                                group.revokeRuntimePermissions(false);
+                                if (!grantedByDefault) {
+                                    mHasConfirmedRevoke = true;
+                                }
+
+                                updatePermissionGroupSetting(index);
+                            }
+                        })
+                        .show();
+            } else {
+                group.revokeRuntimePermissions(false);
+            }
+        }
+
+        updatePermissionGroupSetting(index);
+    }
+
+    private void updatePermissionGroupSetting(int index) {
+        SettingsAdapter.Setting<AppPermissionGroup> setting = mAdapter.get(index);
+        AppPermissionGroup group = setting.data;
+        mAdapter.updateSetting(
+                index,
+                group.getLabel(),
+                getPermissionGroupIcon(group),
+                group);
+    }
+
+    private void addToggledGroup(AppPermissionGroup group) {
+        if (mToggledGroups == null) {
+            mToggledGroups = new ArrayList<>();
+        }
+        // Double toggle is back to initial state.
+        if (mToggledGroups.contains(group)) {
+            mToggledGroups.remove(group);
+        } else {
+            mToggledGroups.add(group);
+        }
+    }
+
+    private void logToggledGroups() {
+        if (mToggledGroups != null) {
+            String packageName = mAppPermissions.getPackageInfo().packageName;
+            SafetyNetLogger.logPermissionsToggled(packageName, mToggledGroups);
+            mToggledGroups = null;
+        }
+    }
+
+    private int getPermissionGroupIcon(AppPermissionGroup group) {
+        // TODO: Return the correct icon based on if permissions are granted
+        return group.getIconResId();
+    }
+}
diff --git a/src/com/android/packageinstaller/permission/ui/wear/TitledSettingsFragment.java b/src/com/android/packageinstaller/permission/ui/wear/TitledSettingsFragment.java
new file mode 100644
index 00000000..a738decd
--- /dev/null
+++ b/src/com/android/packageinstaller/permission/ui/wear/TitledSettingsFragment.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2015 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.android.packageinstaller.permission.ui.wear;
+
+import android.app.Fragment;
+import android.content.Context;
+import android.os.Bundle;
+import android.support.v7.widget.RecyclerView;
+import android.support.wearable.view.WearableListView;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowInsets;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import com.android.packageinstaller.permission.ui.wear.settings.ViewUtils;
+import com.android.packageinstaller.R;
+
+/**
+ * Base settings Fragment that shows a title at the top of the page.
+ */
+public abstract class TitledSettingsFragment extends Fragment implements
+        View.OnLayoutChangeListener, WearableListView.ClickListener {
+
+    private static final int ITEM_CHANGE_DURATION_MS = 120;
+
+    private static final String TAG = "TitledSettingsFragment";
+    private int mInitialHeaderHeight;
+
+    protected TextView mHeader;
+    protected WearableListView mWheel;
+
+    private static boolean sInitialized;
+    private static int sCharLimitShortTitle;
+    private static int sCharLimitLine;
+    private static int mChinOffset;
+
+    private TextWatcher mHeaderTextWatcher = new TextWatcher() {
+        @Override
+        public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+        @Override
+        public void onTextChanged(CharSequence s, int start, int before, int count) {}
+
+        @Override
+        public void afterTextChanged(Editable editable) {
+            adjustHeaderSize();
+        }
+
+    };
+
+    private void adjustHeaderTranslation() {
+        int translation = 0;
+        if (mWheel.getChildCount() > 0) {
+            translation = mWheel.getCentralViewTop() - mWheel.getChildAt(0).getTop();
+        }
+
+        float newTranslation = Math.min(Math.max(-mInitialHeaderHeight, -translation), 0);
+
+        int position = mWheel.getChildAdapterPosition(mWheel.getChildAt(0));
+        if (position == 0 || newTranslation < 0) {
+            mHeader.setTranslationY(newTranslation);
+        }
+    }
+
+    @Override
+    public void onTopEmptyRegionClick() {
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (!sInitialized) {
+            sCharLimitShortTitle = getResources().getInteger(R.integer.short_title_length);
+            sCharLimitLine = getResources().getInteger(R.integer.char_limit_per_line);
+            sInitialized = true;
+        }
+    }
+
+    @Override
+    public void onLayoutChange(View view, int left, int top, int right, int bottom, int oldLeft,
+                               int oldTop, int oldRight, int oldBottom) {
+        if (view == mHeader) {
+            mInitialHeaderHeight = bottom - top;
+            if (ViewUtils.getIsCircular(getContext())) {
+                // We are adding more margin on circular screens, so we need to account for it and use
+                // it for hiding the header.
+                mInitialHeaderHeight +=
+                        ((ViewGroup.MarginLayoutParams) view.getLayoutParams()).topMargin;
+            }
+        } else if (view == mWheel) {
+            adjustHeaderTranslation();
+        }
+    }
+
+    protected void initializeLayout(RecyclerView.Adapter adapter) {
+        View v = getView();
+        mWheel = (WearableListView) v.findViewById(R.id.wheel);
+
+        mHeader = (TextView) v.findViewById(R.id.header);
+        mHeader.addOnLayoutChangeListener(this);
+        mHeader.addTextChangedListener(mHeaderTextWatcher);
+
+        mWheel.setAdapter(adapter);
+        mWheel.addOnScrollListener(new RecyclerView.OnScrollListener() {
+            @Override
+            public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
+            }
+
+            @Override
+            public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
+                adjustHeaderTranslation();
+            }
+        });
+        mWheel.setClickListener(this);
+        mWheel.addOnLayoutChangeListener(this);
+
+        // Decrease item change animation duration to approximately half of the default duration.
+        RecyclerView.ItemAnimator itemAnimator = mWheel.getItemAnimator();
+        itemAnimator.setChangeDuration(ITEM_CHANGE_DURATION_MS);
+
+        adjustHeaderSize();
+
+        positionOnCircular(getContext(), mHeader, mWheel);
+    }
+
+    public static void positionOnCircular(Context context, View header, final ViewGroup wheel) {
+        if (ViewUtils.getIsCircular(context)) {
+            FrameLayout.LayoutParams params =
+                    (FrameLayout.LayoutParams) header.getLayoutParams();
+            params.topMargin = (int) context.getResources().getDimension(
+                    R.dimen.settings_header_top_margin_circular);
+            // Note that the margins are made symmetrical here. Since they're symmetrical we choose
+            // the smaller value to maximize usable width.
+            final int margin = (int) Math.min(context.getResources().getDimension(
+                    R.dimen.round_content_padding_left), context.getResources().getDimension(
+                    R.dimen.round_content_padding_right));
+            params.leftMargin = margin;
+            params.rightMargin = margin;
+            params.gravity = Gravity.CENTER_HORIZONTAL;
+            header.setLayoutParams(params);
+
+            if (header instanceof TextView) {
+                ((TextView) header).setGravity(Gravity.CENTER);
+            }
+
+            final int leftPadding = (int) context.getResources().getDimension(
+                    R.dimen.round_content_padding_left);
+            final int rightPadding = (int) context.getResources().getDimension(
+                    R.dimen.round_content_padding_right);
+            final int topPadding = (int) context.getResources().getDimension(
+                    R.dimen.settings_wearable_list_view_vertical_padding_round);
+            final int bottomPadding = (int) context.getResources().getDimension(
+                    R.dimen.settings_wearable_list_view_vertical_padding_round);
+            wheel.setPadding(leftPadding, topPadding, rightPadding, mChinOffset + bottomPadding);
+            wheel.setClipToPadding(false);
+
+            wheel.setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener() {
+                @Override
+                public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {
+                    mChinOffset = insets.getSystemWindowInsetBottom();
+                    wheel.setPadding(leftPadding, topPadding, rightPadding,
+                            mChinOffset + bottomPadding);
+                    // This listener is invoked after each time we navigate to SettingsActivity and
+                    // it keeps adding padding. We need to disable it after the first update.
+                    v.setOnApplyWindowInsetsListener(null);
+                    return insets.consumeSystemWindowInsets();
+                }
+            });
+        } else {
+            int leftPadding = (int) context.getResources().getDimension(
+                    R.dimen.content_padding_left);
+            wheel.setPadding(leftPadding, wheel.getPaddingTop(), wheel.getPaddingRight(),
+                    wheel.getPaddingBottom());
+        }
+    }
+
+    private void adjustHeaderSize() {
+        int length = mHeader.length();
+
+        if (length <= sCharLimitShortTitle) {
+            mHeader.setTextSize(TypedValue.COMPLEX_UNIT_PX,
+                    getResources().getDimensionPixelSize(
+                            R.dimen.setting_short_header_text_size));
+        } else {
+            mHeader.setTextSize(TypedValue.COMPLEX_UNIT_PX,
+                    getResources().getDimensionPixelSize(
+                            R.dimen.setting_long_header_text_size));
+        }
+
+        boolean singleLine = length <= sCharLimitLine;
+
+        float height = getResources().getDimension(R.dimen.settings_header_base_height);
+        if (!singleLine) {
+            height += getResources().getDimension(R.dimen.setting_header_extra_line_height);
+        }
+
+        FrameLayout.LayoutParams params = (FrameLayout.LayoutParams) mHeader.getLayoutParams();
+        params.height = (int) height;
+        final Context context = getContext();
+        if (!singleLine) {
+            // Make the top margin a little bit smaller so there is more space for the title.
+            if (ViewUtils.getIsCircular(context)) {
+                params.topMargin = getResources().getDimensionPixelSize(
+                        R.dimen.settings_header_top_margin_circular_multiline);
+            } else {
+                params.topMargin = getResources().getDimensionPixelSize(
+                        R.dimen.settings_header_top_margin_multiline);
+            }
+        } else {
+            if (ViewUtils.getIsCircular(context)) {
+                params.topMargin = getResources().getDimensionPixelSize(
+                        R.dimen.settings_header_top_margin_circular);
+            } else {
+                params.topMargin = getResources().getDimensionPixelSize(
+                        R.dimen.settings_header_top_margin);
+            }
+        }
+        mHeader.setLayoutParams(params);
+    }
+
+
+}
diff --git a/src/com/android/packageinstaller/permission/ui/wear/settings/PermissionsSettingsAdapter.java b/src/com/android/packageinstaller/permission/ui/wear/settings/PermissionsSettingsAdapter.java
new file mode 100644
index 00000000..1e6a3795
--- /dev/null
+++ b/src/com/android/packageinstaller/permission/ui/wear/settings/PermissionsSettingsAdapter.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2015 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.android.packageinstaller.permission.ui.wear.settings;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.support.wearable.view.CircledImageView;
+import android.support.wearable.view.WearableListView;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
+import android.text.style.TextAppearanceSpan;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import com.android.packageinstaller.R;
+import com.android.packageinstaller.permission.model.AppPermissionGroup;
+
+import java.util.ArrayList;
+
+public final class PermissionsSettingsAdapter extends SettingsAdapter<AppPermissionGroup> {
+    private Resources mRes;
+
+    public PermissionsSettingsAdapter(Context context) {
+        super(context, R.layout.permissions_settings_item);
+        mRes = context.getResources();
+    }
+
+    @Override
+    public WearableListView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        return new PermissionsViewHolder(new SettingsAdapter.SettingsItem(parent.getContext()));
+    }
+
+    @Override
+    public void onBindViewHolder(WearableListView.ViewHolder holder, int position) {
+        super.onBindViewHolder(holder, position);
+        PermissionsViewHolder viewHolder = (PermissionsViewHolder) holder;
+        AppPermissionGroup group = get(position).data;
+
+        if (group.isPolicyFixed()) {
+            viewHolder.imageView.setEnabled(false);
+            viewHolder.textView.setEnabled(false);
+            viewHolder.state.setEnabled(false);
+            viewHolder.state.setText(
+                    mRes.getString(R.string.permission_summary_enforced_by_policy));
+        } else {
+            viewHolder.imageView.setEnabled(true);
+            viewHolder.textView.setEnabled(true);
+            viewHolder.state.setEnabled(true);
+
+            if (group.areRuntimePermissionsGranted()) {
+                viewHolder.state.setText(R.string.generic_enabled);
+            } else {
+                viewHolder.state.setText(R.string.generic_disabled);
+            }
+        }
+    }
+
+    private static final class PermissionsViewHolder extends SettingsAdapter.SettingsItemHolder {
+        public final TextView state;
+
+        public PermissionsViewHolder(View view) {
+            super(view);
+            state = (TextView) view.findViewById(R.id.state);
+        }
+    }
+}
+
diff --git a/src/com/android/packageinstaller/permission/ui/wear/settings/SettingsAdapter.java b/src/com/android/packageinstaller/permission/ui/wear/settings/SettingsAdapter.java
index 9216cbbf..2ef7a2a4 100644
--- a/src/com/android/packageinstaller/permission/ui/wear/settings/SettingsAdapter.java
+++ b/src/com/android/packageinstaller/permission/ui/wear/settings/SettingsAdapter.java
@@ -228,7 +228,7 @@ public class SettingsAdapter<T> extends WearableListView.Adapter {
 
     protected static class SettingsItemHolder extends ExtendedViewHolder {
         public final CircledImageView imageView;
-        final TextView textView;
+        public final TextView textView;
 
         public SettingsItemHolder(View itemView) {
             super(itemView);