public static LauncherAppWidgetProviderInfo fromProviderInfo(Context context,
        AppWidgetProviderInfo info) {
    final LauncherAppWidgetProviderInfo launcherInfo;
    if (info instanceof LauncherAppWidgetProviderInfo) {
        launcherInfo = (LauncherAppWidgetProviderInfo) info;
    } else {

        // In lieu of a public super copy constructor, we first write the AppWidgetProviderInfo
        // into a parcel, and then construct a new LauncherAppWidgetProvider info from the
        // associated super parcel constructor. This allows us to copy non-public members without
        // using reflection.
        Parcel p = Parcel.obtain();
        info.writeToParcel(p, 0);
        p.setDataPosition(0);
        launcherInfo = new LauncherAppWidgetProviderInfo(p);
        p.recycle();
    }
    launcherInfo.initSpans(context);
    return launcherInfo;
}
 

/**
 * Gets a list of work profile apps that have disabled cross-profile widget providers.
 *
 * @return A list of package names which have disabled cross-profile widget providers.
 */
public List<String> getDisabledCrossProfileWidgetProvidersList() {
    Set<String> enabledCrossProfileWidgetProvidersList = new HashSet<String>(
            mDevicePolicyManager.getCrossProfileWidgetProviders(
                    DeviceAdminReceiver.getComponentName(mContext)));
    // Cross-profile widgets are enabled by their package name. Use set to avoid duplicates.
    Set<String> disabledCrossProfileWidgetProvidersPackageNameSet = new HashSet<String>();
    List<AppWidgetProviderInfo> appWidgetProviderInfoList = mAppWidgetManager
            .getInstalledProviders();
    for (AppWidgetProviderInfo appWidgetProviderInfo : appWidgetProviderInfoList) {
        String appWidgetProviderPackage = appWidgetProviderInfo.provider.getPackageName();
        if (!enabledCrossProfileWidgetProvidersList.contains(appWidgetProviderPackage)) {
            disabledCrossProfileWidgetProvidersPackageNameSet.add(appWidgetProviderPackage);
        }
    }
    return new ArrayList<String>(disabledCrossProfileWidgetProvidersPackageNameSet);
}
 

/**
 * -     * Returns a widget with category {@link AppWidgetProviderInfo#WIDGET_CATEGORY_SEARCHBOX}
 * -     * provided by the same package which is set to be global search activity.
 * -     * If widgetCategory is not supported, or no such widget is found, returns the first widget
 * -     * provided by the package.
 * -
 */
public static AppWidgetProviderInfo get(Context context) {
    SearchManager searchManager =
            (SearchManager) context.getSystemService(Context.SEARCH_SERVICE);
    ComponentName searchComponent = searchManager.getGlobalSearchActivity();
    if (searchComponent == null) return null;
    String providerPkg = searchComponent.getPackageName();

    AppWidgetProviderInfo defaultWidgetForSearchPackage = null;

    AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
    for (AppWidgetProviderInfo info : appWidgetManager.getInstalledProviders()) {
        if (info.provider.getPackageName().equals(providerPkg) && info.configure == null) {
            if ((info.widgetCategory & AppWidgetProviderInfo.WIDGET_CATEGORY_SEARCHBOX) != 0) {
                return info;
            } else if (defaultWidgetForSearchPackage == null) {
                defaultWidgetForSearchPackage = info;
            }
        }
    }
    return defaultWidgetForSearchPackage;
}
 

public Widget(Context context) {
    mContext = context;
    mPrefs = context.getSharedPreferences("widgets", Context.MODE_PRIVATE);

    setupHost(context);

    //mAppWidgetHost.deleteHost();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        for (int oid: mAppWidgetHost.getAppWidgetIds()) {
            AppWidgetProviderInfo provider = mAppWidgetManager.getAppWidgetInfo(oid);
            if (provider==null) continue;
            Log.d(TAG, "Widget is allocated: " + provider.provider);
        }
    }

}
 

public List<AppWidgetProviderInfo> getWidgetsForPackage(String packageName) {
    List<AppWidgetProviderInfo> provs;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        UserHandle user = UserHandle.getUserHandleForUid(Process.myUid());
        provs =  mAppWidgetManager.getInstalledProvidersForPackage(packageName, user);

    } else {
        provs = new ArrayList<>();
        for (AppWidgetProviderInfo prov: mAppWidgetManager.getInstalledProviders()) {
            if (prov.provider.getPackageName().equals(packageName)) {
                provs.add(prov);
            }
        }
    }
    return provs;
}
 

