1 /* 2 * Copyright (C) 2021 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.systemui.accessibility; 18 19 import android.content.ContentResolver; 20 import android.content.Context; 21 import android.database.ContentObserver; 22 import android.os.Handler; 23 import android.os.Looper; 24 import android.os.UserHandle; 25 import android.provider.Settings; 26 27 import androidx.annotation.NonNull; 28 29 import com.android.internal.annotations.VisibleForTesting; 30 import com.android.systemui.settings.UserTracker; 31 import com.android.systemui.util.settings.SecureSettings; 32 33 import java.util.ArrayList; 34 import java.util.List; 35 import java.util.Objects; 36 37 /** 38 * Provides basic methods for adding, removing arbitrary listeners and inquiry given {@code 39 * secureSettingsKey} value; it must comes from {@link Settings.Secure}. 40 * 41 * This abstract class is intended to be subclassed and specialized to maintain 42 * a registry of listeners of specific types and dispatch changes to them. 43 * 44 * @param <T> The listener type 45 */ 46 public abstract class SecureSettingsContentObserver<T> { 47 48 private final ContentResolver mContentResolver; 49 private final UserTracker mUserTracker; 50 @VisibleForTesting 51 final ContentObserver mContentObserver; 52 private final SecureSettings mSecureSettings; 53 54 private final String mKey; 55 56 @VisibleForTesting 57 final List<T> mListeners = new ArrayList<>(); 58 SecureSettingsContentObserver(Context context, UserTracker userTracker, SecureSettings secureSettings, String secureSettingsKey)59 protected SecureSettingsContentObserver(Context context, UserTracker userTracker, 60 SecureSettings secureSettings, String secureSettingsKey) { 61 mKey = secureSettingsKey; 62 mContentResolver = context.getContentResolver(); 63 mUserTracker = userTracker; 64 mContentObserver = new ContentObserver(new Handler(Looper.getMainLooper())) { 65 @Override 66 public void onChange(boolean selfChange) { 67 updateValueChanged(); 68 } 69 }; 70 mSecureSettings = secureSettings; 71 } 72 73 /** 74 * Registers a listener to receive updates from given settings key {@code secureSettingsKey}. 75 * 76 * @param listener A listener to be added to receive the changes 77 */ addListener(@onNull T listener)78 public void addListener(@NonNull T listener) { 79 Objects.requireNonNull(listener, "listener must be non-null"); 80 81 if (!mListeners.contains(listener)) { 82 mListeners.add(listener); 83 } 84 85 if (mListeners.size() == 1) { 86 mSecureSettings.registerContentObserverForUserAsync(Settings.Secure.getUriFor(mKey), 87 /* notifyForDescendants= */ false, mContentObserver, UserHandle.USER_ALL); 88 } 89 } 90 91 /** 92 * Unregisters a listener previously registered with {@link #addListener(T listener)}. 93 * 94 * @param listener A listener to be removed from receiving the changes 95 */ removeListener(@onNull T listener)96 public void removeListener(@NonNull T listener) { 97 Objects.requireNonNull(listener, "listener must be non-null"); 98 99 mListeners.remove(listener); 100 101 if (mListeners.isEmpty()) { 102 mSecureSettings.unregisterContentObserverAsync(mContentObserver); 103 } 104 } 105 106 /** 107 * Gets the value from the current user's secure settings. 108 * 109 * See {@link Settings.Secure}. 110 */ getSettingsValue()111 public final String getSettingsValue() { 112 return Settings.Secure.getStringForUser(mContentResolver, mKey, mUserTracker.getUserId()); 113 } 114 updateValueChanged()115 private void updateValueChanged() { 116 final String value = getSettingsValue(); 117 final int listenerSize = mListeners.size(); 118 for (int i = 0; i < listenerSize; i++) { 119 onValueChanged(mListeners.get(i), value); 120 } 121 } 122 123 /** 124 * Called when the registered value from {@code secureSettingsKey} changes. 125 * 126 * @param listener A listener could be used to receive the updates 127 * @param value Content changed value from {@code secureSettingsKey} 128 */ onValueChanged(T listener, String value)129 abstract void onValueChanged(T listener, String value); 130 } 131