Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 54cc16fd authored by Zaiyue Xue's avatar Zaiyue Xue Committed by Android (Google) Code Review
Browse files

Merge changes from topics "battery_header_bar0", "battery_header_bar06",... 

Merge changes from topics "battery_header_bar0", "battery_header_bar06", "battery_header_bar1" into main

* changes:
  [PixelCare] Catalyst migration for battery header
  Remove BatteryHeaderPreferenceController usage in PowerUsageSummary.
  Split battery header text to a separated preference
parents 38ec311d 8e6066f5

res/layout/preference_battery_header_text.xml

0 → 100644
+32 −0
Original line number Diff line number Diff line 
<!--

  ~ Copyright (C) 2024 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.

  -->

<LinearLayout

    xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:orientation="vertical"

    android:layout_marginStart="?android:attr/listPreferredItemPaddingStart"

    android:layout_marginEnd="?android:attr/listPreferredItemPaddingEnd"

    android:paddingBottom="16dp">



    <TextView

        android:id="@+id/text"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:ellipsize="marquee"

        android:textAppearance="@*android:style/TextAppearance.DeviceDefault.Body1"

        android:textSize="14sp"/>

</LinearLayout>
 
 No newline at end of file

res/xml/power_usage_summary.xml

+7 −0
Original line number Diff line number Diff line
@@ -25,8 +25,15 @@ 
        android:key="battery_header"

        android:title="@string/summary_placeholder"

        android:selectable="false"

        android:paddingBottom="0px"

        android:persistent="false"

        settings:controller="com.android.settings.fuelgauge.BatteryHeaderPreferenceController" />



    <com.android.settings.fuelgauge.BatteryHeaderTextPreference

        android:key="battery_header_text"

        android:selectable="false"

        settings:controller="com.android.settings.fuelgauge.BatteryHeaderTextPreferenceController" />



    <com.android.settingslib.widget.LayoutPreference

        android:key="battery_help_message"

        android:layout="@layout/preference_battery_error"

src/com/android/settings/fuelgauge/BatteryHeaderPreference.kt

0 → 100644
+95 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.settings.fuelgauge



import android.content.Context

import androidx.annotation.VisibleForTesting

import androidx.preference.Preference

import com.android.settings.R

import com.android.settings.fuelgauge.BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_NOT_PRESENT

import com.android.settingslib.Utils

import com.android.settingslib.fuelgauge.BatteryUtils

import com.android.settingslib.metadata.PreferenceLifecycleContext

import com.android.settingslib.metadata.PreferenceLifecycleProvider

import com.android.settingslib.metadata.PreferenceMetadata

import com.android.settingslib.preference.PreferenceBinding

import com.android.settingslib.widget.UsageProgressBarPreference



// LINT.IfChange

class BatteryHeaderPreference :

    PreferenceMetadata,

    PreferenceBinding,

    PreferenceLifecycleProvider {



    @VisibleForTesting

    var batteryBroadcastReceiver: BatteryBroadcastReceiver? = null



    override val key: String

        get() = KEY



    override val title: Int

        get() = R.string.summary_placeholder



    override fun createWidget(context: Context) = UsageProgressBarPreference(context)



    override fun bind(preference: Preference, metadata: PreferenceMetadata) {

        super.bind(preference, metadata)

        preference.isSelectable = false

        if (preference is UsageProgressBarPreference) {

            quickUpdateHeaderPreference(preference)

        }

    }



    override fun isIndexable(context: Context) = false



    override fun onCreate(context: PreferenceLifecycleContext) {

        super.onCreate(context)

        batteryBroadcastReceiver = BatteryBroadcastReceiver(context).apply {

            setBatteryChangedListener {

                if (it != BATTERY_NOT_PRESENT) {

                    context.notifyPreferenceChange(KEY)

                }

            }

        }

    }



    override fun onStart(context: PreferenceLifecycleContext) {

        super.onStart(context)

        batteryBroadcastReceiver?.register();

    }



    override fun onStop(context: PreferenceLifecycleContext) {

        super.onStop(context)

        batteryBroadcastReceiver?.unRegister();

    }



    companion object {

        private const val KEY = "battery_header"

        private const val BATTERY_MAX_LEVEL: Long = 100L



        private fun quickUpdateHeaderPreference(preference: UsageProgressBarPreference) {

            val batteryIntent = BatteryUtils.getBatteryIntent(preference.context) ?: return

            val batteryLevel: Int = Utils.getBatteryLevel(batteryIntent)

            preference.apply {

                setUsageSummary(com.android.settings.Utils.formatPercentage(batteryLevel))

                setPercent(batteryLevel.toLong(), BATTERY_MAX_LEVEL)

                setBottomSummary("")

            }

        }

    }

}

// LINT.ThenChange(BatteryHeaderPreferenceController.java)

src/com/android/settings/fuelgauge/BatteryHeaderPreferenceController.java

+53 −116
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 * Copyright (C) 2024 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
@@ -15,59 +16,77 @@ 


package com.android.settings.fuelgauge;



import static com.android.settings.fuelgauge.BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_NOT_PRESENT;



