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.graphics.PorterDuff;
  29 import android.graphics.PorterDuffColorFilter;
  30 import android.graphics.drawable.Drawable;
  31 import android.net.Uri;
  32 import android.util.ArrayMap;
  33
  34 import androidx.annotation.VisibleForTesting;
  35 import androidx.annotation.WorkerThread;
  36 import androidx.core.graphics.drawable.IconCompat;
  37 import androidx.slice.Slice;
  38 import androidx.slice.builders.ListBuilder;
  39 import androidx.slice.builders.ListBuilder.RowBuilder;
  40 import androidx.slice.builders.SliceAction;
  41
  42 import com.android.internal.os.BatteryStatsHelper;
  43 import com.android.settings.R;
  44 import com.android.settings.SubSettings;
  45 import com.android.settings.Utils;
  46 import com.android.settings.fuelgauge.BatteryStatsHelperLoader;
  47 import com.android.settings.fuelgauge.PowerUsageSummary;
  48 import com.android.settings.fuelgauge.batterytip.BatteryTipLoader;
  49 import com.android.settings.fuelgauge.batterytip.BatteryTipPreferenceController;
  50 import com.android.settings.fuelgauge.batterytip.tips.BatteryTip;
  51 import com.android.settings.slices.CustomSliceable;
  52 import com.android.settings.slices.SliceBackgroundWorker;
  53 import com.android.settings.slices.SliceBuilderUtils;
  54 import com.android.settingslib.utils.ThreadUtils;
  55
  56 import java.util.Arrays;
  57 import java.util.List;
  58 import java.util.Map;
  59
  60 public class BatteryFixSlice implements CustomSliceable {
  61
  62     @VisibleForTesting
  63     static final String PREFS = "battery_fix_prefs";
  64     @VisibleForTesting
  65     static final String KEY_CURRENT_TIPS_TYPE = "current_tip_type";
  66     static final String KEY_CURRENT_TIPS_STATE = "current_tip_state";
  67
  68     // A map tracking which BatteryTip and which state of that tip is not important.
  69     private static final Map<Integer, List<Integer>> UNIMPORTANT_BATTERY_TIPS;
  70
  71     static {
  72         UNIMPORTANT_BATTERY_TIPS = new ArrayMap<>();
  73         UNIMPORTANT_BATTERY_TIPS.put(BatteryTip.TipType.SUMMARY,
  74                 Arrays.asList(BatteryTip.StateType.NEW, BatteryTip.StateType.HANDLED));
  75         UNIMPORTANT_BATTERY_TIPS.put(BatteryTip.TipType.BATTERY_SAVER,
  76                 Arrays.asList(BatteryTip.StateType.HANDLED));
  77     }
  78
  79     private static final String TAG = "BatteryFixSlice";
  80
  81     private final Context mContext;
  82
  83     public BatteryFixSlice(Context context) {
  84         mContext = context;
  85     }
  86
  87     @Override
  88     public Uri getUri() {
  89         return BATTERY_FIX_SLICE_URI;
  90     }
  91
  92     @Override
  93     public Slice getSlice() {
  94         final ListBuilder sliceBuilder =
  95                 new ListBuilder(mContext, BATTERY_FIX_SLICE_URI, ListBuilder.INFINITY)
  96                         .setAccentColor(COLOR_NOT_TINTED);
  97
  98         if (!isBatteryTipAvailableFromCache(mContext)) {
  99             return buildBatteryGoodSlice(sliceBuilder, true /* isError */);
 100         }
 101
 102         final SliceBackgroundWorker worker = SliceBackgroundWorker.getInstance(getUri());
 103         final List<BatteryTip> batteryTips = worker != null ? worker.getResults() : null;
 104
 105         if (batteryTips == null) {
 106             // Because we need wait slice background worker return data
 107             return buildBatteryGoodSlice(sliceBuilder, false /* isError */);
 108         }
 109
 110         for (BatteryTip batteryTip : batteryTips) {
 111             if (batteryTip.getState() == BatteryTip.StateType.INVISIBLE) {
 112                 continue;
 113             }
 114             final Drawable drawable = mContext.getDrawable(batteryTip.getIconId());
 115             drawable.setColorFilter(new PorterDuffColorFilter(
 116                     mContext.getResources().getColor(batteryTip.getIconTintColorId()),
 117                     PorterDuff.Mode.SRC_IN));
 118
 119             final IconCompat icon = Utils.createIconWithDrawable(drawable);
 120             final SliceAction primaryAction = SliceAction.createDeeplink(getPrimaryAction(),
 121                     icon,
 122                     ListBuilder.ICON_IMAGE,
 123                     batteryTip.getTitle(mContext));
 124             sliceBuilder.addRow(new RowBuilder()
 125                     .setTitleItem(icon, ListBuilder.ICON_IMAGE)
 126                     .setTitle(batteryTip.getTitle(mContext))
 127                     .setSubtitle(batteryTip.getSummary(mContext))
 128                     .setPrimaryAction(primaryAction));
 129             break;
 130         }
 131         return sliceBuilder.build();
 132     }
 133
 134     @Override
 135     public Intent getIntent() {
 136         final String screenTitle = mContext.getText(R.string.power_usage_summary_title)
 137                 .toString();
 138         final Uri contentUri = new Uri.Builder()
 139                 .appendPath(BatteryTipPreferenceController.PREF_NAME).build();
 140
 141         return SliceBuilderUtils.buildSearchResultPageIntent(mContext,
 142                 PowerUsageSummary.class.getName(), BatteryTipPreferenceController.PREF_NAME,
 143                 screenTitle,
 144                 SettingsEnums.SLICE)
 145                 .setClassName(mContext.getPackageName(), SubSettings.class.getName())
 146                 .setData(contentUri);
 147     }
 148
 149     @Override
 150     public void onNotifyChange(Intent intent) {
 151     }
 152
 153     @Override
 154     public Class getBackgroundWorkerClass() {
 155         return BatteryTipWorker.class;
 156     }
 157
 158     private PendingIntent getPrimaryAction() {
 159         final Intent intent = getIntent();
 160         return PendingIntent.getActivity(mContext, 0  /* requestCode */, intent, 0  /* flags */);
 161     }
 162
 163     private Slice buildBatteryGoodSlice(ListBuilder sliceBuilder, boolean isError) {
 164         final IconCompat icon = IconCompat.createWithResource(mContext,
 165                 R.drawable.ic_battery_status_good_24dp);
 166         final String title = mContext.getString(R.string.power_usage_summary_title);
 167         final SliceAction primaryAction = SliceAction.createDeeplink(getPrimaryAction(), icon,
 168                 ListBuilder.ICON_IMAGE, title);
 169         sliceBuilder.addRow(new RowBuilder()
 170                 .setTitleItem(icon, ListBuilder.ICON_IMAGE)
 171                 .setTitle(title)
 172                 .setPrimaryAction(primaryAction))
 173                 .setIsError(isError);
 174         return sliceBuilder.build();
 175     }
 176
 177     // TODO(b/114807643): we should find a better way to get current battery tip type quickly
 178     // Now we save battery tip type to shared preference when battery level changes
 179     public static void updateBatteryTipAvailabilityCache(Context context) {
 180         ThreadUtils.postOnBackgroundThread(() -> refreshBatteryTips(context));
 181     }
 182
 183
 184     @VisibleForTesting
 185     static boolean isBatteryTipAvailableFromCache(Context context) {
 186         final SharedPreferences prefs = context.getSharedPreferences(PREFS, MODE_PRIVATE);
 187
 188         final int type = prefs.getInt(KEY_CURRENT_TIPS_TYPE, BatteryTip.TipType.SUMMARY);
 189         final int state = prefs.getInt(KEY_CURRENT_TIPS_STATE, BatteryTip.StateType.INVISIBLE);
 190         if (state == BatteryTip.StateType.INVISIBLE) {
 191             // State is INVISIBLE, We should not show anything.
 192             return false;
 193         }
 194         final boolean unimportant = UNIMPORTANT_BATTERY_TIPS.containsKey(type)
 195                 && UNIMPORTANT_BATTERY_TIPS.get(type).contains(state);
 196         return !unimportant;
 197     }
 198
 199     @WorkerThread
 200     private static List<BatteryTip> refreshBatteryTips(Context context) {
 201         final BatteryStatsHelperLoader statsLoader = new BatteryStatsHelperLoader(context);
 202         final BatteryStatsHelper statsHelper = statsLoader.loadInBackground();
 203         final BatteryTipLoader loader = new BatteryTipLoader(context, statsHelper);
 204         final List<BatteryTip> batteryTips = loader.loadInBackground();
 205         for (BatteryTip batteryTip : batteryTips) {
 206             if (batteryTip.getState() != BatteryTip.StateType.INVISIBLE) {
 207                 context.getSharedPreferences(PREFS, MODE_PRIVATE)
 208                         .edit()
 209                         .putInt(KEY_CURRENT_TIPS_TYPE, batteryTip.getType())
 210                         .putInt(KEY_CURRENT_TIPS_STATE, batteryTip.getState())
 211                         .apply();
 212                 break;
 213             }
 214         }
 215         return batteryTips;
 216     }
 217
 218     public static class BatteryTipWorker extends SliceBackgroundWorker<BatteryTip> {
 219
 220         private final Context mContext;
 221
 222         public BatteryTipWorker(Context context, Uri uri) {
 223             super(context, uri);
 224             mContext = context;
 225         }
 226
 227         @Override
 228         protected void onSlicePinned() {
 229             ThreadUtils.postOnBackgroundThread(() -> {
 230                 final List<BatteryTip> batteryTips = refreshBatteryTips(mContext);
 231                 updateResults(batteryTips);
 232             });
 233         }
 234
 235         @Override
 236         protected void onSliceUnpinned() {
 237         }
 238
 239         @Override
 240         public void close() {
 241         }
 242     }
 243 }