1 /* 2 * Copyright (C) 2023 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 android.provider; 18 19 import android.annotation.NonNull; 20 import android.annotation.Nullable; 21 import android.content.ContentResolver; 22 import android.database.ContentObserver; 23 import android.os.IBinder; 24 import android.provider.aidl.IDeviceConfigManager; 25 import android.util.Slog; 26 27 import java.util.Arrays; 28 import java.util.HashMap; 29 import java.util.concurrent.Executor; 30 31 /** 32 * @hide 33 */ 34 public class DeviceConfigServiceDataStore /*implements DeviceConfigDataStore*/ { 35 36 private static final boolean DEBUG = false; 37 private static final String TAG = "DeviceConfigServiceDataStore"; 38 private static final Object mLock = new Object(); 39 40 // TODO(b/265948914): finish implementation of this data store and make it actually implement 41 // the interface 42 private DeviceConfigManager mManager; 43 DeviceConfigServiceDataStore()44 public DeviceConfigServiceDataStore() { 45 46 } 47 DeviceConfigServiceDataStore(DeviceConfigManager deviceConfigManager)48 public DeviceConfigServiceDataStore(DeviceConfigManager deviceConfigManager) { 49 mManager = deviceConfigManager; 50 } 51 createManagerIfNeeded()52 private @Nullable DeviceConfigManager createManagerIfNeeded() { 53 if (mManager != null) { 54 return mManager; 55 } 56 synchronized (mLock) { 57 if (mManager != null) { 58 return mManager; 59 } 60 61 IBinder binder = DeviceConfigInitializer.getDeviceConfigServiceManager() 62 .getDeviceConfigUpdatableServiceRegisterer() 63 .get(); 64 65 if (binder != null) { 66 IDeviceConfigManager manager = IDeviceConfigManager.Stub.asInterface( 67 binder); 68 mManager = new DeviceConfigManager(manager); 69 } 70 return mManager; 71 } 72 } 73 74 // @Override 75 @NonNull getProperties(@onNull String namespace, @NonNull String... names)76 public DeviceConfig.Properties getProperties(@NonNull String namespace, 77 @NonNull String... names) { 78 createManagerIfNeeded(); 79 80 if (mManager == null) { 81 if(DEBUG) { 82 Slog.d(TAG, "ServiceDS - getProperties before ready " + namespace + " " 83 + Arrays.toString(names)); 84 } 85 return new DeviceConfig.Properties(namespace, new HashMap<>()); 86 } 87 return mManager.getProperties(namespace, names); 88 } 89 90 // @Override setProperties(@onNull DeviceConfig.Properties properties)91 public boolean setProperties(@NonNull DeviceConfig.Properties properties) 92 throws DeviceConfig.BadConfigException { 93 createManagerIfNeeded(); 94 if (mManager == null) { 95 if(DEBUG) { 96 Slog.d(TAG, "ServiceDS - setProperties before ready " + properties.getNamespace() + " " + properties); 97 } 98 return false; 99 } 100 return mManager.setProperties(properties.getNamespace(), properties.getPropertyValues()); 101 } 102 // 103 // @Override setProperty(@onNull String namespace, @NonNull String name, @Nullable String value, boolean makeDefault)104 public boolean setProperty(@NonNull String namespace, @NonNull String name, 105 @Nullable String value, boolean makeDefault) { 106 createManagerIfNeeded(); 107 if (mManager == null) { 108 if (DEBUG) { 109 Slog.d(TAG, "ServiceDS - setProperty before ready " + namespace + " " + name); 110 } 111 return false; 112 } 113 return mManager.setProperty(namespace, name, value, makeDefault); 114 } 115 // 116 // @Override deleteProperty(@onNull String namespace, @NonNull String name)117 public boolean deleteProperty(@NonNull String namespace, @NonNull String name) { 118 createManagerIfNeeded(); 119 if (mManager == null) { 120 if (DEBUG) { 121 Slog.d(TAG, "ServiceDS - setProperty before ready " + namespace + " " + name); 122 } 123 return false; 124 } 125 return mManager.deleteProperty(namespace, name); 126 } 127 // 128 // @Override resetToDefaults(int resetMode, @Nullable String namespace)129 public void resetToDefaults(int resetMode, @Nullable String namespace) { 130 // mManager.resetToDefaults(resetMode, namespace); 131 } 132 // 133 // @Override setSyncDisabledMode(int syncDisabledMode)134 public void setSyncDisabledMode(int syncDisabledMode) { 135 // mManager.setSyncDisabledMode(syncDisabledMode); 136 } 137 // 138 // @Override getSyncDisabledMode()139 public int getSyncDisabledMode() { 140 // return mManager.getSyncDisabledMode(); 141 return 0; 142 } 143 // 144 // @Override setMonitorCallback(@onNull ContentResolver resolver, @NonNull Executor executor, @NonNull DeviceConfig.MonitorCallback callback)145 public void setMonitorCallback(@NonNull ContentResolver resolver, @NonNull Executor executor, 146 @NonNull DeviceConfig.MonitorCallback callback) { 147 // mManager.setMonitorCallback(resolver, executor, callback); 148 } 149 // 150 // @Override clearMonitorCallback(@onNull ContentResolver resolver)151 public void clearMonitorCallback(@NonNull ContentResolver resolver) { 152 // mManager.clearMonitorCallback(resolver); 153 } 154 // 155 // @Override registerContentObserver(@onNull String namespace, boolean notifyForDescendants, ContentObserver contentObserver)156 public void registerContentObserver(@NonNull String namespace, boolean notifyForDescendants, 157 ContentObserver contentObserver) { 158 // mManager.registerContentObserver(namespace, notifyForescendants, contentObserver); 159 } 160 // 161 // @Override unregisterContentObserver(@onNull ContentObserver contentObserver)162 public void unregisterContentObserver(@NonNull ContentObserver contentObserver) { 163 // mManager.unregisterContentObserver(contentObserver); 164 } 165 } 166