import android.content.Context;

import android.content.Intent;

import android.os.BatteryManager;

import android.os.PowerManager;

import android.util.Log;



import androidx.annotation.NonNull;

import androidx.annotation.Nullable;

import androidx.annotation.VisibleForTesting;

import androidx.lifecycle.Lifecycle;

import androidx.lifecycle.LifecycleEventObserver;

import androidx.lifecycle.LifecycleOwner;

import androidx.preference.PreferenceScreen;



import com.android.settings.R;

import com.android.settings.core.BasePreferenceController;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settings.fuelgauge.batterytip.tips.BatteryTip;

import com.android.settings.overlay.FeatureFactory;

import com.android.settingslib.Utils;

import com.android.settingslib.widget.UsageProgressBarPreference;



// LINT.IfChange

/** Controller that update the battery header view */

public class BatteryHeaderPreferenceController extends BasePreferenceController

        implements PreferenceControllerMixin, BatteryPreferenceController {

        implements PreferenceControllerMixin, LifecycleEventObserver {

    private static final String TAG = "BatteryHeaderPreferenceController";



    @VisibleForTesting static final String KEY_BATTERY_HEADER = "battery_header";

    private static final int BATTERY_MAX_LEVEL = 100;



    @VisibleForTesting BatteryStatusFeatureProvider mBatteryStatusFeatureProvider;

    @VisibleForTesting UsageProgressBarPreference mBatteryUsageProgressBarPref;



    private final PowerManager mPowerManager;

    private final BatterySettingsFeatureProvider mBatterySettingsFeatureProvider;



    private BatteryTip mBatteryTip;

    @Nullable @VisibleForTesting BatteryBroadcastReceiver mBatteryBroadcastReceiver;

    @Nullable @VisibleForTesting UsageProgressBarPreference mBatteryUsageProgressBarPreference;



    public BatteryHeaderPreferenceController(Context context, String key) {

        super(context, key);

        mPowerManager = context.getSystemService(PowerManager.class);

        mBatteryStatusFeatureProvider =

                FeatureFactory.getFeatureFactory().getBatteryStatusFeatureProvider();

        mBatterySettingsFeatureProvider =

                FeatureFactory.getFeatureFactory().getBatterySettingsFeatureProvider();

    }



    @Override

    public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,

            @NonNull Lifecycle.Event event) {

        switch (event) {

            case ON_CREATE:

                mBatteryBroadcastReceiver = new BatteryBroadcastReceiver(mContext);

                mBatteryBroadcastReceiver.setBatteryChangedListener(

                        type -> {

                            if (type != BATTERY_NOT_PRESENT) {

                                quickUpdateHeaderPreference();

                            }

                        });

                break;

            case ON_START:

                if (mBatteryBroadcastReceiver != null) {

                    mBatteryBroadcastReceiver.register();

                }

                break;

            case ON_STOP:

                if (mBatteryBroadcastReceiver != null) {

                    mBatteryBroadcastReceiver.unRegister();

                }

                break;

            default:

                break;

        }

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mBatteryUsageProgressBarPref = screen.findPreference(getPreferenceKey());

        // Set up empty space text first to prevent layout flaky before info loaded.

        mBatteryUsageProgressBarPref.setBottomSummary(" ");

        mBatteryUsageProgressBarPreference = screen.findPreference(getPreferenceKey());

        // Hide the bottom summary from the progress bar.

        mBatteryUsageProgressBarPreference.setBottomSummary("");



        if (com.android.settings.Utils.isBatteryPresent(mContext)) {

            quickUpdateHeaderPreference();

        } else {

            mBatteryUsageProgressBarPref.setVisible(false);

            mBatteryUsageProgressBarPreference.setVisible(false);

        }

    }
@@ -76,105 +95,23 @@ public class BatteryHeaderPreferenceController extends BasePreferenceController 
        return AVAILABLE_UNSEARCHABLE;

    }



    private CharSequence generateLabel(BatteryInfo info) {

        if (Utils.containsIncompatibleChargers(mContext, TAG)) {

            return mContext.getString(

                    com.android.settingslib.R.string.battery_info_status_not_charging);

        }

        if (BatteryUtils.isBatteryDefenderOn(info)

                || FeatureFactory.getFeatureFactory()

                .getPowerUsageFeatureProvider()

                .isExtraDefend()) {

            return mContext.getString(

                    com.android.settingslib.R.string.battery_info_status_charging_on_hold);

        }

        if (info.remainingLabel != null

                && mBatterySettingsFeatureProvider.isChargingOptimizationMode(mContext)) {

            return info.remainingLabel;

        }

        if (info.batteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING) {

            return info.statusLabel;

        }

        if (info.pluggedStatus == BatteryManager.BATTERY_PLUGGED_WIRELESS) {

            final CharSequence wirelessChargingLabel =

                    mBatterySettingsFeatureProvider.getWirelessChargingLabel(mContext, info);

            if (wirelessChargingLabel != null) {

                mBatteryUsageProgressBarPref.setBottomSummaryContentDescription(

                        mBatterySettingsFeatureProvider

                                .getWirelessChargingContentDescription(mContext, info));

                return wirelessChargingLabel;

            }

        }

        if (info.remainingLabel == null) {

            return info.statusLabel;

        }

        if (info.statusLabel != null && !info.discharging) {

            // Charging state

            if (com.android.settingslib.fuelgauge.BatteryUtils.isChargingStringV2Enabled()) {

                return info.isFastCharging

                        ? mContext.getString(

                                R.string.battery_state_and_duration,

                                info.statusLabel,

                                info.remainingLabel)

                        : info.remainingLabel;

            }

            return mContext.getString(

                    R.string.battery_state_and_duration, info.statusLabel, info.remainingLabel);

        } else if (mPowerManager.isPowerSaveMode()) {

            // Power save mode is on

            final String powerSaverOn =

                    mContext.getString(R.string.battery_tip_early_heads_up_done_title);

            return mContext.getString(

                    R.string.battery_state_and_duration, powerSaverOn, info.remainingLabel);

        } else if (mBatteryTip != null && mBatteryTip.getType() == BatteryTip.TipType.LOW_BATTERY) {

            // Low battery state

            final String lowBattery = mContext.getString(R.string.low_battery_summary);

            return mContext.getString(

                    R.string.battery_state_and_duration, lowBattery, info.remainingLabel);

        } else {

            // Discharging state

            return info.remainingLabel;

        }

    }



    public void updateHeaderPreference(BatteryInfo info) {

        if (!mBatteryStatusFeatureProvider.triggerBatteryStatusUpdate(this, info)) {

            mBatteryUsageProgressBarPref.setBottomSummary(generateLabel(info));

        }



        mBatteryUsageProgressBarPref.setUsageSummary(

                formatBatteryPercentageText(info.batteryLevel));

        mBatteryUsageProgressBarPref.setPercent(info.batteryLevel, BATTERY_MAX_LEVEL);

    }



    /** Callback which receives text for the summary line. */

    public void updateBatteryStatus(String label, BatteryInfo info) {

        final CharSequence summary = label != null ? label : generateLabel(info);

        mBatteryUsageProgressBarPref.setBottomSummary(summary);

        Log.d(TAG, "updateBatteryStatus: " + label + " summary: " + summary);

    /** Updates {@link UsageProgressBarPreference} information. */

    public void quickUpdateHeaderPreference() {

        if (mBatteryUsageProgressBarPreference == null) {

            return;

        }



    public void quickUpdateHeaderPreference() {

        Intent batteryBroadcast =

                com.android.settingslib.fuelgauge.BatteryUtils.getBatteryIntent(mContext);

        final int batteryLevel = Utils.getBatteryLevel(batteryBroadcast);

        final boolean discharging =

                batteryBroadcast.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1) == 0;



        mBatteryUsageProgressBarPref.setUsageSummary(formatBatteryPercentageText(batteryLevel));

        mBatteryUsageProgressBarPref.setPercent(batteryLevel, BATTERY_MAX_LEVEL);

    }



    /** Update summary when battery tips changed. */

    public void updateHeaderByBatteryTips(BatteryTip batteryTip, BatteryInfo batteryInfo) {

        mBatteryTip = batteryTip;



        if (mBatteryTip != null && batteryInfo != null) {

            updateHeaderPreference(batteryInfo);

        }

        mBatteryUsageProgressBarPreference.setUsageSummary(

                formatBatteryPercentageText(batteryLevel));

        mBatteryUsageProgressBarPreference.setPercent(batteryLevel, BATTERY_MAX_LEVEL);

    }



    private CharSequence formatBatteryPercentageText(int batteryLevel) {

        return com.android.settings.Utils.formatPercentage(batteryLevel);

    }

}

