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

Commit b8deebb4 authored by Josh Hou's avatar Josh Hou
Browse files

[Panlingual] Clear per-app locales setting when the LocaleConfig is 

removed

When a user has set per-app locales for a specific application from the system locale selector, and then the LocaleConfig of that application is removed after apps upgraded, the per-app locales needs to be reset to system default locales to avoid the user being unable to change the system locales.

Bug: 234131462
Test: 1.Run some CTS and unit test cases.
      2.Manual test.
Change-Id: I2809206ae31a745d297128f9e496023c4d670e11
parent 55fef411

services/core/java/com/android/server/locales/AppUpdateTracker.java

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

 * Copyright (C) 2022 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.server.locales;



import android.app.LocaleConfig;

import android.content.Context;

import android.content.SharedPreferences;

import android.content.pm.PackageManager;

import android.os.LocaleList;

import android.os.RemoteException;

import android.os.UserHandle;

import android.util.ArraySet;

import android.util.FeatureFlagUtils;

import android.util.Log;

import android.util.Slog;



import com.android.internal.annotations.VisibleForTesting;



import java.util.HashSet;

import java.util.Locale;

import java.util.Set;



/**

 * Track when a app is being updated.

 */

public class AppUpdateTracker {

    private static final String TAG = "AppUpdateTracker";



    private final Context mContext;

    private final LocaleManagerService mLocaleManagerService;

    private final LocaleManagerBackupHelper mBackupHelper;



    AppUpdateTracker(Context context, LocaleManagerService localeManagerService,

            LocaleManagerBackupHelper backupHelper) {

        mContext = context;

        mLocaleManagerService = localeManagerService;

        mBackupHelper = backupHelper;

    }



    /**

     * <p><b>Note:</b> This is invoked by service's common monitor

     * {@link LocaleManagerServicePackageMonitor#onPackageUpdateFinished} when a package is upgraded

     * on device.

     */

    public void onPackageUpdateFinished(String packageName, int uid) {

        Log.d(TAG, "onPackageUpdateFinished " + packageName);

        int userId = UserHandle.getUserId(uid);

        cleanApplicationLocalesIfNeeded(packageName, userId);

    }



    /**

     * When the user has set per-app locales for a specific application from a delegate selector,

     * and then the LocaleConfig of that application is removed in the upgraded version, the per-app

     * locales needs to be reset to system default locales to avoid the user being unable to change

     * system locales setting.

     */

    private void cleanApplicationLocalesIfNeeded(String packageName, int userId) {

        Set<String> packageNames = new ArraySet<>();

        SharedPreferences delegateAppLocalePackages = mBackupHelper.getPersistedInfo();

        if (delegateAppLocalePackages != null) {

            packageNames = delegateAppLocalePackages.getStringSet(Integer.toString(userId),

                    new ArraySet<>());

        }



        try {

            LocaleList appLocales = mLocaleManagerService.getApplicationLocales(packageName,

                    userId);

            if (appLocales.isEmpty() || isLocalesExistedInLocaleConfig(appLocales, packageName,

                    userId) || !packageNames.contains(packageName)) {

                return;

            }

        } catch (RemoteException | IllegalArgumentException e) {

            Slog.e(TAG, "Exception when getting locales for " + packageName, e);

            return;

        }



        Slog.d(TAG, "Clear app locales for " + packageName);

        try {

            mLocaleManagerService.setApplicationLocales(packageName, userId,

                    LocaleList.forLanguageTags(""), false);

        } catch (RemoteException | IllegalArgumentException e) {

            Slog.e(TAG, "Could not clear locales for " + packageName, e);

        }

    }



    /**

     * Check whether the LocaleConfig is existed and the per-app locales is presented in the

     * LocaleConfig file after the application is upgraded.

     */

