lawnchair/src/com/android/launcher3/widget/util/WidgetSizes.java

/*
 * Copyright (C) 2021 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.launcher3.widget.util;

import static android.appwidget.AppWidgetHostView.getDefaultPaddingForWidget;


import android.appwidget.AppWidgetHostView;
import android.appwidget.AppWidgetManager;
import android.content.ComponentName;
import android.content.Context;
import android.graphics.Point;
import android.graphics.Rect;
import android.os.Bundle;
import android.util.Size;
import android.util.SizeF;

import androidx.annotation.Nullable;

import com.android.launcher3.DeviceProfile;
import com.android.launcher3.LauncherAppState;
import com.android.launcher3.model.WidgetItem;

import java.util.ArrayList;
import java.util.List;

/** A utility class for widget sizes related calculations. */
public final class WidgetSizes {

    /**
     * Returns the list of all possible sizes, in dp, for a widget of given spans on this device.
     *
     * <p>The returned sizes already take into account the system padding, and whether it is applied
     * or not in that specific configuration.
     */
    public static ArrayList<SizeF> getWidgetPaddedSizes(Context context, ComponentName provider,
            int spanX, int spanY) {
        Rect padding = getDefaultPaddingForWidget(context, provider, /* padding= */ null);

        ArrayList<SizeF> sizes = new ArrayList<>(2);
        final float density = context.getResources().getDisplayMetrics().density;
        final Point cellSize = new Point();

        for (DeviceProfile profile : LauncherAppState.getIDP(context).supportedProfiles) {
            Size widgetSizePx = getWidgetSizePx(profile, spanX, spanY, cellSize);
            if (!profile.shouldInsetWidgets()) {
                widgetSizePx = new Size(widgetSizePx.getWidth() - padding.left - padding.right,
                        widgetSizePx.getHeight() - padding.top - padding.bottom);
            }
            sizes.add(new SizeF(widgetSizePx.getWidth() / density,
                    widgetSizePx.getHeight() / density));
        }
        return sizes;
    }

    /** Returns the size, in pixels, a widget of given spans & {@code profile}. */
    public static Size getWidgetSizePx(DeviceProfile profile, int spanX, int spanY) {
        return getWidgetSizePx(profile, spanX, spanY, /* recycledCellSize= */ null);
    }

    /**
     * Returns the size, in pixels and removing padding, a widget of given spans & {@code profile}.
     */
    public static Size getWidgetPaddedSizePx(Context context, ComponentName component,
            DeviceProfile profile, int spanX, int spanY) {
        Size size = getWidgetSizePx(profile, spanX, spanY);
        if (profile.shouldInsetWidgets()) {
            return size;
        }
        Rect padding = getDefaultPaddingForWidget(context, component, /* padding= */ null);
        return new Size(size.getWidth() - padding.left - padding.right,
                size.getHeight() - padding.top - padding.bottom);
    }

    /**
     * Returns the size of a WidgetItem.
     */
    public static Size getWidgetItemSizePx(Context context, DeviceProfile profile,
            WidgetItem widgetItem) {
        if (widgetItem.isShortcut()) {
            return getWidgetSizePx(profile, widgetItem.spanX, widgetItem.spanY);
        }
        return getWidgetPaddedSizePx(context, widgetItem.componentName, profile, widgetItem.spanX,
                widgetItem.spanY);
    }

    private static Size getWidgetSizePx(DeviceProfile profile, int spanX, int spanY,
            @Nullable Point recycledCellSize) {
        final int hBorderSpacing = (spanX - 1) * profile.cellLayoutBorderSpacingPx;
        final int vBorderSpacing = (spanY - 1) * profile.cellLayoutBorderSpacingPx;
        if (recycledCellSize == null) {
            recycledCellSize = new Point();
        }
        profile.getCellSize(recycledCellSize);
        return new Size(((spanX * recycledCellSize.x) + hBorderSpacing),
                ((spanY * recycledCellSize.y) + vBorderSpacing));
    }

    /**
     * Updates a given {@code widgetView} with size, {@code spanX}, {@code spanY}.
     *
     * <p>On Android S+, it also updates the given {@code widgetView} with a list of sizes derived
     * from {@code spanX}, {@code spanY} in all supported device profiles.
     */
    public static void updateWidgetSizeRanges(AppWidgetHostView widgetView, Context context,
            int spanX, int spanY) {
        AppWidgetManager widgetManager = AppWidgetManager.getInstance(context);
        int widgetId = widgetView.getAppWidgetId();
        if (widgetId <= 0) {
            return;
        }
        Bundle sizeOptions = getWidgetSizeOptions(context, widgetView.getAppWidgetInfo().provider,
                spanX, spanY);
        if (sizeOptions.<SizeF>getParcelableArrayList(
                AppWidgetManager.OPTION_APPWIDGET_SIZES).equals(
                widgetManager.getAppWidgetOptions(widgetId).<SizeF>getParcelableArrayList(
                        AppWidgetManager.OPTION_APPWIDGET_SIZES))) {
            return;
        }
        widgetManager.updateAppWidgetOptions(widgetId, sizeOptions);
    }

    /**
     * Returns the bundle to be used as the default options for a widget with provided size.
     */
    public static Bundle getWidgetSizeOptions(Context context, ComponentName provider, int spanX,
            int spanY) {
        ArrayList<SizeF> paddedSizes = getWidgetPaddedSizes(context, provider, spanX, spanY);

        Rect rect = getMinMaxSizes(paddedSizes);
        Bundle options = new Bundle();
        options.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH, rect.left);
        options.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, rect.top);
        options.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH, rect.right);
        options.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, rect.bottom);
        options.putParcelableArrayList(AppWidgetManager.OPTION_APPWIDGET_SIZES, paddedSizes);
        return options;
    }

    /**
     * Returns the min and max widths and heights given a list of sizes, in dp.
     *
     * @param sizes List of sizes to get the min/max from.
     * @return A rectangle with the left (resp. top) is used for the min width (resp. height) and
     * the right (resp. bottom) for the max. The returned rectangle is set with 0s if the list is
     * empty.
     */
    private static Rect getMinMaxSizes(List<SizeF> sizes) {
        if (sizes.isEmpty()) {
            return new Rect();
        } else {
            SizeF first = sizes.get(0);
            Rect result = new Rect((int) first.getWidth(), (int) first.getHeight(),
                    (int) first.getWidth(), (int) first.getHeight());
            for (int i = 1; i < sizes.size(); i++) {
                result.union((int) sizes.get(i).getWidth(), (int) sizes.get(i).getHeight());
            }
            return result;
        }
    }
}