1 /*
2  * Copyright (C) 2024 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.aconfigd;
18 
19 import java.util.Objects;
20 
21 /** @hide */
22 public class AconfigdFlagInfo {
23 
24     private String mPackageName;
25     private String mFlagName;
26     private String mServerFlagValue;
27     private String mLocalFlagValue;
28     private String mBootFlagValue;
29     private String mDefaultFlagValue;
30     private boolean mHasServerOverride;
31     private boolean mHasLocalOverride;
32     private boolean mIsReadWrite;
33 
AconfigdFlagInfo(Builder builder)34     AconfigdFlagInfo(Builder builder) {
35         mPackageName = builder.mPackageName;
36         mFlagName = builder.mFlagName;
37         mServerFlagValue = builder.mServerFlagValue;
38         mLocalFlagValue = builder.mLocalFlagValue;
39         mDefaultFlagValue = builder.mDefaultFlagValue;
40         mHasServerOverride = builder.mHasServerOverride;
41         mHasLocalOverride = builder.mHasLocalOverride;
42         mIsReadWrite = builder.mIsReadWrite;
43         mBootFlagValue = builder.mBootFlagValue;
44         if (mBootFlagValue == null) {
45             updateBootFlagValue();
46         }
47     }
48 
getFullFlagName()49     public String getFullFlagName() {
50         StringBuilder ret = new StringBuilder(mPackageName);
51         return ret.append('.').append(mFlagName).toString();
52     }
53 
getPackageName()54     public String getPackageName() {
55         return mPackageName;
56     }
57 
getFlagName()58     public String getFlagName() {
59         return mFlagName;
60     }
61 
getServerFlagValue()62     public String getServerFlagValue() {
63         return mServerFlagValue;
64     }
65 
getLocalFlagValue()66     public String getLocalFlagValue() {
67         return mLocalFlagValue;
68     }
69 
getBootFlagValue()70     public String getBootFlagValue() {
71         return mBootFlagValue;
72     }
73 
getDefaultFlagValue()74     public String getDefaultFlagValue() {
75         return mDefaultFlagValue;
76     }
77 
getHasServerOverride()78     public boolean getHasServerOverride() {
79         return mHasServerOverride;
80     }
81 
getHasLocalOverride()82     public boolean getHasLocalOverride() {
83         return mHasLocalOverride;
84     }
85 
getIsReadWrite()86     public boolean getIsReadWrite() {
87         return mIsReadWrite;
88     }
89 
setLocalFlagValue(String localFlagValue)90     public void setLocalFlagValue(String localFlagValue) {
91         if (!mIsReadWrite) {
92             return;
93         }
94         mLocalFlagValue = localFlagValue;
95         mHasLocalOverride = true;
96         updateBootFlagValue();
97     }
98 
setServerFlagValue(String serverFlagValue)99     public void setServerFlagValue(String serverFlagValue) {
100         if (!mIsReadWrite) {
101             return;
102         }
103         mServerFlagValue = serverFlagValue;
104         mHasServerOverride = true;
105         updateBootFlagValue();
106     }
107 
updateBootFlagValue()108     private void updateBootFlagValue() {
109         mBootFlagValue = mDefaultFlagValue == null ? mBootFlagValue : mDefaultFlagValue;
110         if (mIsReadWrite) {
111             mBootFlagValue = mServerFlagValue == null ? mBootFlagValue : mServerFlagValue;
112             mBootFlagValue = mLocalFlagValue == null ? mBootFlagValue : mLocalFlagValue;
113         }
114     }
115 
116     @Override
equals(Object obj)117     public boolean equals(Object obj) {
118         if (this == obj) {
119             return true;
120         }
121         if (obj == null || !(obj instanceof AconfigdFlagInfo)) {
122             return false;
123         }
124         AconfigdFlagInfo other = (AconfigdFlagInfo) obj;
125         return Objects.equals(mPackageName, other.mPackageName)
126                 && Objects.equals(mFlagName, other.mFlagName)
127                 && Objects.equals(mServerFlagValue, other.mServerFlagValue)
128                 && Objects.equals(mLocalFlagValue, other.mLocalFlagValue)
129                 && Objects.equals(mBootFlagValue, other.mBootFlagValue)
130                 && Objects.equals(mDefaultFlagValue, other.mDefaultFlagValue)
131                 && mHasServerOverride == other.mHasServerOverride
132                 && mHasLocalOverride == other.mHasLocalOverride
133                 && mIsReadWrite == other.mIsReadWrite;
134     }
135 
136     @Override
hashCode()137     public int hashCode() {
138         return Objects.hash(
139                 mPackageName,
140                 mFlagName,
141                 mServerFlagValue,
142                 mLocalFlagValue,
143                 mBootFlagValue,
144                 mDefaultFlagValue,
145                 mHasServerOverride,
146                 mHasLocalOverride,
147                 mIsReadWrite);
148     }
149 
dump()150     public String dump() {
151         return String.format(
152                 "packageName: %s, flagName: %s, serverFlagValue: %s, localFlagValue: %s,"
153                         + " bootFlagValue: %s, defaultFlagValue: %s, hasServerOverride: %s,"
154                         + " hasLocalOverride: %s, isReadWrite: %s",
155                 mPackageName,
156                 mFlagName,
157                 mServerFlagValue,
158                 mLocalFlagValue,
159                 mBootFlagValue,
160                 mDefaultFlagValue,
161                 mHasServerOverride,
162                 mHasLocalOverride,
163                 mIsReadWrite);
164     }
165 
dumpDiff(AconfigdFlagInfo other)166     public String dumpDiff(AconfigdFlagInfo other) {
167         StringBuilder ret = new StringBuilder();
168         if (!Objects.equals(mPackageName, other.mPackageName)) {
169             ret.append(String.format("packageName: %s -> %s\n", mPackageName, other.mPackageName));
170             return ret.toString();
171         }
172         if (!Objects.equals(mFlagName, other.mFlagName)) {
173             ret.append(String.format("flagName: %s -> %s\n", mFlagName, other.mFlagName));
174             return ret.toString();
175         }
176         if (!Objects.equals(mBootFlagValue, other.mBootFlagValue)) {
177             ret.append(
178                     String.format(
179                             "bootFlagValue: %s -> %s\n", mBootFlagValue, other.mBootFlagValue));
180         }
181         if (!Objects.equals(mDefaultFlagValue, other.mDefaultFlagValue)) {
182             ret.append(
183                     String.format(
184                             "defaultFlagValue: %s -> %s\n",
185                             mDefaultFlagValue, other.mDefaultFlagValue));
186         }
187         if (mIsReadWrite != other.mIsReadWrite) {
188             ret.append(String.format("isReadWrite: %s -> %s\n", mIsReadWrite, other.mIsReadWrite));
189         }
190         if (mIsReadWrite && other.mIsReadWrite) {
191             if (!Objects.equals(mServerFlagValue, other.mServerFlagValue)) {
192                 ret.append(
193                         String.format(
194                                 "serverFlagValue: %s -> %s\n",
195                                 mServerFlagValue, other.mServerFlagValue));
196             }
197             if (!Objects.equals(mLocalFlagValue, other.mLocalFlagValue)) {
198                 ret.append(
199                         String.format(
200                                 "localFlagValue: %s -> %s\n",
201                                 mLocalFlagValue, other.mLocalFlagValue));
202             }
203             if (mHasServerOverride != other.mHasServerOverride) {
204                 ret.append(
205                         String.format(
206                                 "hasServerOverride: %s -> %s\n",
207                                 mHasServerOverride, other.mHasServerOverride));
208             }
209             if (mHasLocalOverride != other.mHasLocalOverride) {
210                 ret.append(
211                         String.format(
212                                 "hasLocalOverride: %s -> %s\n",
213                                 mHasLocalOverride, other.mHasLocalOverride));
214             }
215         }
216         return ret.toString();
217     }
218 
newBuilder()219     public static Builder newBuilder() {
220         return new Builder();
221     }
222 
223     public static class Builder {
224         private String mPackageName;
225         private String mFlagName;
226         private String mServerFlagValue;
227         private String mLocalFlagValue;
228         private String mBootFlagValue;
229         private String mDefaultFlagValue;
230         private boolean mHasServerOverride;
231         private boolean mHasLocalOverride;
232         private boolean mIsReadWrite;
233 
setPackageName(String packageName)234         public Builder setPackageName(String packageName) {
235             mPackageName = packageName;
236             return this;
237         }
238 
setFlagName(String flagName)239         public Builder setFlagName(String flagName) {
240             mFlagName = flagName;
241             return this;
242         }
243 
setServerFlagValue(String serverFlagValue)244         public Builder setServerFlagValue(String serverFlagValue) {
245             mServerFlagValue = nullOrEmpty(serverFlagValue) ? null : serverFlagValue;
246             return this;
247         }
248 
setLocalFlagValue(String localFlagValue)249         public Builder setLocalFlagValue(String localFlagValue) {
250             mLocalFlagValue = nullOrEmpty(localFlagValue) ? null : localFlagValue;
251             return this;
252         }
253 
setBootFlagValue(String bootFlagValue)254         public Builder setBootFlagValue(String bootFlagValue) {
255             mBootFlagValue = nullOrEmpty(bootFlagValue) ? null : bootFlagValue;
256             return this;
257         }
258 
setDefaultFlagValue(String defaultFlagValue)259         public Builder setDefaultFlagValue(String defaultFlagValue) {
260             mDefaultFlagValue = nullOrEmpty(defaultFlagValue) ? null : defaultFlagValue;
261             return this;
262         }
263 
setHasServerOverride(boolean hasServerOverride)264         public Builder setHasServerOverride(boolean hasServerOverride) {
265             mHasServerOverride = hasServerOverride;
266             return this;
267         }
268 
setHasLocalOverride(boolean hasLocalOverride)269         public Builder setHasLocalOverride(boolean hasLocalOverride) {
270             mHasLocalOverride = hasLocalOverride;
271             return this;
272         }
273 
setIsReadWrite(boolean isReadWrite)274         public Builder setIsReadWrite(boolean isReadWrite) {
275             mIsReadWrite = isReadWrite;
276             return this;
277         }
278 
build()279         public AconfigdFlagInfo build() {
280             return new AconfigdFlagInfo(this);
281         }
282 
nullOrEmpty(String str)283         private boolean nullOrEmpty(String str) {
284             return str == null || str.isEmpty();
285         }
286     }
287 }
288