src/com/android/settings/homepage/contextualcards/slices/BatteryFixSlice.java

   1 /*
   2  * Copyright (C) 2018 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.homepage.contextualcards.slices;
  18
  19 import static android.content.Context.MODE_PRIVATE;
  20
  21 import static com.android.settings.slices.CustomSliceRegistry.BATTERY_FIX_SLICE_URI;
  22
  23 import android.app.PendingIntent;
  24 import android.app.settings.SettingsEnums;
  25 import android.content.Context;
  26 import android.content.Intent;
  27 import android.content.SharedPreferences;
  28 import android.net.Uri;
  29 import android.util.ArrayMap;
  30
  31 import androidx.annotation.VisibleForTesting;
  32 import androidx.annotation.WorkerThread;
  33 import androidx.core.graphics.drawable.IconCompat;
  34 import androidx.slice.Slice;
  35 import androidx.slice.builders.ListBuilder;
  36 import androidx.slice.builders.ListBuilder.RowBuilder;
  37 import androidx.slice.builders.SliceAction;
  38
  39 import com.android.internal.os.BatteryStatsHelper;
  40 import com.android.settings.R;
  41 import com.android.settings.SubSettings;
  42 import com.android.settings.fuelgauge.BatteryStatsHelperLoader;
  43 import com.android.settings.fuelgauge.PowerUsageSummary;
  44 import com.android.settings.fuelgauge.batterytip.BatteryTipLoader;
  45 import com.android.settings.fuelgauge.batterytip.BatteryTipPreferenceController;
  46 import com.android.settings.fuelgauge.batterytip.tips.BatteryTip;
  47 import com.android.settings.slices.CustomSliceable;
  48 import com.android.settings.slices.SliceBackgroundWorker;
  49 import com.android.settings.slices.SliceBuilderUtils;
  50 import com.android.settingslib.utils.ThreadUtils;
  51
  52 import java.util.Arrays;
  53 import java.util.List;
  54 import java.util.Map;
  55
  56 public class BatteryFixSlice implements CustomSliceable {
  57
  58     @VisibleForTesting
  59     static final String PREFS = "battery_fix_prefs";
  60     @VisibleForTesting
  61     static final String KEY_CURRENT_TIPS_TYPE = "current_tip_type";
  62     static final String KEY_CURRENT_TIPS_STATE = "current_tip_state";
  63
  64     // A map tracking which BatteryTip and which state of that tip is not important.
  65     private static final Map<Integer, List<Integer>> UNIMPORTANT_BATTERY_TIPS;
  66
  67     static {
  68         UNIMPORTANT_BATTERY_TIPS = new ArrayMap<>();
  69         UNIMPORTANT_BATTERY_TIPS.put(BatteryTip.TipType.SUMMARY,
  70                 Arrays.asList(BatteryTip.StateType.NEW, BatteryTip.StateType.HANDLED));
  71         UNIMPORTANT_BATTERY_TIPS.put(BatteryTip.TipType.BATTERY_SAVER,
  72                 Arrays.asList(BatteryTip.StateType.HANDLED));
  73     }
  74
  75     private static final String TAG = "BatteryFixSlice";
  76
  77     private final Context mContext;
  78
  79     public BatteryFixSlice(Context context) {
  80         mContext = context;
  81     }
  82
  83     @Override
  84     public Uri getUri() {
  85         return BATTERY_FIX_SLICE_URI;
  86     }
  87
  88     @Override
  89     public Slice getSlice() {
  90         final ListBuilder sliceBuilder =
  91                 new ListBuilder(mContext, BATTERY_FIX_SLICE_URI, ListBuilder.INFINITY)
  92                         .setAccentColor(COLOR_NOT_TINTED);
  93
  94         if (!isBatteryTipAvailableFromCache(mContext)) {
  95             return buildBatteryGoodSlice(sliceBuilder, true /* isError */);
  96         }
  97
  98         final SliceBackgroundWorker worker = SliceBackgroundWorker.getInstance(getUri());
  99         final List<BatteryTip> batteryTips = worker != null ? worker.getResults() : null;
 100
 101         if (batteryTips == null) {
 102             // Because we need wait slice background worker return data
 103             return buildBatteryGoodSlice(sliceBuilder, false /* isError */);
 104         }
 105
 106         for (BatteryTip batteryTip : batteryTips) {
 107             if (batteryTip.getState() == BatteryTip.StateType.INVISIBLE) {
 108                 continue;
 109             }
 110             final IconCompat icon = IconCompat.createWithResource(mContext,
 111                     batteryTip.getIconId());
 112             final SliceAction primaryAction = SliceAction.createDeeplink(getPrimaryAction(),
 113                     icon,
 114                     ListBuilder.ICON_IMAGE,
 115                     batteryTip.getTitle(mContext));
 116             sliceBuilder.addRow(new RowBuilder()
 117                     .setTitleItem(icon, ListBuilder.ICON_IMAGE)
 118                     .setTitle(batteryTip.getTitle(mContext))
 119                     .setSubtitle(batteryTip.getSummary(mContext))
 120                     .setPrimaryAction(primaryAction));
 121             break;
 122         }
 123         return sliceBuilder.build();
 124     }
 125
 126     @Override
 127     public Intent getIntent() {
 128         final String screenTitle = mContext.getText(R.string.power_usage_summary_title)
 129                 .toString();
 130         final Uri contentUri = new Uri.Builder()
 131                 .appendPath(BatteryTipPreferenceController.PREF_NAME).build();
 132
 133         return SliceBuilderUtils.buildSearchResultPageIntent(mContext,
 134                 PowerUsageSummary.class.getName(), BatteryTipPreferenceController.PREF_NAME,
 135                 screenTitle,
 136                 SettingsEnums.SLICE)
 137                 .setClassName(mContext.getPackageName(), SubSettings.class.getName())
 138                 .setData(contentUri);
 139     }
 140
 141     @Override
 142     public void onNotifyChange(Intent intent) {
 143     }
 144
 145     @Override
 146     public Class getBackgroundWorkerClass() {
 147         return BatteryTipWorker.class;
 148     }
 149
 150     private PendingIntent getPrimaryAction() {
 151         final Intent intent = getIntent();
 152         return PendingIntent.getActivity(mContext, 0  /* requestCode */, intent, 0  /* flags */);
 153     }
 154
 155     private Slice buildBatteryGoodSlice(ListBuilder sliceBuilder, boolean isError) {
 156         final IconCompat icon = IconCompat.createWithResource(mContext,
 157                 R.drawable.ic_battery_status_good_24dp);
 158         final String title = mContext.getString(R.string.power_usage_summary_title);
 159         final SliceAction primaryAction = SliceAction.createDeeplink(getPrimaryAction(), icon,
 160                 ListBuilder.ICON_IMAGE, title);
 161         sliceBuilder.addRow(new RowBuilder()
 162                 .setTitleItem(icon, ListBuilder.ICON_IMAGE)
 163                 .setTitle(title)
 164                 .setPrimaryAction(primaryAction))
 165                 .setIsError(isError);
 166         return sliceBuilder.build();
 167     }
 168
 169     // TODO(b/114807643): we should find a better way to get current battery tip type quickly
 170     // Now we save battery tip type to shared preference when battery level changes
 171     public static void updateBatteryTipAvailabilityCache(Context context) {
 172         ThreadUtils.postOnBackgroundThread(() -> refreshBatteryTips(context));
 173     }
 174
 175
 176     @VisibleForTesting
 177     static boolean isBatteryTipAvailableFromCache(Context context) {
 178         final SharedPreferences prefs = context.getSharedPreferences(PREFS, MODE_PRIVATE);
 179
 180         final int type = prefs.getInt(KEY_CURRENT_TIPS_TYPE, BatteryTip.TipType.SUMMARY);
 181         final int state = prefs.getInt(KEY_CURRENT_TIPS_STATE, BatteryTip.StateType.INVISIBLE);
 182         if (state == BatteryTip.StateType.INVISIBLE) {
 183             // State is INVISIBLE, We should not show anything.
 184             return false;
 185         }
 186         final boolean unimportant = UNIMPORTANT_BATTERY_TIPS.containsKey(type)
 187                 && UNIMPORTANT_BATTERY_TIPS.get(type).contains(state);
 188         return !unimportant;
 189     }
 190
 191     @WorkerThread
 192     private static List<BatteryTip> refreshBatteryTips(Context context) {
 193         final BatteryStatsHelperLoader statsLoader = new BatteryStatsHelperLoader(context);
 194         final BatteryStatsHelper statsHelper = statsLoader.loadInBackground();
 195         final BatteryTipLoader loader = new BatteryTipLoader(context, statsHelper);
 196         final List<BatteryTip> batteryTips = loader.loadInBackground();
 197         for (BatteryTip batteryTip : batteryTips) {
 198             if (batteryTip.getState() != BatteryTip.StateType.INVISIBLE) {
 199                 context.getSharedPreferences(PREFS, MODE_PRIVATE)
 200                         .edit()
 201                         .putInt(KEY_CURRENT_TIPS_TYPE, batteryTip.getType())
 202                         .putInt(KEY_CURRENT_TIPS_STATE, batteryTip.getState())
 203                         .apply();
 204                 break;
 205             }
 206         }
 207         return batteryTips;
 208     }
 209
 210     public static class BatteryTipWorker extends SliceBackgroundWorker<BatteryTip> {
 211
 212         private final Context mContext;
 213
 214         public BatteryTipWorker(Context context, Uri uri) {
 215             super(context, uri);
 216             mContext = context;
 217         }
 218
 219         @Override
 220         protected void onSlicePinned() {
 221             ThreadUtils.postOnBackgroundThread(() -> {
 222                 final List<BatteryTip> batteryTips = refreshBatteryTips(mContext);
 223                 updateResults(batteryTips);
 224             });
 225         }
 226
 227         @Override
 228         protected void onSliceUnpinned() {
 229         }
 230
 231         @Override
 232         public void close() {
 233         }
 234     }
 235 }