public void applyFromAppWidgetProviderInfo(AppWidgetProviderInfo info,
        int maxWidth, int[] cellSpan, WidgetPreviewLoader loader) {
    LauncherAppState app = LauncherAppState.getInstance();
    DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();

    mIsAppWidget = true;
    mInfo = info;
    final ImageView image = (ImageView) findViewById(R.id.widget_preview);
    if (maxWidth > -1) {
        image.setMaxWidth(maxWidth);
    }
    final TextView name = (TextView) findViewById(R.id.widget_name);
    name.setText(info.label);
    final TextView dims = (TextView) findViewById(R.id.widget_dims);
    if (dims != null) {
        int hSpan = Math.min(cellSpan[0], (int) grid.numColumns);
        int vSpan = Math.min(cellSpan[1], (int) grid.numRows);
        dims.setText(String.format(mDimensionsFormatString, hSpan, vSpan));
    }
    mWidgetPreviewLoader = loader;
}
 

public boolean beginResizeIfPointInRegion(int x, int y) {
    boolean horizontalActive = (mResizeMode & AppWidgetProviderInfo.RESIZE_HORIZONTAL) != 0;
    boolean verticalActive = (mResizeMode & AppWidgetProviderInfo.RESIZE_VERTICAL) != 0;

    mLeftBorderActive = (x < mTouchTargetWidth) && horizontalActive;
    mRightBorderActive = (x > getWidth() - mTouchTargetWidth) && horizontalActive;
    mTopBorderActive = (y < mTouchTargetWidth + mTopTouchRegionAdjustment) && verticalActive;
    mBottomBorderActive = (y > getHeight() - mTouchTargetWidth + mBottomTouchRegionAdjustment)
            && verticalActive;

    boolean anyBordersActive = mLeftBorderActive || mRightBorderActive
            || mTopBorderActive || mBottomBorderActive;

    mBaselineWidth = getMeasuredWidth();
    mBaselineHeight = getMeasuredHeight();
    mBaselineX = getLeft();
    mBaselineY = getTop();

    if (anyBordersActive) {
        mLeftHandle.setAlpha(mLeftBorderActive ? 1.0f : DIMMED_HANDLE_ALPHA);
        mRightHandle.setAlpha(mRightBorderActive ? 1.0f :DIMMED_HANDLE_ALPHA);
        mTopHandle.setAlpha(mTopBorderActive ? 1.0f : DIMMED_HANDLE_ALPHA);
        mBottomHandle.setAlpha(mBottomBorderActive ? 1.0f : DIMMED_HANDLE_ALPHA);
    }
    return anyBordersActive;
}
 

@Override
public List<AppWidgetProviderInfo> getAllProviders() {
    ArrayList<AppWidgetProviderInfo> providers = new ArrayList<AppWidgetProviderInfo>();
    for (UserHandle user : mUserManager.getUserProfiles()) {
        providers.addAll(mAppWidgetManager.getInstalledProvidersForProfile(user));
    }
    return providers;
}
 

@Override
protected void after(XParam param) throws Throwable {
	switch (mMethod) {
	case getInstalledProviders:
	case getInstalledProvidersForProfile:
	case Srv_getInstalledProviders:
	case Srv_getInstalledProvidersForProfile:
		if (param.getResult() != null)
			if (isRestricted(param))
				param.setResult(new ArrayList<AppWidgetProviderInfo>());
		break;
	}
}
 

/**
 * Handles {@link #requestPinShortcut} and {@link ShortcutServiceInternal#requestPinAppWidget}.
 * After validating the caller, it passes the request to {@link #mShortcutRequestPinProcessor}.
 * Either {@param shortcut} or {@param appWidget} should be non-null.
 */
private boolean requestPinItem(String packageName, int userId, ShortcutInfo shortcut,
        AppWidgetProviderInfo appWidget, Bundle extras, IntentSender resultIntent) {
    verifyCaller(packageName, userId);
    verifyShortcutInfoPackage(packageName, shortcut);

    final boolean ret;
    synchronized (mLock) {
        throwIfUserLockedL(userId);

        Preconditions.checkState(isUidForegroundLocked(injectBinderCallingUid()),
                "Calling application must have a foreground activity or a foreground service");

        // If it's a pin shortcut request, and there's already a shortcut with the same ID
        // that's not visible to the caller (i.e. restore-blocked; meaning it's pinned by
        // someone already), then we just replace the existing one with this new one,
        // and then proceed the rest of the process.
        if (shortcut != null) {
            final ShortcutPackage ps = getPackageShortcutsForPublisherLocked(
                    packageName, userId);
            final String id = shortcut.getId();
            if (ps.isShortcutExistsAndInvisibleToPublisher(id)) {

                ps.updateInvisibleShortcutForPinRequestWith(shortcut);

                packageShortcutsChanged(packageName, userId);
            }
        }

        // Send request to the launcher, if supported.
        ret = mShortcutRequestPinProcessor.requestPinItemLocked(shortcut, appWidget, extras,
                userId, resultIntent);
    }

    verifyStates();

    return ret;
}
 

