通过android NDK 取得内存使用情况，和CPU占用

AppleDragon

头文件

 

1. #ifndef __ANDROIDSYSINFO_H__
   
2. #define __ANDROIDSYSINFO_H__
   
3. 
   
   
4. 
   #include <stdio.h>
   
5. 
   #include <string.h>
   
6. 
   #include <stdlib.h>
   
7. 
   #include <fcntl.h>
   
8. 
   #include <android/log.h>
   
9. 
   #include <unistd.h>
   
10. 
    
    
11. 
    typedef unsigned long DWORD;
    
12. 
    
    
13. 
    struct systemCPUdata
    
14. 
    {
    
15. 
      unsigned long utime,stime,cutime,cstime;
    
16. 
      unsigned long vmem, rmem;
    
17. 
      char pname[255];
    
18. 
    };
    
19. 
    
    
20. 
    class AndroidMemInfo
    
21. 
    {
    
22. 
    public:
    
23. 
        AndroidMemInfo();
    
24. 
        ~AndroidMemInfo();    
    
25. 
        void GetTotalPhys();
    
26. 
        void GetAvailPhys();
    
27. 
        DWORD ullTotalPhys;
    
28. 
        DWORD ullAvailPhys;
    
29. 
        
    
30. 
    private:
    
31. 
        int m_memFile;
    
32. 
        
    
33. 
    };
    
34. 
    
    
35. 
    class AndroidCpuUsage
    
36. 
    {
    
37. 
    public:
    
38. 
        AndroidCpuUsage();
    
39.     struct timeval m_lasttime,m_nowtime;
    
40. 
        struct systemCPUdata m_lastproc, m_nowproc;
    
41. 
        void getProcCPUStat(struct systemCPUdata *proc, int pid);
    
42. 
        DWORD GetUsedCpu();
    
43. 
    };
    
44. 
    #endif //__ANDROIDSYSINFO_H__

 

CPP 文件

 

1. #include "AndroidSysInfo.h"
   
2. 
   #define  LOGW(x...)  __android_log_print(ANDROID_LOG_ERROR,"ANDROIDSYSINFO",x)
   
3. 
   
   
4. 
   AndroidMemInfo::AndroidMemInfo()
   
5. 
   {
   
6. 
       m_memFile = -1;
   
7. 
         ullTotalPhys = 0;
   
8. 
       ullAvailPhys = 0;
   
9. 
   }
   
10. 
    
    
11. 
    AndroidMemInfo::~AndroidMemInfo()
    
12. 
    {
    
13. 
    }
    
14. 
    
    
15. 
    void AndroidMemInfo::GetAvailPhys()
    
16. 
    {
    
17. 
        m_memFile = open("/proc/meminfo", O_RDONLY);
    
18. 
    
    
19. 
        if (m_memFile < 0)
    
20. 
        {
    
21. 
            LOGW("Unable to open /proc/meminfo");
    
22. 
        }
    
23. 
    
    
24. 
        char buffer[256];
    
25. 
        const int len = read(m_memFile, buffer, sizeof(buffer)-1);
    
26. 
        close(m_memFile);
    
27. 
    
    
28. 
        if (len < 0)
    
29. 
        {
    
30. 
            LOGW("Unable to read /proc/meminfo");
    
31. 
        }
    
32. 
        buffer[len] = 0;
    
33. 
    
    
34. 
        int numFound = 0;
    
35. 
    
    
36. 
        static const char* const sums[] = { "MemFree:", "Cached:", NULL };
    
37. 
        static const int sumsLen[] = { strlen("MemFree:"), strlen("Cached:"), NULL };
    
38. 
    
    
39. 
        char* p = buffer;
    
40. 
        while (*p && numFound < 2)
    
41. 
        {
    
42. 
            int i = 0;
    
43. 
            while (sums[i])
    
44. 
            {
    
45. 
                if (strncmp(p, sums[i], sumsLen[i]) == 0)
    
46. 
                {
    
47. 
                    p += sumsLen[i];
    
48. 
                    while (*p == ' ') p++;
    
49. 
                    char* num = p;
    
50. 
                    while (*p >= '0' && *p <= '9') p++;
    
51. 
                    if (*p != 0)
    
52. 
                    {
    
53. 
                        *p = 0;
    
54. 
                        p++;
    
55. 
                        if (*p == 0) p--;
    
56. 
                    }
    
57. 
                    ullAvailPhys += atoll(num) * 1024;
    
58. 
                    numFound++;
    
59. 
                    break;
    
60. 
                }
    
61. 
                i++;
    
62. 
            }
    
63. 
            p++;
    
64. 
        }
    
65. 
    }
    
66. 
    
    
67. 
    void AndroidMemInfo::GetTotalPhys()
    
