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