Android获取cpu和内存信息、网址的代码

android获取手机cpu并判断是单核还是多核

/** 
* Gets the number of cores available in this device, across all processors. 
* Requires: Ability to peruse the filesystem at "/sys/devices/system/cpu" 
* @return The number of cores, or 1 if failed to get result 
*/ 
private int getNumCores() { 
//Private Class to display only CPU devices in the directory listing 
class CpuFilter implements FileFilter { 
@Override 
public boolean accept(File pathname) { 
//Check if filename is "cpu", followed by a single digit number 
if(Pattern.matches("cpu[0-9]", pathname.getName())) { 
return true; 

return false; 

}

try { 
//Get directory containing CPU info 
File dir = new File("/sys/devices/system/cpu/"); 
//Filter to only list the devices we care about 
File[] files = dir.listFiles(new CpuFilter()); 
//Return the number of cores (virtual CPU devices) 
return files.length; 
} catch(Exception e) { 
//Default to return 1 core 
return 1; 

}

Android获取cpu和内存信息、网址的代码,/** 获取用户硬件信息 */


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

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

/** 获取用户硬件信息 */

public static String getMobileInfo() { 

    //StringBuffer sb = new StringBuffer(); 

    JSONObject mbInfo = new JSONObject(); 

       

    //通过反射获取用户硬件信息 

    try 

   

        Field[] fields = Build.class.getDeclaredFields(); 

        for (Field field : fields) { 

            // 暴力反射,获取私有信息 

            field.setAccessible(true); 

            String name = field.getName(); 

            String value = field.get(null).toString(); 

            //sb.append(name + "=" + value); 

            //sb.append("n"); 

            mbInfo.put(name, value); 

        

    catch (Exception e) { 

        e.printStackTrace(); 

    

       

    //return sb.toString(); 

    return mbInfo.toString(); 

   

   

static public String getCpuString(){ 

    if(Build.CPU_ABI.equalsIgnoreCase("x86")){ 

        return "Intel"

    

       

    String strInfo = ""

    try

    

        byte[] bs = new byte[1024]; 

        RandomAccessFile reader = new RandomAccessFile("/proc/cpuinfo","r"); 

        reader.read(bs); 

        String ret = new String(bs); 

        int index = ret.indexOf(0); 

        if(index != -1) { 

            strInfo = ret.substring(0, index); 

        else 

            strInfo = ret; 

        

    

    catch (IOException ex){ 

        ex.printStackTrace(); 

    

       

    return strInfo; 

   

static public String getCpuType(){ 

    String strInfo = getCpuString(); 

    String strType = null

       

    if (strInfo.contains("ARMv5")) { 

        strType = "armv5"

    else if (strInfo.contains("ARMv6")) { 

        strType = "armv6"

    else if (strInfo.contains("ARMv7")) { 

        strType = "armv7"

    else if (strInfo.contains("Intel")){ 

        strType = "x86"

    }else

        strType = "unknown"

        return strType; 

    

       

    if (strInfo.contains("neon")) { 

        strType += "_neon"

    }else if (strInfo.contains("vfpv3")) { 

        strType += "_vfpv3"

    }else if (strInfo.contains(" vfp")) { 

        strType += "_vfp"

    }else

        strType += "_none"

    

       

    return strType; 

   

   

   

/**

 * @hide

 * @return

 */

public static CPUInfo getCPUInfo() { 

    String strInfo = null

    try

    

        byte[] bs = new byte[1024]; 

        RandomAccessFile reader = new RandomAccessFile("/proc/cpuinfo","r"); 

        reader.read(bs); 

        String ret = new String(bs); 

        int index = ret.indexOf(0); 

        if(index != -1) { 

            strInfo = ret.substring(0, index); 

        else 

            strInfo = ret; 

        

    

    catch (IOException ex) 

    

        strInfo = ""

        ex.printStackTrace(); 

    

       

    CPUInfo info = parseCPUInfo(strInfo); 

    info.mCPUMaxFreq = getMaxCpuFreq(); 

               

    return info; 

   

   

private final static String kCpuInfoMaxFreqFilePath ="/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq"

private static int getMaxCpuFreq() { 

    int result = 0

    FileReader fr = null

    BufferedReader br = null

    try 

        fr = new FileReader(kCpuInfoMaxFreqFilePath); 

        br = new BufferedReader(fr); 

        String text = br.readLine(); 

        if (text != null) { 

            result = Integer.parseInt(text.trim()); 

        

    catch (FileNotFoundException e) { 

        e.printStackTrace(); 

    catch (IOException e) { 

        e.printStackTrace(); 

    finally 

        if (fr != null

            try 

                fr.close(); 

            catch (IOException e) { 

                // TODO Auto-generated catch block 

                e.printStackTrace(); 

            

        if (br != null

            try 

                br.close(); 

            catch (IOException e) { 

                // TODO Auto-generated catch block 

                e.printStackTrace(); 

            

    

   

    return result; 

       

public static class CPUInfo{ 

    public CPUInfo(){ 

           

    

       

    public static final int CPU_TYPE_UNKNOWN            =   0x00000000

    public static final int CPU_TYPE_ARMV5TE            =   0x00000001

    public static final int CPU_TYPE_ARMV6              =   0x00000010

    public static final int CPU_TYPE_ARMV7              =   0x00000100

       

    public static final int CPU_FEATURE_UNKNOWS         =   0x00000000

    public static final int CPU_FEATURE_VFP             =   0x00000001

    public static final int CPU_FEATURE_VFPV3           =   0x00000010

    public static final int CPU_FEATURE_NEON            =   0x00000100

       

    public int mCPUType; 

    public int mCPUCount; 

    public int mCPUFeature;      

    public double mBogoMips; 

    public long mCPUMaxFreq; 

   

/**

 

 * @param cpuInfo

 * @return

 * @hide

 */

private static CPUInfo parseCPUInfo(String cpuInfo) { 

    if (cpuInfo == null || "".equals(cpuInfo)) { 

        return null

    

   

    CPUInfo ci = new CPUInfo(); 

    ci.mCPUType = CPUInfo.CPU_TYPE_UNKNOWN; 

    ci.mCPUFeature = CPUInfo.CPU_FEATURE_UNKNOWS; 

    ci.mCPUCount = 1

    ci.mBogoMips = 0

   

    if (cpuInfo.contains("ARMv5")) { 

        ci.mCPUType = CPUInfo.CPU_TYPE_ARMV5TE; 

    else if (cpuInfo.contains("ARMv6")) { 

        ci.mCPUType = CPUInfo.CPU_TYPE_ARMV6; 

    else if (cpuInfo.contains("ARMv7")) { 

        ci.mCPUType = CPUInfo.CPU_TYPE_ARMV7; 

    

   

    if (cpuInfo.contains("neon")) { 

        ci.mCPUFeature |= CPUInfo.CPU_FEATURE_NEON; 

    

   

    if (cpuInfo.contains("vfpv3")) { 

        ci.mCPUFeature |= CPUInfo.CPU_FEATURE_VFPV3; 

    

   

    if (cpuInfo.contains(" vfp")) { 

        ci.mCPUFeature |= CPUInfo.CPU_FEATURE_VFP; 

    

   

    String[] items = cpuInfo.split("n"); 

   

    for (String item : items) { 

        if (item.contains("CPU variant")) { 

            int index = item.indexOf(": "); 

            if (index >= 0) { 

                String value = item.substring(index + 2); 

                try 

                    ci.mCPUCount = Integer.decode(value); 

                    ci.mCPUCount = ci.mCPUCount == 0 1 : ci.mCPUCount; 

                catch (NumberFormatException e) { 

                    ci.mCPUCount = 1

                

            

        else if (item.contains("BogoMIPS")) { 

            int index = item.indexOf(": "); 

            if (index >= 0) { 

                String value = item.substring(index + 2); 

            

        

    

       

    return ci; 

   

   

   

/**

 * 获取设备内存大小值

 * @return 内存大小,单位MB

 */

public static long getTotalMemory() {  

    String str1 = "/proc/meminfo"

    String str2;         

    String[] arrayOfString; 

    long initial_memory = 0

    try 

        FileReader localFileReader = new FileReader(str1); 

        BufferedReader localBufferedReader = newBufferedReader(localFileReader, 8192); 

        str2 = localBufferedReader.readLine(); 

        if (str2 != null) { 

            arrayOfString = str2.split("\s+"); 

            initial_memory = Integer.valueOf(arrayOfString[1]).intValue()/1024

        

        localBufferedReader.close(); 

        return initial_memory; 

    }  

    catch (IOException e)  

    {        

        return -1

    

   

   

/**

 * @hide

 * @return

 */

public CPUInfo getCPUInfo() { 

    String strInfo = null

    try

    

        byte[] bs = new byte[1024]; 

        RandomAccessFile reader = new RandomAccessFile("/proc/cpuinfo","r"); 

        reader.read(bs); 

        String ret = new String(bs); 

        int index = ret.indexOf(0); 

        if(index != -1) { 

            strInfo = ret.substring(0, index); 

        else 

            strInfo = ret; 

        

    

    catch (IOException ex) 

    

        strInfo = ""

        ex.printStackTrace(); 

    

       

    CPUInfo info = parseCPUInfo(strInfo); 

    info.mCPUMaxFreq = getMaxCpuFreq(); 

               

    return info; 

   

/**

 * 获取android CPU类型

 

 * @return String CPU类型

 */

public static String getCpuModel(){ 

    String cpu_model = ""

   

    CPUInfo in = getCPUInfo(); 

             

    if ((in.mCPUType & CPUInfo.CPU_TYPE_ARMV5TE) == CPUInfo.CPU_TYPE_ARMV5TE) 

        cpu_model="armv5"

    else if ((in.mCPUType & CPUInfo.CPU_TYPE_ARMV6) == CPUInfo.CPU_TYPE_ARMV6) 

        cpu_model="armv6"

    else if ((in.mCPUType & CPUInfo.CPU_TYPE_ARMV7) == CPUInfo.CPU_TYPE_ARMV7) 

        cpu_model="armv7"

    else

        cpu_model="unknown"

    return cpu_model; 

   

/**

 * 获取android CPU特性

 

 * @return String CPU特性

 */

public static String getCpuFeature(){ 

    String cpu_feature = ""

           

    CPUInfo in = getCPUInfo(); 

               

    if ((in.mCPUFeature & CPUInfo.CPU_FEATURE_NEON ) == CPUInfo.CPU_FEATURE_NEON) 

        cpu_feature="neon"

    else if ((in.mCPUFeature & CPUInfo.CPU_FEATURE_VFP ) == CPUInfo.CPU_FEATURE_VFP) 

        cpu_feature="vfp"

    else if ((in.mCPUFeature & CPUInfo.CPU_FEATURE_VFPV3 ) == CPUInfo.CPU_FEATURE_VFPV3) 

        cpu_feature="vfpv3"

    else

        cpu_feature="unknown";  

    return cpu_feature; 

   

/**

 * 获取ip地址

 

 * @param mContext  Context

 * @return ip地址字符串

 */

public static String getIpAddress(Context mContext) { 

    String ipAddress = null

    try 

        for (Enumeration<NetworkInterface> en = NetworkInterface 

                .getNetworkInterfaces(); en.hasMoreElements();) { 

            NetworkInterface intf = en.nextElement(); 

            for (Enumeration<InetAddress> enumIpAddr = intf 

                    .getInetAddresses(); enumIpAddr.hasMoreElements();) { 

                InetAddress inetAddress = enumIpAddr.nextElement(); 

                if (!inetAddress.isLoopbackAddress()) { 

                    ipAddress = inetAddress.getHostAddress().toString();  

                

            

        

    catch (SocketException ex) { 

        return null

    

    if (DEBUG) { 

        Log.d(TAG, "ip address:" + ipAddress); 

    

    return ipAddress; 

}

 

时间: 2024-10-13 13:18:13

Android获取cpu和内存信息、网址的代码的相关文章

使用python获取CPU和内存信息的思路与实现(linux系统)

linux里一切皆为文件,在linux/unix的根目录下,有个/proc目录,这个/proc 是一种内核和内核模块用来向进程(process)发送信息的机制(所以叫做"/proc"),这个伪文件系统允许与内核内部数据结构交互,获取有关进程的有用信息,在运行中(on the fly)改变设置(通过改变内核参数).与其他文件系统不同,/proc 存在于内存而不是硬盘中.proc 文件系统提供的信息如下: ?进程信息:系统中的任何一个进程,在 proc 的子目录中都有一个同名的进程 ID,

Android 获取手机总内存和可用内存等信息

在android开发中,有时候我们想获取手机的一些硬件信息,比如android手机的总内存和可用内存大小.这个该如何实现呢? 通过读取文件"/proc/meminfo"的信息能够获取手机Memory的总量,而通过ActivityManager.getMemoryInfo(ActivityManager.MemoryInfo)方法可以获取当前的可用Memory量. "/proc/meminfo"文件记录了android手机的一些内存信息,在命令行窗口里输入"

方法:Linux 下用JAVA获取CPU、内存、磁盘的系统资源信息

CPU使用率: InputStream is = null; InputStreamReader isr = null; BufferedReader brStat = null; StringTokenizer tokenStat = null; // 用来分隔String的应用类 try { System.out.println("Get usage rate of CUP : "); Process process = Runtime.getRuntime().exec(&quo

busybox devmem 直接获取、修改内存信息

/********************************************************************** * busybox devmem 直接获取.修改内存信息 * 说明: * 有时候再进行一些硬件测试的时候为了加快处理速度,可能会希望通过 * shell直接修改内存地址中的信息,devmem内部还是mmap进行地址映射,另外 * 觉得可以直接用outb/inb等函数直接操作. * * 2018-6-25 深圳 宝安西乡 曾剑锋 *************

戴尔R740服务器获取cpu、内存、硬盘参数信息。

戴尔R740服务器获取cpu.内存.硬盘参数信息.使用redfish协议,只使用了system的一个总URL即可获取所有参数. import requests import json requests.packages.urllib3.disable_warnings() ##使用一个system总的URL分别获取到cpu.内存.存储三个url.所以只修改system的URL即可 ##sel日志单独使用URL获取 class GetHostInfo(object): def __init__(s

Android获取cpu使用率,剩余内存和硬盘容量

1.内存信息 在proc/meminfo下有详细的内存使用情况,我这里获取的内存信息就是从这个文件里获取的.获取到详细的内存信息后根据我自己的需求,从bufferdreader中单独抽取出来了剩余的内存容量. <span style="font-family:Microsoft YaHei;font-size:14px;"> Runtime runtime = Runtime.getRuntime(); Process p; try { p = runtime.exec(C

java获取cpu、内存、硬盘信息

1 下载安装sigar-1.6.4.zip 使用java自带的包获取系统数据,容易找不到包,尤其是内存信息不够准确,所以选择使用sigar获取系统信息. 下载地址:http://sourceforge.net/projects/sigar/files/latest/download?source=files 解压压缩包,将lib下sigar.jar导入eclipse的CLASSPATH中,再将sigar-x86-winnt.dll存入Java的bin目录即可. 2 代码示例 /**    * @

python 获取linux的内存信息

1.安装psutil源码 https://pypi.python.org/pypi?:action=display&name=psutil#downloads 找到psutil-5.2.2.tar.gz 点击即可下载 shell # tar xzvf psutil-5.2.2.tar.gz shell # cd psutil-5.2.2 shell # python setup.py install 2.使用psutil获取内存信息 终端输入python shell # python Pytho

Linux下java获取CPU、内存、磁盘IO、网络带宽使用率

一.CPU 使用proc文件系统,"proc文件系统是一个伪文件系统,它只存在内存当中,而不占用外存空间.它以文件系统的方式为访问系统内核数据的操作提供接口.用户和应用程序可以通过proc得到系统的信息,并可以改变内核的某些参数." 从/proc文件系统获取cpu使用情况:    cat /proc/stat 在Linux的内核中,有一个全 局变量:Jiffies. Jiffies代表时间.它的单位随硬件平台的不同而不同.系统里定义了一个常数HZ,代表每秒种最小时间间隔的数目.这样ji