    private boolean isLocalesExistedInLocaleConfig(LocaleList appLocales, String packageName,

            int userId) {

        LocaleList packageLocalesList = getPackageLocales(packageName, userId);

        HashSet<Locale> packageLocales = new HashSet<>();



        if (isSettingsAppLocalesOptIn()) {

            if (packageLocalesList == null || packageLocalesList.isEmpty()) {

                // The app locale feature is not enabled by the app

                Slog.d(TAG, "opt-in: the app locale feature is not enabled");

                return false;

            }

        } else {

            if (packageLocalesList != null && packageLocalesList.isEmpty()) {

                // The app locale feature is not enabled by the app

                Slog.d(TAG, "opt-out: the app locale feature is not enabled");

                return false;

            }

        }



        if (packageLocalesList != null && !packageLocalesList.isEmpty()) {

            // The app has added the supported locales into the LocaleConfig

            for (int i = 0; i < packageLocalesList.size(); i++) {

                packageLocales.add(packageLocalesList.get(i));

            }

            if (!matchesLocale(packageLocales, appLocales)) {

                // The set app locales do not match with the list of app supported locales

                Slog.d(TAG, "App locales: " + appLocales.toLanguageTags()

                        + " are not existed in the supported locale list");

                return false;

            }

        }



        return true;

    }



    /**

     * Get locales from LocaleConfig.

     */

    @VisibleForTesting

    public LocaleList getPackageLocales(String packageName, int userId) {

        try {

            LocaleConfig localeConfig = new LocaleConfig(

                    mContext.createPackageContextAsUser(packageName, 0, UserHandle.of(userId)));

            if (localeConfig.getStatus() == LocaleConfig.STATUS_SUCCESS) {

                return localeConfig.getSupportedLocales();

            }

        } catch (PackageManager.NameNotFoundException e) {

            Slog.e(TAG, "Can not found the package name : " + packageName + " / " + e);

        }

        return null;

    }



    /**

     * Check whether the feature to show per-app locales list in Settings is enabled.

     */

    @VisibleForTesting

    public boolean isSettingsAppLocalesOptIn() {

        return FeatureFlagUtils.isEnabled(mContext,

                FeatureFlagUtils.SETTINGS_APP_LOCALE_OPT_IN_ENABLED);

    }



    private boolean matchesLocale(HashSet<Locale> supported, LocaleList appLocales) {

        if (supported.size() <= 0 || appLocales.size() <= 0) {

            return true;

        }



        for (int i = 0; i < appLocales.size(); i++) {

            final Locale appLocale = appLocales.get(i);

            if (supported.stream().anyMatch(

                    locale -> LocaleList.matchesLanguageAndScript(locale, appLocale))) {

                return true;

            }

        }



        return false;

    }

}

services/core/java/com/android/server/locales/LocaleManagerBackupHelper.java

+5 −5
Original line number Original line Diff line number Diff line
@@ -359,7 +359,7 @@ class LocaleManagerBackupHelper { 
            if (!currLocales.isEmpty()) {

            if (!currLocales.isEmpty()) {

                return;

                return;

            }

            }

        } catch (RemoteException e) {

        } catch (RemoteException | IllegalArgumentException e) {

            Slog.e(TAG, "Could not check for current locales before restoring", e);

            Slog.e(TAG, "Could not check for current locales before restoring", e);

        }

        }
