1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.base;
import android.annotation.TargetApi;
import android.app.ActivityManager;
import android.content.Context;
import android.os.Build;
import android.os.StrictMode;
import android.util.Log;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Exposes system related information about the current device.
*/
public class SysUtils {
// A device reporting strictly more total memory in megabytes cannot be considered 'low-end'.
private static final int ANDROID_LOW_MEMORY_DEVICE_THRESHOLD_MB = 512;
// Number of kilobytes in a megabyte.
private static final int KBS_IN_MB = 1024;
private static final String TAG = "SysUtils";
private static Boolean sLowEndDevice;
private SysUtils() { }
/**
* Return the amount of physical memory on this device in kilobytes.
* @return Amount of physical memory in kilobytes, or 0 if there was
* an error trying to access the information.
*/
private static int amountOfPhysicalMemoryMB() {
// Extract total memory RAM size by parsing /proc/meminfo, note that
// this is exactly what the implementation of sysconf(_SC_PHYS_PAGES)
// does. However, it can't be called because this method must be
// usable before any native code is loaded.
// An alternative is to use ActivityManager.getMemoryInfo(), but this
// requires a valid ActivityManager handle, which can only come from
// a valid Context object, which itself cannot be retrieved
// during early startup, where this method is called. And making it
// an explicit parameter here makes all call paths _much_ more
// complicated.
Pattern pattern = Pattern.compile("^MemTotal:\\s+([0-9]+) kB$");
// Synchronously reading files in /proc in the UI thread is safe.
StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();
try {
FileReader fileReader = new FileReader("/proc/meminfo");
try {
BufferedReader reader = new BufferedReader(fileReader);
try {
String line;
for (;;) {
line = reader.readLine();
if (line == null) {
Log.w(TAG, "/proc/meminfo lacks a MemTotal entry?");
break;
}
Matcher m = pattern.matcher(line);
if (!m.find()) continue;
int totalMemoryKB = Integer.parseInt(m.group(1));
// Sanity check.
if (totalMemoryKB <= KBS_IN_MB) {
Log.w(TAG, "Invalid /proc/meminfo total size in kB: " + m.group(1));
break;
}
return totalMemoryKB / KBS_IN_MB;
}
} finally {
reader.close();
}
} finally {
fileReader.close();
}
} catch (Exception e) {
Log.w(TAG, "Cannot get total physical size from /proc/meminfo", e);
} finally {
StrictMode.setThreadPolicy(oldPolicy);
}
return 0;
}
/**
* @return Whether or not this device should be considered a low end device.
*/
@CalledByNative
public static boolean isLowEndDevice() {
if (sLowEndDevice == null) {
sLowEndDevice = detectLowEndDevice();
}
return sLowEndDevice.booleanValue();
}
@TargetApi(Build.VERSION_CODES.KITKAT)
private static boolean detectLowEndDevice() {
assert CommandLine.isInitialized();
if (CommandLine.getInstance().hasSwitch(BaseSwitches.ENABLE_LOW_END_DEVICE_MODE)) {
return true;
}
if (CommandLine.getInstance().hasSwitch(BaseSwitches.DISABLE_LOW_END_DEVICE_MODE)) {
return false;
}
// Any pre-KitKat device cannot be considered 'low-end'.
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
return false;
}
Context context = ApplicationStatus.getApplicationContext();
if (context != null) {
ActivityManager activityManager = (ActivityManager)
context.getSystemService(Context.ACTIVITY_SERVICE);
if (activityManager.isLowRamDevice()) {
return true;
}
} else {
Log.e(TAG, "ApplicationContext is null in ApplicationStatus");
}
int ramSizeMB = amountOfPhysicalMemoryMB();
if (ramSizeMB <= 0) {
return false;
}
return ramSizeMB < ANDROID_LOW_MEMORY_DEVICE_THRESHOLD_MB;
}
}
|
