1daa1bb380
Bug: 388199937 Test: manual Flag: EXEMPT refactor Change-Id: I45ddbfb460365e3ff4858de0c0411c7a46d49302
278 lines
12 KiB
Java
278 lines
12 KiB
Java
/*
|
|
* Copyright (C) 2023 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.localepicker;
|
|
|
|
import static com.android.settings.flags.Flags.localeNotificationEnabled;
|
|
import static com.android.settings.localepicker.LocaleListEditor.EXTRA_RESULT_LOCALE;
|
|
import static com.android.settings.localepicker.RegionAndNumberingSystemPickerFragment.EXTRA_IS_NUMBERING_SYSTEM;
|
|
import static com.android.settings.localepicker.RegionAndNumberingSystemPickerFragment.EXTRA_TARGET_LOCALE;
|
|
|
|
import android.app.Dialog;
|
|
import android.app.LocaleManager;
|
|
import android.app.NotificationChannel;
|
|
import android.app.NotificationManager;
|
|
import android.app.PendingIntent;
|
|
import android.app.settings.SettingsEnums;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.pm.PackageManager;
|
|
import android.os.LocaleList;
|
|
import android.os.SystemClock;
|
|
import android.util.Log;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.core.app.NotificationCompat;
|
|
|
|
import com.android.internal.app.LocaleHelper;
|
|
import com.android.internal.app.LocaleStore;
|
|
import com.android.settings.R;
|
|
import com.android.settings.overlay.FeatureFactory;
|
|
import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
* A locale utility class.
|
|
*/
|
|
public class LocaleUtils {
|
|
private static final String TAG = "LocaleUtils";
|
|
private static final String CHANNEL_ID_SUGGESTION = "suggestion";
|
|
private static final String CHANNEL_ID_SUGGESTION_TO_USER = "Locale suggestion";
|
|
private static final String EXTRA_APP_LOCALE = "app_locale";
|
|
private static final String EXTRA_NOTIFICATION_ID = "notification_id";
|
|
private static final int SIM_LOCALE = 1 << 0;
|
|
private static final int SYSTEM_LOCALE = 1 << 1;
|
|
private static final int APP_LOCALE = 1 << 2;
|
|
private static final int IME_LOCALE = 1 << 3;
|
|
|
|
/**
|
|
* Checks if the languageTag is in the system locale. Since in the current design, the system
|
|
* language list would not show two locales with the same language and region but different
|
|
* numbering system. So, the u extension has to be stripped out in the process of comparison.
|
|
*
|
|
* @param languageTag A language tag
|
|
* @return true if the locale is in the system locale. Otherwise, false.
|
|
*/
|
|
public static boolean isInSystemLocale(@NonNull String languageTag) {
|
|
LocaleList systemLocales = LocaleList.getDefault();
|
|
Locale localeWithoutUextension =
|
|
new Locale.Builder()
|
|
.setLocale(Locale.forLanguageTag(languageTag))
|
|
.clearExtensions()
|
|
.build();
|
|
for (int i = 0; i < systemLocales.size(); i++) {
|
|
Locale sysLocaleWithoutUextension =
|
|
new Locale.Builder().setLocale(systemLocales.get(i)).clearExtensions().build();
|
|
if (localeWithoutUextension.equals(sysLocaleWithoutUextension)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Logs the locale, sets the default locale for the app then broadcasts it.
|
|
*
|
|
* @param context Context
|
|
* @param localeInfo locale info
|
|
*/
|
|
public static void onLocaleSelected(@NonNull Context context,
|
|
@NonNull LocaleStore.LocaleInfo localeInfo,
|
|
@NonNull String packageName) {
|
|
if (localeInfo.getLocale() == null || localeInfo.isSystemLocale()) {
|
|
setAppDefaultLocale(context, "", packageName);
|
|
} else {
|
|
logLocaleSource(context, localeInfo);
|
|
setAppDefaultLocale(context, localeInfo.getLocale().toLanguageTag(),
|
|
packageName);
|
|
broadcastAppLocaleChange(context, localeInfo, packageName);
|
|
}
|
|
}
|
|
|
|
private static void logLocaleSource(Context context, LocaleStore.LocaleInfo localeInfo) {
|
|
if (!localeInfo.isSuggested() || localeInfo.isAppCurrentLocale()) {
|
|
return;
|
|
}
|
|
|
|
int localeSource = 0;
|
|
if (hasSuggestionType(localeInfo,
|
|
LocaleStore.LocaleInfo.SUGGESTION_TYPE_SYSTEM_AVAILABLE_LANGUAGE)) {
|
|
localeSource |= SYSTEM_LOCALE;
|
|
}
|
|
if (hasSuggestionType(localeInfo,
|
|
LocaleStore.LocaleInfo.SUGGESTION_TYPE_OTHER_APP_LANGUAGE)) {
|
|
localeSource |= APP_LOCALE;
|
|
}
|
|
if (hasSuggestionType(localeInfo, LocaleStore.LocaleInfo.SUGGESTION_TYPE_IME_LANGUAGE)) {
|
|
localeSource |= IME_LOCALE;
|
|
}
|
|
if (hasSuggestionType(localeInfo, LocaleStore.LocaleInfo.SUGGESTION_TYPE_SIM)) {
|
|
localeSource |= SIM_LOCALE;
|
|
}
|
|
MetricsFeatureProvider metricsFeatureProvider =
|
|
FeatureFactory.getFeatureFactory().getMetricsFeatureProvider();
|
|
metricsFeatureProvider.action(context,
|
|
SettingsEnums.ACTION_CHANGE_APP_LANGUAGE_FROM_SUGGESTED, localeSource);
|
|
}
|
|
|
|
private static boolean hasSuggestionType(LocaleStore.LocaleInfo localeInfo,
|
|
int suggestionType) {
|
|
return localeInfo.isSuggestionOfType(suggestionType);
|
|
}
|
|
|
|
private static void setAppDefaultLocale(Context context, String languageTag,
|
|
String packageName) {
|
|
LocaleManager localeManager = context.getSystemService(LocaleManager.class);
|
|
if (localeManager == null) {
|
|
Log.w(TAG, "LocaleManager is null, cannot set default app locale");
|
|
return;
|
|
}
|
|
localeManager.setApplicationLocales(packageName,
|
|
LocaleList.forLanguageTags(languageTag));
|
|
}
|
|
|
|
private static void broadcastAppLocaleChange(Context context, LocaleStore.LocaleInfo localeInfo,
|
|
String packageName) {
|
|
if (!localeNotificationEnabled()) {
|
|
Log.w(TAG, "Locale notification is not enabled");
|
|
return;
|
|
}
|
|
if (localeInfo.isAppCurrentLocale()) {
|
|
return;
|
|
}
|
|
try {
|
|
NotificationController notificationController = NotificationController.getInstance(
|
|
context);
|
|
String localeTag = localeInfo.getLocale().toLanguageTag();
|
|
int uid = context.getPackageManager().getApplicationInfo(packageName,
|
|
PackageManager.GET_META_DATA).uid;
|
|
boolean launchNotification = notificationController.shouldTriggerNotification(
|
|
uid, localeTag);
|
|
if (launchNotification) {
|
|
triggerNotification(
|
|
context,
|
|
notificationController.getNotificationId(localeTag),
|
|
context.getString(R.string.title_system_locale_addition,
|
|
localeInfo.getFullNameNative()),
|
|
context.getString(R.string.desc_system_locale_addition),
|
|
localeTag);
|
|
MetricsFeatureProvider metricsFeatureProvider =
|
|
FeatureFactory.getFeatureFactory().getMetricsFeatureProvider();
|
|
metricsFeatureProvider.action(context,
|
|
SettingsEnums.ACTION_NOTIFICATION_FOR_SYSTEM_LOCALE);
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.e(TAG, "Unable to find info for package: " + packageName);
|
|
}
|
|
}
|
|
|
|
private static void triggerNotification(
|
|
Context context,
|
|
int notificationId,
|
|
String title,
|
|
String description,
|
|
String localeTag) {
|
|
NotificationManager notificationManager = context.getSystemService(
|
|
NotificationManager.class);
|
|
final boolean channelExist =
|
|
notificationManager.getNotificationChannel(CHANNEL_ID_SUGGESTION) != null;
|
|
|
|
// Create an alert channel if it does not exist
|
|
if (!channelExist) {
|
|
NotificationChannel channel =
|
|
new NotificationChannel(
|
|
CHANNEL_ID_SUGGESTION,
|
|
CHANNEL_ID_SUGGESTION_TO_USER,
|
|
NotificationManager.IMPORTANCE_DEFAULT);
|
|
channel.setSound(/* sound */ null, /* audioAttributes */ null); // silent notification
|
|
notificationManager.createNotificationChannel(channel);
|
|
}
|
|
final NotificationCompat.Builder builder =
|
|
new NotificationCompat.Builder(context, CHANNEL_ID_SUGGESTION)
|
|
.setSmallIcon(R.drawable.ic_settings_language)
|
|
.setAutoCancel(true)
|
|
.setContentTitle(title)
|
|
.setContentText(description)
|
|
.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
|
|
.setContentIntent(
|
|
createPendingIntent(context, localeTag, notificationId, false))
|
|
.setDeleteIntent(
|
|
createPendingIntent(context, localeTag, notificationId, true));
|
|
notificationManager.notify(notificationId, builder.build());
|
|
}
|
|
|
|
private static PendingIntent createPendingIntent(Context context, String locale,
|
|
int notificationId,
|
|
boolean isDeleteIntent) {
|
|
Intent intent = isDeleteIntent
|
|
? new Intent(context, NotificationCancelReceiver.class)
|
|
: new Intent(context, NotificationActionActivity.class)
|
|
.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
|
|
|
|
intent.putExtra(EXTRA_APP_LOCALE, locale)
|
|
.putExtra(EXTRA_NOTIFICATION_ID, notificationId);
|
|
int flag = PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT;
|
|
int elapsedTime = (int) SystemClock.elapsedRealtimeNanos();
|
|
|
|
return isDeleteIntent
|
|
? PendingIntent.getBroadcast(context, elapsedTime, intent, flag)
|
|
: PendingIntent.getActivity(context, elapsedTime, intent, flag);
|
|
}
|
|
|
|
/**
|
|
* Sort the locale's list.
|
|
*
|
|
* @param localeInfos list of locale Infos
|
|
* @param isCountryMode Whether the locale page is in country mode or not.
|
|
* @return localeInfos list of locale Infos
|
|
*/
|
|
public static @NonNull List<LocaleStore.LocaleInfo> getSortedLocaleList(
|
|
@NonNull List<LocaleStore.LocaleInfo> localeInfos, boolean isCountryMode) {
|
|
final Locale sortingLocale = Locale.getDefault();
|
|
final LocaleHelper.LocaleInfoComparator comp = new LocaleHelper.LocaleInfoComparator(
|
|
sortingLocale, isCountryMode);
|
|
Collections.sort(localeInfos, comp);
|
|
return localeInfos;
|
|
}
|
|
|
|
/**
|
|
* Sort the locale's list by keywords in search.
|
|
*
|
|
* @param searchList locale Infos in search bar
|
|
* @param localeList list of locale Infos
|
|
* @param isCountryMode Whether the locale page is in country mode or not.
|
|
* @return localeInfos list of locale Infos
|
|
*/
|
|
public static @NonNull List<LocaleStore.LocaleInfo> getSortedLocaleFromSearchList(
|
|
@NonNull List<LocaleStore.LocaleInfo> searchList,
|
|
@NonNull List<LocaleStore.LocaleInfo> localeList,
|
|
boolean isCountryMode) {
|
|
List<LocaleStore.LocaleInfo> searchItem = localeList.stream()
|
|
.filter(suggested -> searchList.stream()
|
|
.anyMatch(option -> option.getLocale() != null
|
|
&& option.getLocale().getLanguage().equals(
|
|
suggested.getLocale().getLanguage())))
|
|
.distinct()
|
|
.collect(Collectors.toList());
|
|
return getSortedLocaleList(searchItem, isCountryMode);
|
|
}
|
|
}
|