@@ -580,16 +580,16 @@ class LocaleManagerBackupHelper { 
        }

        }





        SharedPreferences.Editor editor = mDelegateAppLocalePackages.edit();

        SharedPreferences.Editor editor = mDelegateAppLocalePackages.edit();

        String key = Integer.toString(userId);

        String user = Integer.toString(userId);

        Set<String> packageNames = new ArraySet<>(

        Set<String> packageNames = new ArraySet<>(

                mDelegateAppLocalePackages.getStringSet(key, new ArraySet<>()));

                mDelegateAppLocalePackages.getStringSet(user, new ArraySet<>()));

        if (fromDelegate && !emptyLocales) {

        if (fromDelegate && !emptyLocales) {

            if (!packageNames.contains(packageName)) {

            if (!packageNames.contains(packageName)) {

                if (DEBUG) {

                if (DEBUG) {

                    Slog.d(TAG, "persist package: " + packageName);

                    Slog.d(TAG, "persist package: " + packageName);

                }

                }

                packageNames.add(packageName);

                packageNames.add(packageName);

                editor.putStringSet(key, packageNames);

                editor.putStringSet(user, packageNames);

            }

            }

        } else {

        } else {

            // Remove the package name if per-app locales was not set from the delegate selector

            // Remove the package name if per-app locales was not set from the delegate selector
@@ -599,7 +599,7 @@ class LocaleManagerBackupHelper { 
                    Slog.d(TAG, "remove package: " + packageName);

                    Slog.d(TAG, "remove package: " + packageName);

                }

                }

                packageNames.remove(packageName);

                packageNames.remove(packageName);

                editor.putStringSet(key, packageNames);

                editor.putStringSet(user, packageNames);

            }

            }

        }

        }

services/core/java/com/android/server/locales/LocaleManagerService.java

