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