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