1 /* 2 * Copyright (C) 2007 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.os; 18 19 import com.android.internal.telephony.TelephonyProperties; 20 21 /** 22 * Information about the current build, extracted from system properties. 23 */ 24 public class Build { 25 /** Value used for when a build property is unknown. */ 26 public static final String UNKNOWN = "unknown"; 27 28 /** Either a changelist number, or a label like "M4-rc20". */ 29 public static final String ID = getString("ro.build.id"); 30 31 /** A build ID string meant for displaying to the user */ 32 public static final String DISPLAY = getString("ro.build.display.id"); 33 34 /** The name of the overall product. */ 35 public static final String PRODUCT = getString("ro.product.name"); 36 37 /** The name of the industrial design. */ 38 public static final String DEVICE = getString("ro.product.device"); 39 40 /** The name of the underlying board, like "goldfish". */ 41 public static final String BOARD = getString("ro.product.board"); 42 43 /** The name of the instruction set (CPU type + ABI convention) of native code. */ 44 public static final String CPU_ABI = getString("ro.product.cpu.abi"); 45 46 /** The name of the second instruction set (CPU type + ABI convention) of native code. */ 47 public static final String CPU_ABI2 = getString("ro.product.cpu.abi2"); 48 49 /** The manufacturer of the product/hardware. */ 50 public static final String MANUFACTURER = getString("ro.product.manufacturer"); 51 52 /** The brand (e.g., carrier) the software is customized for, if any. */ 53 public static final String BRAND = getString("ro.product.brand"); 54 55 /** The end-user-visible name for the end product. */ 56 public static final String MODEL = getString("ro.product.model"); 57 58 /** The system bootloader version number. */ 59 public static final String BOOTLOADER = getString("ro.bootloader"); 60 61 /** 62 * The radio firmware version number. 63 * 64 * @deprecated The radio firmware version is frequently not 65 * available when this class is initialized, leading to a blank or 66 * "unknown" value for this string. Use 67 * {@link #getRadioVersion} instead. 68 */ 69 @Deprecated 70 public static final String RADIO = getString(TelephonyProperties.PROPERTY_BASEBAND_VERSION); 71 72 /** The name of the hardware (from the kernel command line or /proc). */ 73 public static final String HARDWARE = getString("ro.hardware"); 74 75 /** A hardware serial number, if available. Alphanumeric only, case-insensitive. */ 76 public static final String SERIAL = getString("ro.serialno"); 77 78 /** Various version strings. */ 79 public static class VERSION { 80 /** 81 * The internal value used by the underlying source control to 82 * represent this build. E.g., a perforce changelist number 83 * or a git hash. 84 */ 85 public static final String INCREMENTAL = getString("ro.build.version.incremental"); 86 87 /** 88 * The user-visible version string. E.g., "1.0" or "3.4b5". 89 */ 90 public static final String RELEASE = getString("ro.build.version.release"); 91 92 /** 93 * The user-visible SDK version of the framework in its raw String 94 * representation; use {@link #SDK_INT} instead. 95 * 96 * @deprecated Use {@link #SDK_INT} to easily get this as an integer. 97 */ 98 @Deprecated 99 public static final String SDK = getString("ro.build.version.sdk"); 100 101 /** 102 * The user-visible SDK version of the framework; its possible 103 * values are defined in {@link Build.VERSION_CODES}. 104 */ 105 public static final int SDK_INT = SystemProperties.getInt( 106 "ro.build.version.sdk", 0); 107 108 /** 109 * The current development codename, or the string "REL" if this is 110 * a release build. 111 */ 112 public static final String CODENAME = getString("ro.build.version.codename"); 113 114 /** 115 * The SDK version to use when accessing resources. 116 * Use the current SDK version code. If we are a development build, 117 * also allow the previous SDK version + 1. 118 * @hide 119 */ 120 public static final int RESOURCES_SDK_INT = SDK_INT 121 + ("REL".equals(CODENAME) ? 0 : 1); 122 } 123 124 /** 125 * Enumeration of the currently known SDK version codes. These are the 126 * values that can be found in {@link VERSION#SDK}. Version numbers 127 * increment monotonically with each official platform release. 128 */ 129 public static class VERSION_CODES { 130 /** 131 * Magic version number for a current development build, which has 132 * not yet turned into an official release. 133 */ 134 public static final int CUR_DEVELOPMENT = 10000; 135 136 /** 137 * October 2008: The original, first, version of Android. Yay! 138 */ 139 public static final int BASE = 1; 140 141 /** 142 * February 2009: First Android update, officially called 1.1. 143 */ 144 public static final int BASE_1_1 = 2; 145 146 /** 147 * May 2009: Android 1.5. 148 */ 149 public static final int CUPCAKE = 3; 150 151 /** 152 * September 2009: Android 1.6. 153 * 154 * <p>Applications targeting this or a later release will get these 155 * new changes in behavior:</p> 156 * <ul> 157 * <li> They must explicitly request the 158 * {@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} permission to be 159 * able to modify the contents of the SD card. (Apps targeting 160 * earlier versions will always request the permission.) 161 * <li> They must explicitly request the 162 * {@link android.Manifest.permission#READ_PHONE_STATE} permission to be 163 * able to be able to retrieve phone state info. (Apps targeting 164 * earlier versions will always request the permission.) 165 * <li> They are assumed to support different screen densities and 166 * sizes. (Apps targeting earlier versions are assumed to only support 167 * medium density normal size screens unless otherwise indicated). 168 * They can still explicitly specify screen support either way with the 169 * supports-screens manifest tag. 170 * <li> {@link android.widget.TabHost} will use the new dark tab 171 * background design. 172 * </ul> 173 */ 174 public static final int DONUT = 4; 175 176 /** 177 * November 2009: Android 2.0 178 * 179 * <p>Applications targeting this or a later release will get these 180 * new changes in behavior:</p> 181 * <ul> 182 * <li> The {@link android.app.Service#onStartCommand 183 * Service.onStartCommand} function will return the new 184 * {@link android.app.Service#START_STICKY} behavior instead of the 185 * old compatibility {@link android.app.Service#START_STICKY_COMPATIBILITY}. 186 * <li> The {@link android.app.Activity} class will now execute back 187 * key presses on the key up instead of key down, to be able to detect 188 * canceled presses from virtual keys. 189 * <li> The {@link android.widget.TabWidget} class will use a new color scheme 190 * for tabs. In the new scheme, the foreground tab has a medium gray background 191 * the background tabs have a dark gray background. 192 * </ul> 193 */ 194 public static final int ECLAIR = 5; 195 196 /** 197 * December 2009: Android 2.0.1 198 */ 199 public static final int ECLAIR_0_1 = 6; 200 201 /** 202 * January 2010: Android 2.1 203 */ 204 public static final int ECLAIR_MR1 = 7; 205 206 /** 207 * June 2010: Android 2.2 208 */ 209 public static final int FROYO = 8; 210 211 /** 212 * November 2010: Android 2.3 213 * 214 * <p>Applications targeting this or a later release will get these 215 * new changes in behavior:</p> 216 * <ul> 217 * <li> The application's notification icons will be shown on the new 218 * dark status bar background, so must be visible in this situation. 219 * </ul> 220 */ 221 public static final int GINGERBREAD = 9; 222 223 /** 224 * February 2011: Android 2.3.3. 225 */ 226 public static final int GINGERBREAD_MR1 = 10; 227 228 /** 229 * February 2011: Android 3.0. 230 * 231 * <p>Applications targeting this or a later release will get these 232 * new changes in behavior:</p> 233 * <ul> 234 * <li> The default theme for applications is now dark holographic: 235 * {@link android.R.style#Theme_Holo}. 236 * <li> On large screen devices that do not have a physical menu 237 * button, the soft (compatibility) menu is disabled. 238 * <li> The activity lifecycle has changed slightly as per 239 * {@link android.app.Activity}. 240 * <li> An application will crash if it does not call through 241 * to the super implementation of its 242 * {@link android.app.Activity#onPause Activity.onPause()} method. 243 * <li> When an application requires a permission to access one of 244 * its components (activity, receiver, service, provider), this 245 * permission is no longer enforced when the application wants to 246 * access its own component. This means it can require a permission 247 * on a component that it does not itself hold and still access that 248 * component. 249 * <li> {@link android.content.Context#getSharedPreferences 250 * Context.getSharedPreferences()} will not automatically reload 251 * the preferences if they have changed on storage, unless 252 * {@link android.content.Context#MODE_MULTI_PROCESS} is used. 253 * <li> {@link android.view.ViewGroup#setMotionEventSplittingEnabled} 254 * will default to true. 255 * <li> {@link android.view.WindowManager.LayoutParams#FLAG_SPLIT_TOUCH} 256 * is enabled by default on windows. 257 * <li> {@link android.widget.PopupWindow#isSplitTouchEnabled() 258 * PopupWindow.isSplitTouchEnabled()} will return true by default. 259 * <li> {@link android.widget.GridView} and {@link android.widget.ListView} 260 * will use {@link android.view.View#setActivated View.setActivated} 261 * for selected items if they do not implement {@link android.widget.Checkable}. 262 * <li> {@link android.widget.Scroller} will be constructed with 263 * "flywheel" behavior enabled by default. 264 * </ul> 265 */ 266 public static final int HONEYCOMB = 11; 267 268 /** 269 * May 2011: Android 3.1. 270 */ 271 public static final int HONEYCOMB_MR1 = 12; 272 273 /** 274 * June 2011: Android 3.2. 275 * 276 * <p>Update to Honeycomb MR1 to support 7 inch tablets, improve 277 * screen compatibility mode, etc.</p> 278 * 279 * <p>As of this version, applications that don't say whether they 280 * support XLARGE screens will be assumed to do so only if they target 281 * {@link #HONEYCOMB} or later; it had been {@link #GINGERBREAD} or 282 * later. Applications that don't support a screen size at least as 283 * large as the current screen will provide the user with a UI to 284 * switch them in to screen size compatibility mode.</p> 285 * 286 * <p>This version introduces new screen size resource qualifiers 287 * based on the screen size in dp: see 288 * {@link android.content.res.Configuration#screenWidthDp}, 289 * {@link android.content.res.Configuration#screenHeightDp}, and 290 * {@link android.content.res.Configuration#smallestScreenWidthDp}. 291 * Supplying these in <supports-screens> as per 292 * {@link android.content.pm.ApplicationInfo#requiresSmallestWidthDp}, 293 * {@link android.content.pm.ApplicationInfo#compatibleWidthLimitDp}, and 294 * {@link android.content.pm.ApplicationInfo#largestWidthLimitDp} is 295 * preferred over the older screen size buckets and for older devices 296 * the appropriate buckets will be inferred from them.</p> 297 * 298 * <p>Applications targeting this or a later release will get these 299 * new changes in behavior:</p> 300 * <ul> 301 * <li><p>New {@link android.content.pm.PackageManager#FEATURE_SCREEN_PORTRAIT} 302 * and {@link android.content.pm.PackageManager#FEATURE_SCREEN_LANDSCAPE} 303 * features were introduced in this release. Applications that target 304 * previous platform versions are assumed to require both portrait and 305 * landscape support in the device; when targeting Honeycomb MR1 or 306 * greater the application is responsible for specifying any specific 307 * orientation it requires.</p> 308 * <li><p>{@link android.os.AsyncTask} will use the serial executor 309 * by default when calling {@link android.os.AsyncTask#execute}.</p> 310 * <li><p>{@link android.content.pm.ActivityInfo#configChanges 311 * ActivityInfo.configChanges} will have the 312 * {@link android.content.pm.ActivityInfo#CONFIG_SCREEN_SIZE} and 313 * {@link android.content.pm.ActivityInfo#CONFIG_SMALLEST_SCREEN_SIZE} 314 * bits set; these need to be cleared for older applications because 315 * some developers have done absolute comparisons against this value 316 * instead of correctly masking the bits they are interested in. 317 * </ul> 318 */ 319 public static final int HONEYCOMB_MR2 = 13; 320 321 /** 322 * October 2011: Android 4.0. 323 * 324 * <p>Applications targeting this or a later release will get these 325 * new changes in behavior:</p> 326 * <ul> 327 * <li> For devices without a dedicated menu key, the software compatibility 328 * menu key will not be shown even on phones. By targeting Ice Cream Sandwich 329 * or later, your UI must always have its own menu UI affordance if needed, 330 * on both tablets and phones. The ActionBar will take care of this for you. 331 * <li> 2d drawing hardware acceleration is now turned on by default. 332 * You can use 333 * {@link android.R.attr#hardwareAccelerated android:hardwareAccelerated} 334 * to turn it off if needed, although this is strongly discouraged since 335 * it will result in poor performance on larger screen devices. 336 * <li> The default theme for applications is now the "device default" theme: 337 * {@link android.R.style#Theme_DeviceDefault}. This may be the 338 * holo dark theme or a different dark theme defined by the specific device. 339 * The {@link android.R.style#Theme_Holo} family must not be modified 340 * for a device to be considered compatible. Applications that explicitly 341 * request a theme from the Holo family will be guaranteed that these themes 342 * will not change character within the same platform version. Applications 343 * that wish to blend in with the device should use a theme from the 344 * {@link android.R.style#Theme_DeviceDefault} family. 345 * <li> Managed cursors can now throw an exception if you directly close 346 * the cursor yourself without stopping the management of it; previously failures 347 * would be silently ignored. 348 * <li> The fadingEdge attribute on views will be ignored (fading edges is no 349 * longer a standard part of the UI). A new requiresFadingEdge attribute allows 350 * applications to still force fading edges on for special cases. 351 * <li> {@link android.content.Context#bindService Context.bindService()} 352 * will not automatically add in {@link android.content.Context#BIND_WAIVE_PRIORITY}. 353 * <li> App Widgets will have standard padding automatically added around 354 * them, rather than relying on the padding being baked into the widget itself. 355 * <li> An exception will be thrown if you try to change the type of a 356 * window after it has been added to the window manager. Previously this 357 * would result in random incorrect behavior. 358 * <li> {@link android.view.animation.AnimationSet} will parse out 359 * the duration, fillBefore, fillAfter, repeatMode, and startOffset 360 * XML attributes that are defined. 361 * <li> {@link android.app.ActionBar#setHomeButtonEnabled 362 * ActionBar.setHomeButtonEnabled()} is false by default. 363 * </ul> 364 */ 365 public static final int ICE_CREAM_SANDWICH = 14; 366 367 /** 368 * December 2011: Android 4.0.3. 369 */ 370 public static final int ICE_CREAM_SANDWICH_MR1 = 15; 371 372 /** 373 * June 2012: Android 4.1. 374 * 375 * <p>Applications targeting this or a later release will get these 376 * new changes in behavior:</p> 377 * <ul> 378 * <li> You must explicitly request the {@link android.Manifest.permission#READ_CALL_LOG} 379 * and/or {@link android.Manifest.permission#WRITE_CALL_LOG} permissions; 380 * access to the call log is no longer implicitly provided through 381 * {@link android.Manifest.permission#READ_CONTACTS} and 382 * {@link android.Manifest.permission#WRITE_CONTACTS}. 383 * <li> {@link android.widget.RemoteViews} will throw an exception if 384 * setting an onClick handler for views being generated by a 385 * {@link android.widget.RemoteViewsService} for a collection container; 386 * previously this just resulted in a warning log message. 387 * <li> New {@link android.app.ActionBar} policy for embedded tabs: 388 * embedded tabs are now always stacked in the action bar when in portrait 389 * mode, regardless of the size of the screen. 390 * <li> {@link android.webkit.WebSettings#setAllowFileAccessFromFileURLs(boolean) 391 * WebSettings.setAllowFileAccessFromFileURLs} and 392 * {@link android.webkit.WebSettings#setAllowUniversalAccessFromFileURLs(boolean) 393 * WebSettings.setAllowUniversalAccessFromFileURLs} default to false. 394 * <li> Calls to {@link android.content.pm.PackageManager#setComponentEnabledSetting 395 * PackageManager.setComponentEnabledSetting} will now throw an 396 * IllegalArgumentException if the given component class name does not 397 * exist in the application's manifest. 398 * <li> {@link android.nfc.NfcAdapter#setNdefPushMessage 399 * NfcAdapter.setNdefPushMessage}, 400 * {@link android.nfc.NfcAdapter#setNdefPushMessageCallback 401 * NfcAdapter.setNdefPushMessageCallback} and 402 * {@link android.nfc.NfcAdapter#setOnNdefPushCompleteCallback 403 * NfcAdapter.setOnNdefPushCompleteCallback} will throw 404 * IllegalStateException if called after the Activity has been destroyed. 405 * <li> Accessibility services must require the new 406 * {@link android.Manifest.permission#BIND_ACCESSIBILITY_SERVICE} permission or 407 * they will not be available for use. 408 * <li> {@link android.accessibilityservice.AccessibilityServiceInfo#FLAG_INCLUDE_NOT_IMPORTANT_VIEWS 409 * AccessibilityServiceInfo.FLAG_INCLUDE_NOT_IMPORTANT_VIEWS} must be set 410 * for unimportant views to be included in queries. 411 * </ul> 412 */ 413 public static final int JELLY_BEAN = 16; 414 415 /** 416 * Android 4.2: Moar jelly beans! 417 * 418 * <p>Applications targeting this or a later release will get these 419 * new changes in behavior:</p> 420 * <ul> 421 * <li>Content Providers: The default value of {@code android:exported} is now 422 * {@code false}. See 423 * <a href="{@docRoot}guide/topics/manifest/provider-element.html#exported"> 424 * the android:exported section</a> in the provider documentation for more details.</li> 425 * <li>{@link android.view.View#getLayoutDirection() View.getLayoutDirection()} 426 * can return different values than {@link android.view.View#LAYOUT_DIRECTION_LTR} 427 * based on the locale etc. 428 * <li> {@link android.webkit.WebView#addJavascriptInterface(Object, String) 429 * WebView.addJavascriptInterface} requires explicit annotations on methods 430 * for them to be accessible from Javascript. 431 * </ul> 432 */ 433 public static final int JELLY_BEAN_MR1 = 17; 434 435 /** 436 * Android 4.3: Jelly Bean MR2, the revenge of the beans. 437 */ 438 public static final int JELLY_BEAN_MR2 = 18; 439 440 /** 441 * Android 4.4: KitKat, another tasty treat. 442 * 443 * <p>Applications targeting this or a later release will get these 444 * new changes in behavior:</p> 445 * <ul> 446 * <li> The default result of {android.preference.PreferenceActivity#isValidFragment 447 * PreferenceActivity.isValueFragment} becomes false instead of true.</li> 448 * <li> In {@link android.webkit.WebView}, apps targeting earlier versions will have 449 * JS URLs evaluated directly and any result of the evaluation will not replace 450 * the current page content. Apps targetting KITKAT or later that load a JS URL will 451 * have the result of that URL replace the content of the current page</li> 452 * <li> {@link android.app.AlarmManager#set AlarmManager.set} becomes interpreted as 453 * an inexact value, to give the system more flexibility in scheduling alarms.</li> 454 * <li> {@link android.content.Context#getSharedPreferences(String, int) 455 * Context.getSharedPreferences} no longer allows a null name.</li> 456 * <li> {@link android.widget.RelativeLayout} changes to compute wrapped content 457 * margins correctly.</li> 458 * <li> {@link android.app.ActionBar}'s window content overlay is allowed to be 459 * drawn.</li> 460 * <li>The {@link android.Manifest.permission#READ_EXTERNAL_STORAGE} 461 * permission is now always enforced.</li> 462 * <li>Access to package-specific external storage directories belonging 463 * to the calling app no longer requires the 464 * {@link android.Manifest.permission#READ_EXTERNAL_STORAGE} or 465 * {@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} 466 * permissions.</li> 467 * </ul> 468 */ 469 public static final int KITKAT = 19; 470 } 471 472 /** The type of build, like "user" or "eng". */ 473 public static final String TYPE = getString("ro.build.type"); 474 475 /** Comma-separated tags describing the build, like "unsigned,debug". */ 476 public static final String TAGS = getString("ro.build.tags"); 477 478 /** A string that uniquely identifies this build. Do not attempt to parse this value. */ 479 public static final String FINGERPRINT = getString("ro.build.fingerprint"); 480 481 // The following properties only make sense for internal engineering builds. 482 public static final long TIME = getLong("ro.build.date.utc") * 1000; 483 public static final String USER = getString("ro.build.user"); 484 public static final String HOST = getString("ro.build.host"); 485 486 /** 487 * Returns true if we are running a debug build such as "user-debug" or "eng". 488 * @hide 489 */ 490 public static final boolean IS_DEBUGGABLE = 491 SystemProperties.getInt("ro.debuggable", 0) == 1; 492 493 /** 494 * Returns the version string for the radio firmware. May return 495 * null (if, for instance, the radio is not currently on). 496 */ 497 public static String getRadioVersion() { 498 return SystemProperties.get(TelephonyProperties.PROPERTY_BASEBAND_VERSION, null); 499 } 500 501 private static String getString(String property) { 502 return SystemProperties.get(property, UNKNOWN); 503 } 504 505 private static long getLong(String property) { 506 try { 507 return Long.parseLong(SystemProperties.get(property)); 508 } catch (NumberFormatException e) { 509 return -1; 510 } 511 } 512 } 513