@Override
public boolean requestPinAppWidget(@NonNull String callingPackage,
        @NonNull AppWidgetProviderInfo appWidget, @Nullable Bundle extras,
        @Nullable IntentSender resultIntent, int userId) {
    Preconditions.checkNotNull(appWidget);
    return requestPinItem(callingPackage, userId, null, appWidget, extras, resultIntent);
}
 

public Bitmap generateWidgetPreview(AppWidgetProviderInfo info, Bitmap preview) {
    int[] cellSpans = Launcher.getSpanForWidget(mContext, info);
    int maxWidth = maxWidthForWidgetPreview(cellSpans[0]);
    int maxHeight = maxHeightForWidgetPreview(cellSpans[1]);
    return generateWidgetPreview(info.provider, info.previewImage, info.icon,
            cellSpans[0], cellSpans[1], maxWidth, maxHeight, preview, null);
}
 

/**
 * Attempts to find an AppWidgetProviderInfo that matches the given component.
 */
static AppWidgetProviderInfo findAppWidgetProviderInfoWithComponent(Context context,
        ComponentName component) {
    List<AppWidgetProviderInfo> widgets =
        AppWidgetManager.getInstance(context).getInstalledProviders();
    for (AppWidgetProviderInfo info : widgets) {
        if (info.provider.equals(component)) {
            return info;
        }
    }
    return null;
}
 

@Override
public void startConfigActivity(AppWidgetProviderInfo info, int widgetId, Activity activity,
        AppWidgetHost host, int requestCode) {
    Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_CONFIGURE);
    intent.setComponent(info.configure);
    intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, widgetId);
    Utilities.startActivityForResultSafely(activity, intent, requestCode);
}
 

