• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022 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.car.os;
18 
19 import android.annotation.SuppressLint;
20 import android.car.annotation.AddedInOrBefore;
21 import android.car.annotation.ExperimentalFeature;
22 import android.os.Parcelable;
23 
24 import com.android.car.internal.util.DataClass;
25 
26 /**
27  * CPU availability monitoring config.
28  *
29  * @hide
30  */
31 @ExperimentalFeature
32 @DataClass(genToString = true, genBuilder = true, genHiddenConstDefs = true)
33 public final class CpuAvailabilityMonitoringConfig implements Parcelable {
34     /** Constant to monitor all cpusets. */
35     @Cpuset
36     @AddedInOrBefore(majorVersion = 33)
37     public static final int CPUSET_ALL = 1;
38 
39     /** Constant to monitor only background cpusets. */
40     @Cpuset
41     @AddedInOrBefore(majorVersion = 33)
42     public static final int CPUSET_BACKGROUND = 2;
43 
44     /** Constant to ignore the CPU availability lower bound percent. */
45     @IgnorePercent
46     @AddedInOrBefore(majorVersion = 33)
47     public static final int IGNORE_PERCENT_LOWER_BOUND = 0;
48 
49     /** Constant to ignore the CPU availability upper bound percent. */
50     @IgnorePercent
51     @AddedInOrBefore(majorVersion = 33)
52     public static final int IGNORE_PERCENT_UPPER_BOUND = 100;
53 
54     /** Constant to avoid timing out when monitoring CPU availability. */
55     @AddedInOrBefore(majorVersion = 33)
56     public static final int MONITORING_TIMEOUT_NEVER = -1;
57 
58     /**
59      * Constant to notify the listener on timeout.
60      *
61      * <p>When the timeout action is notification, the timeout resets on each notification and the
62      * listener is again on the next timeout. This repeats until the listener is explicitly removed.
63      */
64     @TimeoutAction
65     @AddedInOrBefore(majorVersion = 33)
66     public static final int TIMEOUT_ACTION_NOTIFICATION = 1;
67 
68     /** Constant to remove the listener on timeout. */
69     @TimeoutAction
70     @AddedInOrBefore(majorVersion = 33)
71     public static final int TIMEOUT_ACTION_REMOVE = 2;
72 
73     /**
74      * CPUSETs to monitor.
75      */
76     private @Cpuset int mCpuset = CPUSET_ALL;
77 
78     /**
79      * CPU availability lower bound percent.
80      *
81      * <p>CPU availability change notifications are sent when the CPU availability reaches or
82      * decreases below this value. The value of this field must be less than the value of
83      * {@link #mUpperBoundPercent}.
84      *
85      * <p>To avoid spurious or very frequent notifications, the delta between the upper bound
86      * percent and lower bound percent must be reasonably large.
87      *
88      * <p>To ignore this field, specify {@link #IGNORE_PERCENT_LOWER_BOUND} as the value.
89      * Must not ignore both this field and {@link #mUpperBoundPercent} in the same configuration.
90      */
91     private int mLowerBoundPercent;
92 
93     /**
94      * CPU availability upper bound percent.
95      *
96      * <p>CPU availability change notifications are sent when the CPU availability reaches or
97      * increases above this value. The value of this field must be greater than the value of
98      * {@link #mLowerBoundPercent}.
99      *
100      * <p>To avoid spurious or very frequent notifications, the delta between the upper bound
101      * percent and lower bound percent must be reasonably large.
102      *
103      * <p>To ignore this field, specify {@link #IGNORE_PERCENT_UPPER_BOUND} as the value.
104      * Must not ignore both this field and {@link #mLowerBoundPercent} in the same configuration.
105      */
106     private int mUpperBoundPercent;
107 
108     /**
109      * CPU availability monitoring timeout in seconds.
110      *
111      * <p>To avoid timing out, specify {@link #MONITORING_TIMEOUT_NEVER} as the value.
112      */
113     @SuppressLint({"MethodNameUnits"})
114     private long mTimeoutInSeconds;
115 
116     /**
117      * Action to take on timeout. Specify one of the {@code TIMEOUT_ACTION_*} constants.
118      *
119      * <p>When the value of {@link #mTimeoutInSeconds} is {@link #MONITORING_TIMEOUT_NEVER},
120      * this field is ignored.
121      */
122     private @TimeoutAction int mTimeoutAction = TIMEOUT_ACTION_NOTIFICATION;
123 
124 
125 
126     // Code below generated by codegen v1.0.23.
127     //
128     // DO NOT MODIFY!
129     // CHECKSTYLE:OFF Generated code
130     //
131     // To regenerate run:
132     // $ codegen $ANDROID_BUILD_TOP/packages/services/Car/car-lib/src/android/car/os/CpuAvailabilityMonitoringConfig.java
133     //
134     // To exclude the generated code from IntelliJ auto-formatting enable (one-time):
135     //   Settings > Editor > Code Style > Formatter Control
136     //@formatter:off
137 
138 
139     /** @hide */
140     @android.annotation.IntDef(prefix = "CPUSET_", value = {
141         CPUSET_ALL,
142         CPUSET_BACKGROUND
143     })
144     @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)
145     @DataClass.Generated.Member
146     public @interface Cpuset {}
147 
148     /** @hide */
149     @DataClass.Generated.Member
150     @AddedInOrBefore(majorVersion = 33)
cpusetToString(@puset int value)151     public static String cpusetToString(@Cpuset int value) {
152         switch (value) {
153             case CPUSET_ALL:
154                     return "CPUSET_ALL";
155             case CPUSET_BACKGROUND:
156                     return "CPUSET_BACKGROUND";
157             default: return Integer.toHexString(value);
158         }
159     }
160 
161     /** @hide */
162     @android.annotation.IntDef(prefix = "IGNORE_PERCENT_", value = {
163         IGNORE_PERCENT_LOWER_BOUND,
164         IGNORE_PERCENT_UPPER_BOUND
165     })
166     @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)
167     @DataClass.Generated.Member
168     public @interface IgnorePercent {}
169 
170     /** @hide */
171     @DataClass.Generated.Member
172     @AddedInOrBefore(majorVersion = 33)
ignorePercentToString(@gnorePercent int value)173     public static String ignorePercentToString(@IgnorePercent int value) {
174         switch (value) {
175             case IGNORE_PERCENT_LOWER_BOUND:
176                     return "IGNORE_PERCENT_LOWER_BOUND";
177             case IGNORE_PERCENT_UPPER_BOUND:
178                     return "IGNORE_PERCENT_UPPER_BOUND";
179             default: return Integer.toHexString(value);
180         }
181     }
182 
183     /** @hide */
184     @android.annotation.IntDef(prefix = "TIMEOUT_ACTION_", value = {
185         TIMEOUT_ACTION_NOTIFICATION,
186         TIMEOUT_ACTION_REMOVE
187     })
188     @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)
189     @DataClass.Generated.Member
190     public @interface TimeoutAction {}
191 
192     /** @hide */
193     @DataClass.Generated.Member
194     @AddedInOrBefore(majorVersion = 33)
timeoutActionToString(@imeoutAction int value)195     public static String timeoutActionToString(@TimeoutAction int value) {
196         switch (value) {
197             case TIMEOUT_ACTION_NOTIFICATION:
198                     return "TIMEOUT_ACTION_NOTIFICATION";
199             case TIMEOUT_ACTION_REMOVE:
200                     return "TIMEOUT_ACTION_REMOVE";
201             default: return Integer.toHexString(value);
202         }
203     }
204 
205     @DataClass.Generated.Member
CpuAvailabilityMonitoringConfig( @puset int cpuset, int lowerBoundPercent, int upperBoundPercent, @SuppressLint({ "MethodNameUnits" }) long timeoutInSeconds, @TimeoutAction int timeoutAction)206     /* package-private */ CpuAvailabilityMonitoringConfig(
207             @Cpuset int cpuset,
208             int lowerBoundPercent,
209             int upperBoundPercent,
210             @SuppressLint({ "MethodNameUnits" }) long timeoutInSeconds,
211             @TimeoutAction int timeoutAction) {
212         this.mCpuset = cpuset;
213 
214         if (!(mCpuset == CPUSET_ALL)
215                 && !(mCpuset == CPUSET_BACKGROUND)) {
216             throw new java.lang.IllegalArgumentException(
217                     "cpuset was " + mCpuset + " but must be one of: "
218                             + "CPUSET_ALL(" + CPUSET_ALL + "), "
219                             + "CPUSET_BACKGROUND(" + CPUSET_BACKGROUND + ")");
220         }
221 
222         this.mLowerBoundPercent = lowerBoundPercent;
223         this.mUpperBoundPercent = upperBoundPercent;
224         this.mTimeoutInSeconds = timeoutInSeconds;
225         this.mTimeoutAction = timeoutAction;
226 
227         if (!(mTimeoutAction == TIMEOUT_ACTION_NOTIFICATION)
228                 && !(mTimeoutAction == TIMEOUT_ACTION_REMOVE)) {
229             throw new java.lang.IllegalArgumentException(
230                     "timeoutAction was " + mTimeoutAction + " but must be one of: "
231                             + "TIMEOUT_ACTION_NOTIFICATION(" + TIMEOUT_ACTION_NOTIFICATION + "), "
232                             + "TIMEOUT_ACTION_REMOVE(" + TIMEOUT_ACTION_REMOVE + ")");
233         }
234 
235 
236         // onConstructed(); // You can define this method to get a callback
237     }
238 
239     /**
240      * CPUSETs to monitor.
241      */
242     @DataClass.Generated.Member
243     @AddedInOrBefore(majorVersion = 33)
getCpuset()244     public @Cpuset int getCpuset() {
245         return mCpuset;
246     }
247 
248     /**
249      * CPU availability lower bound percent.
250      *
251      * <p>CPU availability change notifications are sent when the CPU availability reaches or
252      * decreases below this value. The value of this field must be less than the value of
253      * {@link #mUpperBoundPercent}.
254      *
255      * <p>To avoid spurious or very frequent notifications, the delta between the upper bound
256      * percent and lower bound percent must be reasonably large.
257      *
258      * <p>To ignore this field, specify {@link #IGNORE_PERCENT_LOWER_BOUND} as the value.
259      * Must not ignore both this field and {@link #mUpperBoundPercent} in the same configuration.
260      */
261     @DataClass.Generated.Member
262     @AddedInOrBefore(majorVersion = 33)
getLowerBoundPercent()263     public int getLowerBoundPercent() {
264         return mLowerBoundPercent;
265     }
266 
267     /**
268      * CPU availability upper bound percent.
269      *
270      * <p>CPU availability change notifications are sent when the CPU availability reaches or
271      * increases above this value. The value of this field must be greater than the value of
272      * {@link #mLowerBoundPercent}.
273      *
274      * <p>To avoid spurious or very frequent notifications, the delta between the upper bound
275      * percent and lower bound percent must be reasonably large.
276      *
277      * <p>To ignore this field, specify {@link #IGNORE_PERCENT_UPPER_BOUND} as the value.
278      * Must not ignore both this field and {@link #mLowerBoundPercent} in the same configuration.
279      */
280     @DataClass.Generated.Member
281     @AddedInOrBefore(majorVersion = 33)
getUpperBoundPercent()282     public int getUpperBoundPercent() {
283         return mUpperBoundPercent;
284     }
285 
286     /**
287      * CPU availability monitoring timeout in seconds.
288      *
289      * <p>To avoid timing out, specify {@link #MONITORING_TIMEOUT_NEVER} as the value.
290      */
291     @DataClass.Generated.Member
292     @AddedInOrBefore(majorVersion = 33)
getTimeoutInSeconds()293     public @SuppressLint({ "MethodNameUnits" }) long getTimeoutInSeconds() {
294         return mTimeoutInSeconds;
295     }
296 
297     /**
298      * Action to take on timeout. Specify one of the {@code TIMEOUT_ACTION_*} constants.
299      *
300      * <p>When the value of {@link #mTimeoutInSeconds} is {@link #MONITORING_TIMEOUT_NEVER},
301      * this field is ignored.
302      */
303     @DataClass.Generated.Member
304     @AddedInOrBefore(majorVersion = 33)
getTimeoutAction()305     public @TimeoutAction int getTimeoutAction() {
306         return mTimeoutAction;
307     }
308 
309     @Override
310     @DataClass.Generated.Member
toString()311     public String toString() {
312         // You can override field toString logic by defining methods like:
313         // String fieldNameToString() { ... }
314 
315         return "CpuAvailabilityMonitoringConfig { " +
316                 "cpuset = " + cpusetToString(mCpuset) + ", " +
317                 "lowerBoundPercent = " + mLowerBoundPercent + ", " +
318                 "upperBoundPercent = " + mUpperBoundPercent + ", " +
319                 "timeoutInSeconds = " + mTimeoutInSeconds + ", " +
320                 "timeoutAction = " + timeoutActionToString(mTimeoutAction) +
321         " }";
322     }
323 
324     @Override
325     @DataClass.Generated.Member
326     @AddedInOrBefore(majorVersion = 33)
writeToParcel(@ndroid.annotation.NonNull android.os.Parcel dest, int flags)327     public void writeToParcel(@android.annotation.NonNull android.os.Parcel dest, int flags) {
328         // You can override field parcelling by defining methods like:
329         // void parcelFieldName(Parcel dest, int flags) { ... }
330 
331         dest.writeInt(mCpuset);
332         dest.writeInt(mLowerBoundPercent);
333         dest.writeInt(mUpperBoundPercent);
334         dest.writeLong(mTimeoutInSeconds);
335         dest.writeInt(mTimeoutAction);
336     }
337 
338     @Override
339     @DataClass.Generated.Member
340     @AddedInOrBefore(majorVersion = 33)
describeContents()341     public int describeContents() { return 0; }
342 
343     /** @hide */
344     @SuppressWarnings({"unchecked", "RedundantCast"})
345     @DataClass.Generated.Member
CpuAvailabilityMonitoringConfig(@ndroid.annotation.NonNull android.os.Parcel in)346     /* package-private */ CpuAvailabilityMonitoringConfig(@android.annotation.NonNull android.os.Parcel in) {
347         // You can override field unparcelling by defining methods like:
348         // static FieldType unparcelFieldName(Parcel in) { ... }
349 
350         int cpuset = in.readInt();
351         int lowerBoundPercent = in.readInt();
352         int upperBoundPercent = in.readInt();
353         long timeoutInSeconds = in.readLong();
354         int timeoutAction = in.readInt();
355 
356         this.mCpuset = cpuset;
357 
358         if (!(mCpuset == CPUSET_ALL)
359                 && !(mCpuset == CPUSET_BACKGROUND)) {
360             throw new java.lang.IllegalArgumentException(
361                     "cpuset was " + mCpuset + " but must be one of: "
362                             + "CPUSET_ALL(" + CPUSET_ALL + "), "
363                             + "CPUSET_BACKGROUND(" + CPUSET_BACKGROUND + ")");
364         }
365 
366         this.mLowerBoundPercent = lowerBoundPercent;
367         this.mUpperBoundPercent = upperBoundPercent;
368         this.mTimeoutInSeconds = timeoutInSeconds;
369         this.mTimeoutAction = timeoutAction;
370 
371         if (!(mTimeoutAction == TIMEOUT_ACTION_NOTIFICATION)
372                 && !(mTimeoutAction == TIMEOUT_ACTION_REMOVE)) {
373             throw new java.lang.IllegalArgumentException(
374                     "timeoutAction was " + mTimeoutAction + " but must be one of: "
375                             + "TIMEOUT_ACTION_NOTIFICATION(" + TIMEOUT_ACTION_NOTIFICATION + "), "
376                             + "TIMEOUT_ACTION_REMOVE(" + TIMEOUT_ACTION_REMOVE + ")");
377         }
378 
379 
380         // onConstructed(); // You can define this method to get a callback
381     }
382 
383     @DataClass.Generated.Member
384     @AddedInOrBefore(majorVersion = 33)
385     public static final @android.annotation.NonNull Parcelable.Creator<CpuAvailabilityMonitoringConfig> CREATOR
386             = new Parcelable.Creator<CpuAvailabilityMonitoringConfig>() {
387         @Override
388         public CpuAvailabilityMonitoringConfig[] newArray(int size) {
389             return new CpuAvailabilityMonitoringConfig[size];
390         }
391 
392         @Override
393         public CpuAvailabilityMonitoringConfig createFromParcel(@android.annotation.NonNull android.os.Parcel in) {
394             return new CpuAvailabilityMonitoringConfig(in);
395         }
396     };
397 
398     /**
399      * A builder for {@link CpuAvailabilityMonitoringConfig}
400      */
401     @SuppressWarnings("WeakerAccess")
402     @DataClass.Generated.Member
403     public static final class Builder {
404 
405         private @Cpuset int mCpuset;
406         private int mLowerBoundPercent;
407         private int mUpperBoundPercent;
408         private @SuppressLint({ "MethodNameUnits" }) long mTimeoutInSeconds;
409         private @TimeoutAction int mTimeoutAction;
410 
411         private long mBuilderFieldsSet = 0L;
412 
413         /**
414          * Creates a new Builder.
415          *
416          * @param lowerBoundPercent
417          *   CPU availability lower bound percent.
418          *
419          *   <p>CPU availability change notifications are sent when the CPU availability reaches or
420          *   decreases below this value. The value of this field must be less than the value of
421          *   {@link #mUpperBoundPercent}.
422          *
423          *   <p>To avoid spurious or very frequent notifications, the delta between the upper bound
424          *   percent and lower bound percent must be reasonably large.
425          *
426          *   <p>To ignore this field, specify {@link #IGNORE_PERCENT_LOWER_BOUND} as the value.
427          *   Must not ignore both this field and {@link #mUpperBoundPercent} in the same configuration.
428          * @param upperBoundPercent
429          *   CPU availability upper bound percent.
430          *
431          *   <p>CPU availability change notifications are sent when the CPU availability reaches or
432          *   increases above this value. The value of this field must be greater than the value of
433          *   {@link #mLowerBoundPercent}.
434          *
435          *   <p>To avoid spurious or very frequent notifications, the delta between the upper bound
436          *   percent and lower bound percent must be reasonably large.
437          *
438          *   <p>To ignore this field, specify {@link #IGNORE_PERCENT_UPPER_BOUND} as the value.
439          *   Must not ignore both this field and {@link #mLowerBoundPercent} in the same configuration.
440          * @param timeoutInSeconds
441          *   CPU availability monitoring timeout in seconds.
442          *
443          *   <p>To avoid timing out, specify {@link #MONITORING_TIMEOUT_NEVER} as the value.
444          */
Builder( int lowerBoundPercent, int upperBoundPercent, @SuppressLint({ "MethodNameUnits" }) long timeoutInSeconds)445         public Builder(
446                 int lowerBoundPercent,
447                 int upperBoundPercent,
448                 @SuppressLint({ "MethodNameUnits" }) long timeoutInSeconds) {
449             mLowerBoundPercent = lowerBoundPercent;
450             mUpperBoundPercent = upperBoundPercent;
451             mTimeoutInSeconds = timeoutInSeconds;
452         }
453 
454         /**
455          * CPUSETs to monitor.
456          */
457         @DataClass.Generated.Member
458         @AddedInOrBefore(majorVersion = 33)
setCpuset(@puset int value)459         public @android.annotation.NonNull Builder setCpuset(@Cpuset int value) {
460             checkNotUsed();
461             mBuilderFieldsSet |= 0x1;
462             mCpuset = value;
463             return this;
464         }
465 
466         /**
467          * CPU availability lower bound percent.
468          *
469          * <p>CPU availability change notifications are sent when the CPU availability reaches or
470          * decreases below this value. The value of this field must be less than the value of
471          * {@link #mUpperBoundPercent}.
472          *
473          * <p>To avoid spurious or very frequent notifications, the delta between the upper bound
474          * percent and lower bound percent must be reasonably large.
475          *
476          * <p>To ignore this field, specify {@link #IGNORE_PERCENT_LOWER_BOUND} as the value.
477          * Must not ignore both this field and {@link #mUpperBoundPercent} in the same configuration.
478          */
479         @DataClass.Generated.Member
480         @AddedInOrBefore(majorVersion = 33)
setLowerBoundPercent(int value)481         public @android.annotation.NonNull Builder setLowerBoundPercent(int value) {
482             checkNotUsed();
483             mBuilderFieldsSet |= 0x2;
484             mLowerBoundPercent = value;
485             return this;
486         }
487 
488         /**
489          * CPU availability upper bound percent.
490          *
491          * <p>CPU availability change notifications are sent when the CPU availability reaches or
492          * increases above this value. The value of this field must be greater than the value of
493          * {@link #mLowerBoundPercent}.
494          *
495          * <p>To avoid spurious or very frequent notifications, the delta between the upper bound
496          * percent and lower bound percent must be reasonably large.
497          *
498          * <p>To ignore this field, specify {@link #IGNORE_PERCENT_UPPER_BOUND} as the value.
499          * Must not ignore both this field and {@link #mLowerBoundPercent} in the same configuration.
500          */
501         @DataClass.Generated.Member
502         @AddedInOrBefore(majorVersion = 33)
setUpperBoundPercent(int value)503         public @android.annotation.NonNull Builder setUpperBoundPercent(int value) {
504             checkNotUsed();
505             mBuilderFieldsSet |= 0x4;
506             mUpperBoundPercent = value;
507             return this;
508         }
509 
510         /**
511          * CPU availability monitoring timeout in seconds.
512          *
513          * <p>To avoid timing out, specify {@link #MONITORING_TIMEOUT_NEVER} as the value.
514          */
515         @DataClass.Generated.Member
516         @AddedInOrBefore(majorVersion = 33)
setTimeoutInSeconds(@uppressLint{ "MethodNameUnits" }) long value)517         public @android.annotation.NonNull Builder setTimeoutInSeconds(@SuppressLint({ "MethodNameUnits" }) long value) {
518             checkNotUsed();
519             mBuilderFieldsSet |= 0x8;
520             mTimeoutInSeconds = value;
521             return this;
522         }
523 
524         /**
525          * Action to take on timeout. Specify one of the {@code TIMEOUT_ACTION_*} constants.
526          *
527          * <p>When the value of {@link #mTimeoutInSeconds} is {@link #MONITORING_TIMEOUT_NEVER},
528          * this field is ignored.
529          */
530         @DataClass.Generated.Member
531         @AddedInOrBefore(majorVersion = 33)
setTimeoutAction(@imeoutAction int value)532         public @android.annotation.NonNull Builder setTimeoutAction(@TimeoutAction int value) {
533             checkNotUsed();
534             mBuilderFieldsSet |= 0x10;
535             mTimeoutAction = value;
536             return this;
537         }
538 
539         /** Builds the instance. This builder should not be touched after calling this! */
540         @AddedInOrBefore(majorVersion = 33)
build()541         public @android.annotation.NonNull CpuAvailabilityMonitoringConfig build() {
542             checkNotUsed();
543             mBuilderFieldsSet |= 0x20; // Mark builder used
544 
545             if ((mBuilderFieldsSet & 0x1) == 0) {
546                 mCpuset = CPUSET_ALL;
547             }
548             if ((mBuilderFieldsSet & 0x10) == 0) {
549                 mTimeoutAction = TIMEOUT_ACTION_NOTIFICATION;
550             }
551             CpuAvailabilityMonitoringConfig o = new CpuAvailabilityMonitoringConfig(
552                     mCpuset,
553                     mLowerBoundPercent,
554                     mUpperBoundPercent,
555                     mTimeoutInSeconds,
556                     mTimeoutAction);
557             return o;
558         }
559 
checkNotUsed()560         private void checkNotUsed() {
561             if ((mBuilderFieldsSet & 0x20) != 0) {
562                 throw new IllegalStateException(
563                         "This Builder should not be reused. Use a new Builder instance instead");
564             }
565         }
566     }
567 
568     @DataClass.Generated(
569             time = 1673057982096L,
570             codegenVersion = "1.0.23",
571             sourceFile = "packages/services/Car/car-lib/src/android/car/os/CpuAvailabilityMonitoringConfig.java",
572             inputSignatures = "public static final @android.car.os.CpuAvailabilityMonitoringConfig.Cpuset @android.car.annotation.AddedInOrBefore int CPUSET_ALL\npublic static final @android.car.os.CpuAvailabilityMonitoringConfig.Cpuset @android.car.annotation.AddedInOrBefore int CPUSET_BACKGROUND\npublic static final @android.car.os.CpuAvailabilityMonitoringConfig.IgnorePercent @android.car.annotation.AddedInOrBefore int IGNORE_PERCENT_LOWER_BOUND\npublic static final @android.car.os.CpuAvailabilityMonitoringConfig.IgnorePercent @android.car.annotation.AddedInOrBefore int IGNORE_PERCENT_UPPER_BOUND\npublic static final @android.car.annotation.AddedInOrBefore int MONITORING_TIMEOUT_NEVER\npublic static final @android.car.os.CpuAvailabilityMonitoringConfig.TimeoutAction @android.car.annotation.AddedInOrBefore int TIMEOUT_ACTION_NOTIFICATION\npublic static final @android.car.os.CpuAvailabilityMonitoringConfig.TimeoutAction @android.car.annotation.AddedInOrBefore int TIMEOUT_ACTION_REMOVE\nprivate @android.car.os.CpuAvailabilityMonitoringConfig.Cpuset int mCpuset\nprivate  int mLowerBoundPercent\nprivate  int mUpperBoundPercent\nprivate @android.annotation.SuppressLint long mTimeoutInSeconds\nprivate @android.car.os.CpuAvailabilityMonitoringConfig.TimeoutAction int mTimeoutAction\nclass CpuAvailabilityMonitoringConfig extends java.lang.Object implements [android.os.Parcelable]\n@com.android.car.internal.util.DataClass(genToString=true, genBuilder=true, genHiddenConstDefs=true)")
573     @Deprecated
__metadata()574     private void __metadata() {}
575 
576 
577     //@formatter:on
578     // End of generated code
579 
580 }
581