Home | History | Annotate | Download | only in os
      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 &lt;supports-screens&gt; 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