@Override
public void startConfigActivity(AppWidgetProviderInfo info, int widgetId, Activity activity,
        AppWidgetHost host, int requestCode) {
    try {
        host.startAppWidgetConfigureActivityForResult(activity, widgetId, 0, requestCode, null);
    } catch (ActivityNotFoundException | SecurityException e) {
        Toast.makeText(activity, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
    }
}
 

@Override
public LauncherAppWidgetProviderInfo findProvider(ComponentName provider, UserHandle user) {
    for (AppWidgetProviderInfo info : mAppWidgetManager
            .getInstalledProvidersForProfile(user)) {
        if (info.provider.equals(provider)) {
            return LauncherAppWidgetProviderInfo.fromProviderInfo(mContext, info);
        }
    }
    return null;
}
 

@Override
public HashMap<ComponentKey, AppWidgetProviderInfo> getAllProvidersMap() {
    HashMap<ComponentKey, AppWidgetProviderInfo> result = new HashMap<>();
    for (UserHandle user : mUserManager.getUserProfiles()) {
        for (AppWidgetProviderInfo info :
                mAppWidgetManager.getInstalledProvidersForProfile(user)) {
            result.put(new ComponentKey(info.provider, user), info);
        }
    }
    return result;
}
 

/**
 * @param packageUser If null, all widgets and shortcuts are updated and returned, otherwise
 *                    only widgets and shortcuts associated with the package/user are.
 */
public ArrayList<WidgetItem> update(Context context, @Nullable PackageUserKey packageUser) {

    final ArrayList<WidgetItem> widgetsAndShortcuts = new ArrayList<>();
    try {
        PackageManager pm = context.getPackageManager();
        InvariantDeviceProfile idp = LauncherAppState.getIDP(context);

        // Widgets
        AppWidgetManagerCompat widgetManager = AppWidgetManagerCompat.getInstance(context);
        for (AppWidgetProviderInfo widgetInfo : widgetManager.getAllProviders(packageUser)) {
            widgetsAndShortcuts.add(new WidgetItem(LauncherAppWidgetProviderInfo
                    .fromProviderInfo(context, widgetInfo), pm, idp));
        }

        // Shortcuts
        for (ShortcutConfigActivityInfo info : LauncherAppsCompat.getInstance(context)
                .getCustomShortcutActivityList(packageUser)) {
            widgetsAndShortcuts.add(new WidgetItem(info));
        }
        setWidgetsAndShortcuts(widgetsAndShortcuts, context, packageUser);
    } catch (Exception e) {
        if (Utilities.isBinderSizeError(e)) {
            // the returned value may be incomplete and will not be refreshed until the next
            // time Launcher starts.
            // TODO: after figuring out a repro step, introduce a dirty bit to check when
            // onResume is called to refresh the widget provider list.
        } else {
            throw e;
        }
    }
    return widgetsAndShortcuts;
}
 

@Override
public AppWidgetProviderInfo getAppWidgetInfo() {
    AppWidgetProviderInfo info = super.getAppWidgetInfo();
    if (info != null && !(info instanceof LauncherAppWidgetProviderInfo)) {
        throw new IllegalStateException("Launcher widget must have"
                + " LauncherAppWidgetProviderInfo");
    }
    return info;
}
 

private Advanceable getAdvanceable() {
    AppWidgetProviderInfo info = getAppWidgetInfo();
    if (info == null || info.autoAdvanceViewId == NO_ID || !mIsAttachedToWindow) {
        return null;
    }
    View v = findViewById(info.autoAdvanceViewId);
    return (v instanceof Advanceable) ? (Advanceable) v : null;
}
 

@Override
protected AppWidgetHostView onCreateView(Context context, int appWidgetId,
        AppWidgetProviderInfo appWidget) {
    if (appWidgetId == mQsbWidgetId) {
        return new LauncherAppWidgetHostView(context) {

            @Override
            protected View getErrorView() {
                // For the QSB, show an empty view instead of an error view.
                return new View(getContext());
            }
        };
    }
    return new LauncherAppWidgetHostView(context);
}
 

public static final Comparator<AppWidgetProviderInfo> getWidgetNameComparator() {
	final Collator collator = Collator.getInstance();
	return new Comparator<AppWidgetProviderInfo>() {
		public final int compare(AppWidgetProviderInfo a,
				AppWidgetProviderInfo b) {
			return collator.compare(a.label.toString().trim(), b.label
					.toString().trim());
		}
	};
}
 

public void widgetsRestored(final ArrayList<LauncherAppWidgetInfo> changedInfo) {
    if (!changedInfo.isEmpty()) {
        DeferredWidgetRefresh widgetRefresh = new DeferredWidgetRefresh(changedInfo,
                mLauncher.getAppWidgetHost());

        LauncherAppWidgetInfo item = changedInfo.get(0);
        final AppWidgetProviderInfo widgetInfo;
        if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
            widgetInfo = AppWidgetManagerCompat
                    .getInstance(mLauncher).findProvider(item.providerName, item.user);
        } else {
            widgetInfo = AppWidgetManagerCompat.getInstance(mLauncher)
                    .getAppWidgetInfo(item.appWidgetId);
        }

        if (widgetInfo != null) {
            // Re-inflate the widgets which have changed status
            widgetRefresh.run();
        } else {
            // widgetRefresh will automatically run when the packages are updated.
            // For now just update the progress bars
            mapOverItems(MAP_NO_RECURSE, new ItemOperator() {
                @Override
                public boolean evaluate(ItemInfo info, View view) {
                    if (view instanceof PendingAppWidgetHostView
                            && changedInfo.contains(info)) {
                        ((LauncherAppWidgetInfo) info).installProgress = 100;
                        ((PendingAppWidgetHostView) view).applyState();
                    }
                    // process all the shortcuts
                    return false;
                }
            });
        }
    }
}
 

public void onPackagesUpdated(ArrayList<Object> widgetsAndShortcuts) {
    LauncherAppState app = LauncherAppState.getInstance();
    DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();

    // Get the list of widgets and shortcuts
    mWidgets.clear();
    for (Object o : widgetsAndShortcuts) {
        if (o instanceof AppWidgetProviderInfo) {
            AppWidgetProviderInfo widget = (AppWidgetProviderInfo) o;
            if (!app.shouldShowAppOrWidgetProvider(widget.provider)) {
                continue;
            }
            if (widget.minWidth > 0 && widget.minHeight > 0) {
                // Ensure that all widgets we show can be added on a workspace of this size
                int[] spanXY = Launcher.getSpanForWidget(mLauncher, widget);
                int[] minSpanXY = Launcher.getMinSpanForWidget(mLauncher, widget);
                int minSpanX = Math.min(spanXY[0], minSpanXY[0]);
                int minSpanY = Math.min(spanXY[1], minSpanXY[1]);
                if (minSpanX <= (int) grid.numColumns &&
                    minSpanY <= (int) grid.numRows) {
                    mWidgets.add(widget);
                } else {
                    Log.e(TAG, "Widget " + widget.provider + " can not fit on this device (" +
                          widget.minWidth + ", " + widget.minHeight + ")");
                }
            } else {
                Log.e(TAG, "Widget " + widget.provider + " has invalid dimensions (" +
                      widget.minWidth + ", " + widget.minHeight + ")");
            }
        } else {
            // just add shortcuts
            mWidgets.add(o);
        }
    }
    updatePageCountsAndInvalidateData();
}
 

