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