68. 
    {
    
69. 
        m_memFile = open("/proc/meminfo", O_RDONLY);
    
70. 
    
    
71. 
        if (m_memFile < 0)
    
72. 
        {
    
73. 
            LOGW("Unable to open /proc/meminfo");
    
74. 
        }
    
75. 
    
    
76. 
        char buffer[256];
    
77. 
        const int len = read(m_memFile, buffer, sizeof(buffer)-1);
    
78. 
        close(m_memFile);
    
79. 
    
    
80. 
        if (len < 0)
    
81. 
        {
    
82. 
            LOGW("Unable to read /proc/meminfo");
    
83. 
        }
    
84. 
        
    
85. 
        buffer[len] = 0;
    
86. 
        
    
87. 
        static const char* const sums[] = { "MemTotal:", NULL };
    
88. 
        static const int sumsLen[] = { strlen("MemTotal:"), NULL };
    
89. 
    
    
90. 
        char* p = buffer;
    
91. 
        while (*p )
    
92. 
        {
    
93. 
            int i = 0;
    
94. 
            while (sums[i])
    
95. 
            {
    
96. 
                if (strncmp(p, sums[i], sumsLen[i]) == 0)
    
97. 
                {
    
98. 
                    p += sumsLen[i];
    
99. 
                    while (*p == ' ') p++;
    
100. 
                     char* num = p;
     
101. 
                     while (*p >= '0' && *p <= '9') p++;
     
102. 
                     if (*p != 0)
     
103. 
                     {
     
104. 
                         *p = 0;
     
105. 
                         p++;
     
106. 
                         if (*p == 0) p--;
     
107. 
                     }
     
108. 
                     ullTotalPhys += atoll(num) * 1024;
     
109. 
                     break;
     
110. 
                 }
     
111. 
                 i++;
     
112. 
             }
     
113. 
             p++;
     
114. 
         }
     
115. 
     }
     
116. 
     
     
117. 
     AndroidCpuUsage::AndroidCpuUsage()
     
118. 
     {
     
119. 
         timerclear(&m_lasttime);
     
120. 
         timerclear(&m_nowtime);
     
121. 
         
     
122. 
         m_lastproc.utime = 0;
     
123. 
         m_lastproc.stime = 0;
     
124. 
         m_lastproc.cutime = 0;
     
125. 
         m_lastproc.cstime = 0;
     
126. 
         
     
127. 
         m_nowproc.utime = 0;
     
128. 
         m_nowproc.stime = 0;
     
129. 
         m_nowproc.cutime = 0;
     
130. 
         m_nowproc.cstime = 0;
     
131. 
     }
     
132. 
     
     
133. 
     void AndroidCpuUsage::getProcCPUStat(struct systemCPUdata *proc, int pid)
     
134. 
     {
     
135. 
       FILE *file;
     
136. 
       unsigned long itemp;
     
137. 
       char ctemp;
     
138. 
       char line[255];
     
139. 
     
     
140. 
       sprintf(line, "/proc/%d/stat", pid);
     
141. 
       file = fopen(line, "r");
     
142. 
       if (file == NULL)
     
143. 
       {
     
144. 
             LOGW("AndroidCpuUsage Error: process not found!\n");
     
145. 
             return;
     
146. 
       }
     
147. 
       fgets(line, 255, file);
     
148. 
       fclose(file);
     
149. 
       sscanf(line, "%d %s %c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu "
     
150. 
                "%ld %ld %ld %ld %ld %ld %lu %lu %ld",
     
151. 
                (int*)&itemp, proc->pname, &ctemp, (int*)&itemp, (int*)&itemp, (int*)&itemp, (int*)&itemp, (int*)&itemp,
     
152. 
                &itemp, &itemp, &itemp, &itemp, &itemp, &proc->utime, &proc->stime,
     
153. 
                &proc->cutime, &proc->cstime, &itemp, &itemp, &itemp, &itemp, &itemp, &proc->vmem, &proc->rmem
     
154. 
                );
     
155. 
     
     
156. 
     }
     
157. 
     
     
158. 
     DWORD AndroidCpuUsage::GetUsedCpu()
     
159. 
     {
     
160. 
     
     
161. 
         gettimeofday(&m_nowtime, NULL);
     
162. 
         
     
163. 
         getProcCPUStat(&m_nowproc,getpid());
     
164. 
         DWORD percent = 0;
     
165. 
         
     
166. 
         // for the first time ,it's always return 0;
     
167. 
         if ( m_lasttime.tv_sec == 0 && m_lasttime.tv_usec == 0)
     
168. 
         {
     
169. 
             percent = 0;
     
170. 
         }
     
171. 
         else
     
172. 
         {
     
173. 
             DWORD usedtime = m_nowproc.utime + m_nowproc.stime - m_lastproc.utime - m_lastproc.stime;
     
174. 
             percent = usedtime/(m_nowtime.tv_sec - m_lasttime.tv_sec);
     
175. 
         }
     
176. 
         m_lastproc.utime = m_nowproc.utime;
     
177. 
         m_lastproc.stime = m_nowproc.stime;
     
178. 
         m_lastproc.cutime = m_nowproc.cutime;
     
179. 
         m_lastproc.cstime = m_nowproc.cstime;
     
180. 
         
     
181. 
         m_lasttime.tv_sec = m_nowtime.tv_sec;
     
182. 
         m_lasttime.tv_usec = m_nowtime.tv_usec;
     
183. 
         
     
184. 
         char tchBuf[128] = "\0";
     
185. 
         memset(tchBuf, 0, sizeof(tchBuf));
     
186. 
         snprintf(tchBuf, sizeof(tchBuf), "AndroidCpuUsage GetUsedCpu:%d",percent);
     
187. 
         
     
188. 
         LOGW(tchBuf);
     
189. 
         return percent;
     
190. 
     }