public void onPackagesUpdated(ArrayList<Object> widgetsAndShortcuts) {
    LauncherAppState app = LauncherAppState.getInstance();
    DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();

    // Get the list of widgets and shortcuts
    mWidgets.clear();
    for (Object o : widgetsAndShortcuts) {
        if (o instanceof AppWidgetProviderInfo) {
            AppWidgetProviderInfo widget = (AppWidgetProviderInfo) o;
            if (!app.shouldShowAppOrWidgetProvider(widget.provider)) {
                continue;
            }
            widget.label = widget.label.trim();
            if (widget.minWidth > 0 && widget.minHeight > 0) {
                // Ensure that all widgets we show can be added on a workspace of this size
                int[] spanXY = Launcher.getSpanForWidget(mLauncher, widget);
                int[] minSpanXY = Launcher.getMinSpanForWidget(mLauncher, widget);
                int minSpanX = Math.min(spanXY[0], minSpanXY[0]);
                int minSpanY = Math.min(spanXY[1], minSpanXY[1]);
                if (minSpanX <= (int) grid.numColumns &&
                    minSpanY <= (int) grid.numRows) {
                    mWidgets.add(widget);
                } else {
                    Log.e(TAG, "Widget " + widget.provider + " can not fit on this device (" +
                          widget.minWidth + ", " + widget.minHeight + ")");
                }
            } else {
                Log.e(TAG, "Widget " + widget.provider + " has invalid dimensions (" +
                      widget.minWidth + ", " + widget.minHeight + ")");
            }
        } else {
            // just add shortcuts
            mWidgets.add(o);
        }
    }
    filterWidgets();
}
 

/**
 * Gets an appwidget provider from the given package. If the package contains more than
 * one appwidget provider, an arbitrary one is returned.
 */
private ComponentName getProviderInPackage(String packageName) {
    AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(mContext);
    List<AppWidgetProviderInfo> providers = appWidgetManager.getInstalledProviders();
    if (providers == null) return null;
    final int providerCount = providers.size();
    for (int i = 0; i < providerCount; i++) {
        ComponentName provider = providers.get(i).provider;
        if (provider != null && provider.getPackageName().equals(packageName)) {
            return provider;
        }
    }
    return null;
}
 

private String getObjectPackage(Object o) {
    if (o instanceof AppWidgetProviderInfo) {
        return ((AppWidgetProviderInfo) o).provider.getPackageName();
    } else {
        ResolveInfo info = (ResolveInfo) o;
        return info.activityInfo.packageName;
    }
}
 

/**
 * Attempts to find an AppWidgetProviderInfo that matches the given
 * component.
 */
AppWidgetProviderInfo findAppWidgetProviderInfoWithComponent(
		Context context, ComponentName component) {
	List<AppWidgetProviderInfo> widgets = AppWidgetManager.getInstance(
			context).getInstalledProviders();
	for (AppWidgetProviderInfo info : widgets) {
		if (info.provider.equals(component)) {
			return info;
		}
	}
	return null;
}
 

private AppWidgetProviderInfo findAppWidgetProviderInfo(ComponentName component) {
    if (mWidgetMap == null) {
        List<AppWidgetProviderInfo> widgets =
                AppWidgetManager.getInstance(mContext).getInstalledProviders();
        mWidgetMap = new HashMap<ComponentName, AppWidgetProviderInfo>(widgets.size());
        for (AppWidgetProviderInfo info : widgets) {
            mWidgetMap.put(info.provider, info);
        }
    }
    return mWidgetMap.get(component);
}
 

void addWidgetToAutoAdvanceIfNeeded(View hostView,
		AppWidgetProviderInfo appWidgetInfo) {
	if (appWidgetInfo == null || appWidgetInfo.autoAdvanceViewId == -1)
		return;
	View v = hostView.findViewById(appWidgetInfo.autoAdvanceViewId);
	if (v instanceof Advanceable) {
		mWidgetsToAdvance.put(hostView, appWidgetInfo);
		((Advanceable) v).fyiWillBeAdvancedByHostKThx();
		updateRunning();
	}
}