// LINT.ThenChange(BatteryHeaderPreference.kt)

src/com/android/settings/fuelgauge/BatteryHeaderTextPreference.java

0 → 100644
+60 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.settings.fuelgauge;



import android.content.Context;

import android.text.TextUtils;

import android.util.AttributeSet;

import android.widget.TextView;



import androidx.annotation.Nullable;

import androidx.preference.Preference;

import androidx.preference.PreferenceViewHolder;



import com.android.settings.R;



/** A preference for battery header text. */

public class BatteryHeaderTextPreference extends Preference {

    private static final String TAG = "BatteryHeaderTextPreference";



    @Nullable private CharSequence mText;

    @Nullable private CharSequence mContentDescription;



    public BatteryHeaderTextPreference(Context context, AttributeSet attrs) {

        super(context, attrs);

        setLayoutResource(R.layout.preference_battery_header_text);

    }



    @Override

    public void onBindViewHolder(PreferenceViewHolder view) {

        final TextView textView = (TextView) view.findViewById(R.id.text);

        textView.setText(mText);

        if (!TextUtils.isEmpty(mContentDescription)) {

            textView.setContentDescription(mContentDescription);

        }

    }



    void setText(@Nullable CharSequence text) {

        mText = text;

        notifyChanged();

    }



    void setContentDescription(@Nullable CharSequence contentDescription) {

        mContentDescription = contentDescription;

        notifyChanged();

    }

}