Home | History | Annotate | Download | only in getinfo 
      1 /*
      2  * Copyright (C) 2008 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.tests.getinfo;
     18 
     19 import android.app.Activity;
     20 import android.app.ActivityManager;
     21 import android.app.ActivityManager.MemoryInfo;
     22 import android.app.Instrumentation;
     23 import android.content.Context;
     24 import android.content.Intent;
     25 import android.content.pm.FeatureInfo;
     26 import android.content.pm.PackageManager;
     27 import android.content.res.Configuration;
     28 import android.os.Build;
     29 import android.os.Bundle;
     30 import android.os.Environment;
     31 import android.os.UserManager;
     32 import android.os.SystemProperties;
     33 import android.telephony.TelephonyManager;
     34 import android.text.TextUtils;
     35 import android.util.DisplayMetrics;
     36 import android.util.Log;
     37 import android.view.Display;
     38 import android.view.WindowManager;
     39 
     40 import com.android.compatibility.common.util.ShellIdentityUtils;
     41 
     42 import java.io.IOException;
     43 import java.lang.reflect.Field;
     44 import java.lang.reflect.InvocationTargetException;
     45 import java.lang.reflect.Method;
     46 import java.util.ArrayList;
     47 import java.util.Arrays;
     48 import java.util.HashSet;
     49 import java.util.List;
     50 import java.util.Scanner;
     51 import java.util.Set;
     52 
     53 public class DeviceInfoInstrument extends Instrumentation implements DeviceInfoConstants {
     54 
     55     private static final String TAG = "DeviceInfoInstrument";
     56 
     57     private static Bundle mResults = new Bundle();
     58 
     59     public DeviceInfoInstrument() {
     60         super();
     61     }
     62 
     63     @Override
     64     public void onCreate(Bundle arguments) {
     65         start();
     66     }
     67 
     68     @Override
     69     public void onStart() {
     70         addResult(BUILD_ID, Build.ID);
     71         addResult(PRODUCT_NAME, Build.PRODUCT);
     72         addResult(BUILD_DEVICE, Build.DEVICE);
     73         addResult(BUILD_BOARD, Build.BOARD);
     74         addResult(BUILD_MANUFACTURER, Build.MANUFACTURER);
     75         addResult(BUILD_BRAND, Build.BRAND);
     76         addResult(BUILD_MODEL, Build.MODEL);
     77         addResult(BUILD_TYPE, Build.TYPE);
     78         addResult(BUILD_FINGERPRINT, Build.FINGERPRINT);
     79         addResult(BUILD_ABI, Build.CPU_ABI);
     80         addResult(BUILD_ABI2, Build.CPU_ABI2);
     81         addResult(BUILD_ABIS, TextUtils.join(",", Build.SUPPORTED_ABIS));
     82         addResult(BUILD_ABIS_32, TextUtils.join(",", Build.SUPPORTED_32_BIT_ABIS));
     83         addResult(BUILD_ABIS_64, TextUtils.join(",", Build.SUPPORTED_64_BIT_ABIS));
     84         addResult(SERIAL_NUMBER, Build.SERIAL);
     85 
     86         addResult(REFERENCE_BUILD_FINGERPRINT,
     87             SystemProperties.get("ro.build.reference.fingerprint", ""));
     88 
     89         addResult(VERSION_RELEASE, Build.VERSION.RELEASE);
     90         addResult(VERSION_SDK, Build.VERSION.SDK);
     91         addResult(VERSION_BASE_OS, Build.VERSION.BASE_OS);
     92         addResult(VERSION_SECURITY_PATCH, Build.VERSION.SECURITY_PATCH);
     93 
     94         DisplayMetrics metrics = new DisplayMetrics();
     95         WindowManager wm = (WindowManager) getContext().getSystemService(
     96                 Context.WINDOW_SERVICE);
     97         Display d = wm.getDefaultDisplay();
     98         d.getRealMetrics(metrics);
     99         addResult(RESOLUTION, String.format("%sx%s", metrics.widthPixels, metrics.heightPixels));
    100         addResult(SCREEN_DENSITY, metrics.density);
    101         addResult(SCREEN_X_DENSITY, metrics.xdpi);
    102         addResult(SCREEN_Y_DENSITY, metrics.ydpi);
    103 
    104         String screenDensityBucket = getScreenDensityBucket(metrics);
    105         addResult(SCREEN_DENSITY_BUCKET, screenDensityBucket);
    106 
    107         String screenSize = getScreenSize();
    108         addResult(SCREEN_SIZE, screenSize);
    109 
    110         Configuration configuration = getContext().getResources().getConfiguration();
    111         addResult(SMALLEST_SCREEN_WIDTH_DP, configuration.smallestScreenWidthDp);
    112 
    113         Intent intent = new Intent();
    114         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    115         intent.setClass(this.getContext(), DeviceInfoActivity.class);
    116 
    117         DeviceInfoActivity activity = (DeviceInfoActivity) startActivitySync(intent);
    118         waitForIdleSync();
    119         activity.waitForAcitityToFinish();
    120 
    121         TelephonyManager tm = (TelephonyManager) getContext().getSystemService(
    122                 Context.TELEPHONY_SERVICE);
    123         // network
    124         String network = tm.getNetworkOperatorName();
    125         addResult(NETWORK, network.trim());
    126         // imei
    127         String imei = ShellIdentityUtils.invokeMethodWithShellPermissions(tm,
    128                 (telephonyManager) -> telephonyManager.getDeviceId());
    129         addResult(IMEI, imei);
    130 
    131         // imsi
    132         String imsi = ShellIdentityUtils.invokeMethodWithShellPermissions(tm,
    133                 (telephonyManager) -> telephonyManager.getSubscriberId());
    134         addResult(IMSI, imsi);
    135 
    136         // phone number
    137         String phoneNumber = tm.getLine1Number();
    138         addResult(PHONE_NUMBER, phoneNumber);
    139 
    140         // features
    141         String features = getFeatures();
    142         addResult(FEATURES, features);
    143 
    144         // processes
    145         String processes = getProcesses();
    146         addResult(PROCESSES, processes);
    147 
    148         // OpenGL ES version
    149         String openGlEsVersion = getOpenGlEsVersion();
    150         addResult(OPEN_GL_ES_VERSION, openGlEsVersion);
    151 
    152         // partitions
    153         String partitions = getPartitions();
    154         addResult(PARTITIONS, partitions);
    155 
    156         // System libraries
    157         String sysLibraries = getSystemLibraries();
    158         addResult(SYS_LIBRARIES, sysLibraries);
    159 
    160         // Storage devices
    161         addResult(STORAGE_DEVICES, getStorageDevices());
    162 
    163         // Multi-user support
    164         addResult(MULTI_USER, getMultiUserInfo());
    165 
    166         // Encrypted
    167         addResult(ENCRYPTED, getEncrypted());
    168 
    169         // Memory Info
    170         addResult(IS_LOW_RAM_DEVICE, isLowRamDevice());
    171         addResult(MEMORY_CLASS, getMemoryClass());
    172         addResult(LARGE_MEMORY_CLASS, getLargeMemoryClass());
    173         addResult(TOTAL_MEMORY, getTotalMemory());
    174 
    175         // CPU Info
    176         addResult(AVAILABLE_PROCESSORS, Runtime.getRuntime().availableProcessors());
    177 
    178         finish(Activity.RESULT_OK, mResults);
    179     }
    180 
    181     /**
    182      * Add string result.
    183      *
    184      * @param key the string of the key name.
    185      * @param value string value.
    186      */
    187     static void addResult(final String key, final String value){
    188         mResults.putString(key, value);
    189     }
    190 
    191     /**
    192      * Add integer result.
    193      *
    194      * @param key the string of the key name.
    195      * @param value integer value.
    196      */
    197     static void addResult(final String key, final int value){
    198         mResults.putInt(key, value);
    199     }
    200 
    201     /**
    202      * Add float result.
    203      *
    204      * @param key the string of the key name.
    205      * @param value float value.
    206      */
    207     static void addResult(final String key, final float value){
    208         mResults.putFloat(key, value);
    209     }
    210 
    211     private String getScreenSize() {
    212         Configuration config = getContext().getResources().getConfiguration();
    213         int screenLayout = config.screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK;
    214         String screenSize = String.format("0x%x", screenLayout);
    215         switch (screenLayout) {
    216             case Configuration.SCREENLAYOUT_SIZE_SMALL:
    217                 screenSize = "small";
    218                 break;
    219 
    220             case Configuration.SCREENLAYOUT_SIZE_NORMAL:
    221                 screenSize = "normal";
    222                 break;
    223 
    224             case Configuration.SCREENLAYOUT_SIZE_LARGE:
    225                 screenSize = "large";
    226                 break;
    227 
    228             case Configuration.SCREENLAYOUT_SIZE_XLARGE:
    229                 screenSize = "xlarge";
    230                 break;
    231 
    232             case Configuration.SCREENLAYOUT_SIZE_UNDEFINED:
    233                 screenSize = "undefined";
    234                 break;
    235         }
    236         return screenSize;
    237     }
    238 
    239     private String getScreenDensityBucket(DisplayMetrics metrics) {
    240         switch (metrics.densityDpi) {
    241             case DisplayMetrics.DENSITY_LOW:
    242                 return "ldpi";
    243 
    244             case DisplayMetrics.DENSITY_MEDIUM:
    245                 return "mdpi";
    246 
    247             case DisplayMetrics.DENSITY_TV:
    248                 return "tvdpi";
    249 
    250             case DisplayMetrics.DENSITY_HIGH:
    251                 return "hdpi";
    252 
    253             case DisplayMetrics.DENSITY_XHIGH:
    254                 return "xdpi";
    255 
    256             default:
    257                 return "" + metrics.densityDpi;
    258         }
    259     }
    260 
    261     /**
    262      * Return a summary of the device's feature as a semi-colon-delimited list of colon separated
    263      * name and availability pairs like "feature1:sdk:true;feature2:sdk:false;feature3:other:true;".
    264      */
    265     private String getFeatures() {
    266         StringBuilder features = new StringBuilder();
    267 
    268         try {
    269             Set<String> checkedFeatures = new HashSet<String>();
    270 
    271             PackageManager packageManager = getContext().getPackageManager();
    272             for (String featureName : getPackageManagerFeatures()) {
    273                 checkedFeatures.add(featureName);
    274                 boolean hasFeature = packageManager.hasSystemFeature(featureName);
    275                 addFeature(features, featureName, "sdk", hasFeature);
    276             }
    277 
    278             FeatureInfo[] featureInfos = packageManager.getSystemAvailableFeatures();
    279             if (featureInfos != null) {
    280                 for (FeatureInfo featureInfo : featureInfos) {
    281                     if (featureInfo.name != null && !checkedFeatures.contains(featureInfo.name)) {
    282                         addFeature(features, featureInfo.name, "other", true);
    283                     }
    284                 }
    285             }
    286         } catch (Exception exception) {
    287             Log.e(TAG, "Error getting features: " + exception.getMessage(), exception);
    288         }
    289 
    290         return features.toString();
    291     }
    292 
    293     private static void addFeature(StringBuilder features, String name, String type,
    294             boolean available) {
    295         features.append(name).append(':').append(type).append(':').append(available).append(';');
    296     }
    297 
    298     /**
    299      * Use reflection to get the features defined by the SDK. If there are features that do not fit
    300      * the convention of starting with "FEATURE_" then they will still be shown under the
    301      * "Other Features" section.
    302      *
    303      * @return list of feature names from sdk
    304      */
    305     private List<String> getPackageManagerFeatures() {
    306         try {
    307             List<String> features = new ArrayList<String>();
    308             Field[] fields = PackageManager.class.getFields();
    309             for (Field field : fields) {
    310                 if (field.getName().startsWith("FEATURE_")) {
    311                     String feature = (String) field.get(null);
    312                     features.add(feature);
    313                 }
    314             }
    315             return features;
    316         } catch (IllegalAccessException illegalAccess) {
    317             throw new RuntimeException(illegalAccess);
    318         }
    319     }
    320 
    321     /**
    322      * Return a semi-colon-delimited list of the root processes that were running on the phone
    323      * or an error message.
    324      */
    325     private static String getProcesses() {
    326         StringBuilder builder = new StringBuilder();
    327 
    328         try {
    329             String[] rootProcesses = RootProcessScanner.getRootProcesses();
    330             for (String rootProcess : rootProcesses) {
    331                 builder.append(rootProcess).append(':').append(0).append(';');
    332             }
    333         } catch (Exception exception) {
    334             Log.e(TAG, "Error getting processes: " + exception.getMessage(), exception);
    335             builder.append(exception.getMessage());
    336         }
    337 
    338         return builder.toString();
    339     }
    340 
    341     /** @return a string containing the Open GL ES version number or an error message */
    342     private String getOpenGlEsVersion() {
    343         PackageManager packageManager = getContext().getPackageManager();
    344         FeatureInfo[] featureInfos = packageManager.getSystemAvailableFeatures();
    345         if (featureInfos != null && featureInfos.length > 0) {
    346             for (FeatureInfo featureInfo : featureInfos) {
    347                 // Null feature name means this feature is the open gl es version feature.
    348                 if (featureInfo.name == null) {
    349                     return featureInfo.getGlEsVersion();
    350                 }
    351             }
    352         }
    353         return "No feature for Open GL ES version.";
    354     }
    355 
    356     private String getPartitions() {
    357         try {
    358             StringBuilder builder = new StringBuilder();
    359             Process df = new ProcessBuilder("df").start();
    360             Scanner scanner = new Scanner(df.getInputStream());
    361             try {
    362                 while (scanner.hasNextLine()) {
    363                     builder.append(scanner.nextLine()).append(';');
    364                 }
    365                 return builder.toString();
    366             } finally {
    367                 scanner.close();
    368             }
    369         } catch (IOException e) {
    370             return "Not able to run df for partition information.";
    371         }
    372     }
    373 
    374     private String getSystemLibraries() {
    375         PackageManager pm = getContext().getPackageManager();
    376         String list[] = pm.getSystemSharedLibraryNames();
    377 
    378         StringBuilder builder = new StringBuilder();
    379         for (String lib : list) {
    380             builder.append(lib);
    381             builder.append(";");
    382         }
    383 
    384         return builder.toString();
    385     }
    386 
    387     private String getStorageDevices() {
    388         int count = 0;
    389         count = Math.max(count, getContext().getExternalCacheDirs().length);
    390         count = Math.max(count, getContext().getExternalFilesDirs(null).length);
    391         count = Math.max(
    392                 count, getContext().getExternalFilesDirs(Environment.DIRECTORY_PICTURES).length);
    393         count = Math.max(count, getContext().getObbDirs().length);
    394 
    395         if (Environment.isExternalStorageEmulated()) {
    396             if (count == 1) {
    397                 return "1 emulated";
    398             } else {
    399                 return "1 emulated, " + (count - 1) + " physical media";
    400             }
    401         } else {
    402             return count + " physical media";
    403         }
    404     }
    405 
    406     private String getMultiUserInfo() {
    407         try {
    408             final Method method = UserManager.class.getMethod("getMaxSupportedUsers");
    409             final Integer maxUsers = (Integer) method.invoke(null);
    410             if (maxUsers == 1) {
    411                 return "single user";
    412             } else {
    413                 return maxUsers + " users supported";
    414             }
    415         } catch (ClassCastException e) {
    416         } catch (NoSuchMethodException e) {
    417         } catch (InvocationTargetException e) {
    418         } catch (IllegalAccessException e) {
    419         }
    420 
    421         return "unknown";
    422     }
    423 
    424     private static String getProperty(String property)
    425             throws IOException {
    426         Process process = new ProcessBuilder("getprop", property).start();
    427         Scanner scanner = null;
    428         String line = "";
    429         try {
    430             scanner = new Scanner(process.getInputStream());
    431             line = scanner.nextLine();
    432         } finally {
    433             if (scanner != null) {
    434                 scanner.close();
    435             }
    436         }
    437         return line;
    438     }
    439 
    440     private int getEncrypted() {
    441         try {
    442             return "encrypted".equals(getProperty("ro.crypto.state")) ? 1 : 0;
    443         } catch (IOException e) {
    444         }
    445 
    446         return 0;
    447     }
    448 
    449     private String isLowRamDevice() {
    450         ActivityManager activityManager = (ActivityManager) getContext()
    451                 .getSystemService(Context.ACTIVITY_SERVICE);
    452         return activityManager.isLowRamDevice() ? "true" : "false";
    453     }
    454 
    455     private String getMemoryClass() {
    456         ActivityManager activityManager = (ActivityManager) getContext()
    457                 .getSystemService(Context.ACTIVITY_SERVICE);
    458         return String.valueOf(activityManager.getMemoryClass());
    459     }
    460 
    461     private String getLargeMemoryClass() {
    462         ActivityManager activityManager = (ActivityManager) getContext()
    463                 .getSystemService(Context.ACTIVITY_SERVICE);
    464         return String.valueOf(activityManager.getLargeMemoryClass());
    465     }
    466 
    467     private String getTotalMemory() {
    468         ActivityManager activityManager = (ActivityManager) getContext()
    469                 .getSystemService(Context.ACTIVITY_SERVICE);
    470 
    471         MemoryInfo memoryInfo = new MemoryInfo();
    472         activityManager.getMemoryInfo(memoryInfo);
    473         return String.valueOf(memoryInfo.totalMem);
    474     }
    475 }
    476