+3 −1
Original line number Original line Diff line number Diff line
@@ -94,9 +94,11 @@ public class LocaleManagerService extends SystemService { 




        mBackupHelper = new LocaleManagerBackupHelper(this,

        mBackupHelper = new LocaleManagerBackupHelper(this,

                mPackageManager, broadcastHandlerThread);

                mPackageManager, broadcastHandlerThread);

        AppUpdateTracker appUpdateTracker =

                new AppUpdateTracker(mContext, this, mBackupHelper);





        mPackageMonitor = new LocaleManagerServicePackageMonitor(mBackupHelper,

        mPackageMonitor = new LocaleManagerServicePackageMonitor(mBackupHelper,

                systemAppUpdateTracker);

                systemAppUpdateTracker, appUpdateTracker);

        mPackageMonitor.register(context, broadcastHandlerThread.getLooper(),

        mPackageMonitor.register(context, broadcastHandlerThread.getLooper(),

                UserHandle.ALL,

                UserHandle.ALL,

                true);

                true);

services/core/java/com/android/server/locales/LocaleManagerServicePackageMonitor.java

+4 −1
Original line number Original line Diff line number Diff line
@@ -34,11 +34,13 @@ import com.android.internal.content.PackageMonitor; 
final class LocaleManagerServicePackageMonitor extends PackageMonitor {

final class LocaleManagerServicePackageMonitor extends PackageMonitor {

    private LocaleManagerBackupHelper mBackupHelper;

    private LocaleManagerBackupHelper mBackupHelper;

    private SystemAppUpdateTracker mSystemAppUpdateTracker;

    private SystemAppUpdateTracker mSystemAppUpdateTracker;

    private AppUpdateTracker mAppUpdateTracker;





    LocaleManagerServicePackageMonitor(LocaleManagerBackupHelper localeManagerBackupHelper,

    LocaleManagerServicePackageMonitor(LocaleManagerBackupHelper localeManagerBackupHelper,

            SystemAppUpdateTracker systemAppUpdateTracker) {

            SystemAppUpdateTracker systemAppUpdateTracker, AppUpdateTracker appUpdateTracker) {

        mBackupHelper = localeManagerBackupHelper;

        mBackupHelper = localeManagerBackupHelper;

        mSystemAppUpdateTracker = systemAppUpdateTracker;

        mSystemAppUpdateTracker = systemAppUpdateTracker;

        mAppUpdateTracker = appUpdateTracker;

    }

    }





    @Override

    @Override
@@ -58,6 +60,7 @@ final class LocaleManagerServicePackageMonitor extends PackageMonitor { 




    @Override

    @Override

    public void onPackageUpdateFinished(String packageName, int uid) {

    public void onPackageUpdateFinished(String packageName, int uid) {

        mAppUpdateTracker.onPackageUpdateFinished(packageName, uid);

        mSystemAppUpdateTracker.onPackageUpdateFinished(packageName, uid);

        mSystemAppUpdateTracker.onPackageUpdateFinished(packageName, uid);

    }

    }

}
 
}

services/tests/servicestests/src/com/android/server/locales/AppUpdateTrackerTest.java

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

 * Copyright (C) 2022 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.server.locales;



import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyBoolean;

import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;



import android.content.Context;

import android.content.SharedPreferences;

import android.os.Binder;

import android.os.LocaleList;

import android.util.ArraySet;



import androidx.test.ext.junit.runners.AndroidJUnit4;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;



import java.util.Arrays;

import java.util.Set;



/**

 * Unit tests for {@link AppUpdateTracker}.

 */

@RunWith(AndroidJUnit4.class)

public class AppUpdateTrackerTest {

    private static final String DEFAULT_PACKAGE_NAME = "com.android.myapp";

    private static final int DEFAULT_UID = Binder.getCallingUid() + 100;

    private static final int DEFAULT_USER_ID = 0;

    private static final String DEFAULT_LOCALE_TAGS = "en-XC,ar-XB";

    private static final LocaleList DEFAULT_LOCALES = LocaleList.forLanguageTags(

            DEFAULT_LOCALE_TAGS);

    private AppUpdateTracker mAppUpdateTracker;



    @Mock

    private Context mMockContext;

    @Mock

    private LocaleManagerService mMockLocaleManagerService;

    @Mock

    private ShadowLocaleManagerBackupHelper mMockBackupHelper;



    @Before

    public void setUp() throws Exception {

        mMockContext = mock(Context.class);

        mMockLocaleManagerService = mock(LocaleManagerService.class);

        mMockBackupHelper = mock(ShadowLocaleManagerBackupHelper.class);

        mAppUpdateTracker = spy(

                new AppUpdateTracker(mMockContext, mMockLocaleManagerService, mMockBackupHelper));

    }



    @Test

    public void testPackageUpgraded_localeEmpty_doNothing() throws Exception {

        setUpLocalesForPackage(DEFAULT_PACKAGE_NAME, LocaleList.getEmptyLocaleList());

        setUpPackageNamesForSp(new ArraySet<>(Arrays.asList(DEFAULT_PACKAGE_NAME)));

        setUpPackageLocaleConfig(null, DEFAULT_PACKAGE_NAME);

        setUpAppLocalesOptIn(true);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verifyNoLocalesCleared();

    }



    @Test

    public void testPackageUpgraded_pkgNotInSp_doNothing() throws Exception {

        setUpLocalesForPackage(DEFAULT_PACKAGE_NAME, DEFAULT_LOCALES);

        String pkgNameA = "com.android.myAppA";

        String pkgNameB = "com.android.myAppB";

        setUpPackageNamesForSp(new ArraySet<>(Arrays.asList(pkgNameA, pkgNameB)));

        setUpPackageLocaleConfig(null, DEFAULT_PACKAGE_NAME);

        setUpAppLocalesOptIn(true);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verifyNoLocalesCleared();

    }



    @Test

    public void testPackageUpgraded_appLocalesSupported_doNothing() throws Exception {

        setUpLocalesForPackage(DEFAULT_PACKAGE_NAME, DEFAULT_LOCALES);

        setUpPackageNamesForSp(new ArraySet<>(Arrays.asList(DEFAULT_PACKAGE_NAME)));

        setUpPackageLocaleConfig(DEFAULT_LOCALES, DEFAULT_PACKAGE_NAME);



        setUpAppLocalesOptIn(true);

        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verifyNoLocalesCleared();



        setUpAppLocalesOptIn(false);

        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verifyNoLocalesCleared();



        setUpAppLocalesOptIn(false);

        setUpPackageLocaleConfig(null, DEFAULT_PACKAGE_NAME);

        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verifyNoLocalesCleared();

    }



    @Test

    public void testPackageUpgraded_appLocalesNotSupported_clearAppLocale() throws Exception {

        setUpLocalesForPackage(DEFAULT_PACKAGE_NAME, DEFAULT_LOCALES);

        setUpPackageNamesForSp(new ArraySet<>(Arrays.asList(DEFAULT_PACKAGE_NAME)));

        setUpPackageLocaleConfig(null, DEFAULT_PACKAGE_NAME);

        setUpAppLocalesOptIn(true);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verify(mMockLocaleManagerService, times(1)).setApplicationLocales(DEFAULT_PACKAGE_NAME,

                DEFAULT_USER_ID, LocaleList.forLanguageTags(""), false);



        setUpPackageLocaleConfig(LocaleList.getEmptyLocaleList(), DEFAULT_PACKAGE_NAME);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verify(mMockLocaleManagerService, times(2)).setApplicationLocales(DEFAULT_PACKAGE_NAME,

                DEFAULT_USER_ID, LocaleList.forLanguageTags(""), false);



        setUpAppLocalesOptIn(false);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verify(mMockLocaleManagerService, times(3)).setApplicationLocales(DEFAULT_PACKAGE_NAME,

                DEFAULT_USER_ID, LocaleList.forLanguageTags(""), false);

    }



    @Test

    public void testPackageUpgraded_appLocalesNotInLocaleConfig_clearAppLocale() throws Exception {

        setUpLocalesForPackage(DEFAULT_PACKAGE_NAME, DEFAULT_LOCALES);

        setUpPackageNamesForSp(new ArraySet<>(Arrays.asList(DEFAULT_PACKAGE_NAME)));

        setUpPackageLocaleConfig(LocaleList.forLanguageTags("hi,fr"), DEFAULT_PACKAGE_NAME);

        setUpAppLocalesOptIn(true);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verify(mMockLocaleManagerService, times(1)).setApplicationLocales(DEFAULT_PACKAGE_NAME,

                DEFAULT_USER_ID, LocaleList.forLanguageTags(""), false);



        setUpAppLocalesOptIn(false);



        mAppUpdateTracker.onPackageUpdateFinished(DEFAULT_PACKAGE_NAME, DEFAULT_UID);

        verify(mMockLocaleManagerService, times(2)).setApplicationLocales(DEFAULT_PACKAGE_NAME,

                DEFAULT_USER_ID, LocaleList.forLanguageTags(""), false);

    }



    private void setUpLocalesForPackage(String packageName, LocaleList locales) throws Exception {

        doReturn(locales).when(mMockLocaleManagerService).getApplicationLocales(eq(packageName),

                anyInt());

    }



    private void setUpPackageNamesForSp(Set<String> packageNames) {

        SharedPreferences mockSharedPreference = mock(SharedPreferences.class);

        doReturn(mockSharedPreference).when(mMockBackupHelper).getPersistedInfo();

        doReturn(packageNames).when(mockSharedPreference).getStringSet(anyString(), any());

    }



    private void setUpPackageLocaleConfig(LocaleList locales, String packageName) {

        doReturn(locales).when(mAppUpdateTracker).getPackageLocales(eq(packageName), anyInt());

    }



    private void setUpAppLocalesOptIn(boolean optIn) {

        doReturn(optIn).when(mAppUpdateTracker).isSettingsAppLocalesOptIn();

    }



    /**

     * Verifies that no app locales needs to be cleared for any package.

     *

     * <p>If {@link LocaleManagerService#setApplicationLocales} is not invoked when receiving the

     * callback of package upgraded, we can conclude that no app locales needs to be cleared.

     */

    private void verifyNoLocalesCleared() throws Exception {

        verify(mMockLocaleManagerService, times(0)).setApplicationLocales(anyString(), anyInt(),

                any(), anyBoolean());

    }

}