Android项目实战--手机卫士28--读取进程的信息并显示出来

今天呢，我们就继续我们的进程管理啦，昨天我们就讲到了拿到进程数目，以及可用的内存，那么今天，我们就把那些进程一个个的显示出来，

但在做今天这个之前，我先给大家提个醒，我觉得那个程序锁的界面有点不好看，所以就修改了一下，大家到时可以看看源码，我们就先把今天要做的，和那个程序锁的给大家看看先吧

大家可以看到，我们这个界面也是挺简单的，有一个标签把系统的进程和用户的进程给区分开来，所以我们到时在显示在listview的时候就要小心处理了，

首先，我们要先新建一个model类，用来存放那些进程的信息

com.xiaobin.security.domain.TaskInfo

package com.xiaobin.security.domain;

import android.graphics.drawable.Drawable;

public class TaskInfo
{
private String name;
private Drawable icon;
private int id;
//以KB作为单位
private int memory;
private boolean isCheck;
private String packageName;

//是否为系统进程
private boolean isSystemProcess;

public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Drawable getIcon()
{
return icon;
}
public void setIcon(Drawable icon)
{
this.icon = icon;
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public boolean isCheck()
{
return isCheck;
}
public void setCheck(boolean isCheck)
{
this.isCheck = isCheck;
}
public String getPackageName()
{
return packageName;
}
public void setPackageName(String packageName)
{
this.packageName = packageName;
}
public int getMemory()
{
return memory;
}
public void setMemory(int memory)
{
this.memory = memory;
}
public boolean isSystemProcess()
{
return isSystemProcess;
}
public void setSystemProcess(boolean isSystemProcess)
{
this.isSystemProcess = isSystemProcess;
}

}

好啦，写完model类之后，我们就要写一个类来读取我们的进程信息啦

com.xiaobin.security.engine.TaskInfoProvider

package com.xiaobin.security.engine;

import java.util.ArrayList;
import java.util.List;

import android.app.ActivityManager;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.os.Debug.MemoryInfo;

import com.xiaobin.security.domain.TaskInfo;

public class TaskInfoProvider
{
private PackageManager packageManager;
private ActivityManager activityManager;

public TaskInfoProvider(Context context)
{
packageManager = context.getPackageManager();
activityManager = (ActivityManager) context
.getSystemService(Context.ACTIVITY_SERVICE);
}

public List<TaskInfo> getAllTask(
List<RunningAppProcessInfo> runningAppProcessInfos)
{
List<TaskInfo> taskInfos = new ArrayList<TaskInfo>();
for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcessInfos)
{
TaskInfo taskInfo = new TaskInfo();
int id = runningAppProcessInfo.pid;
taskInfo.setId(id);
String packageName = runningAppProcessInfo.processName;
taskInfo.setPackageName(packageName);
try
{
// ApplicationInfo是AndroidMainfest文件里面整个Application节点的封装
ApplicationInfo applicationInfo = packageManager
.getPackageInfo(packageName, 0).applicationInfo;
// 应用的图标
Drawable icon = applicationInfo.loadIcon(packageManager);
taskInfo.setIcon(icon);
// 应用的名字
String name = applicationInfo.loadLabel(packageManager)
.toString();
taskInfo.setName(name);

//设置是否为系统应用
taskInfo.setSystemProcess(!filterApp(applicationInfo));

// 可以返回一个内存信息的数组，传进去的id有多少个，就返回多少个对应id的内存信息
MemoryInfo[] memoryInfos = activityManager
.getProcessMemoryInfo(new int[] { id });
// 拿到占用的内存空间
int memory = memoryInfos[0].getTotalPrivateDirty();
taskInfo.setMemory(memory);
taskInfos.add(taskInfo);
taskInfo = null;
}
catch (Exception e)
{
e.printStackTrace();
}
}
return taskInfos;
}

// 判断某一个应用程序是不是用户的应用程序，如果是返回true，否则返回false
public boolean filterApp(ApplicationInfo info)
{
// 有些系统应用是可以更新的，如果用户自己下载了一个系统的应用来更新了原来的，
// 它就不是系统应用啦，这个就是判断这种情况的
if ((info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0)
{
return true;
}
else if ((info.flags & ApplicationInfo.FLAG_SYSTEM) == 0)// 判断是不是系统应用
{
return true;
}
return false;
}

}

读取进程的信息，其实也很简单的，我们上一次已经拿到了RunningAppProcessInfo的集合啦，那么我们只要遍历这个集合，那就可以拿到这些进程啦，

那么，我们就可以读取到它们的processName字段啦，其实这个字段就是这个应用的包名啦，那么，拿到了包名之后，我们就可以拿到很多信息的啦。

如上面写到的，通过PackageManager来拿到一个applicationInfo，拿到这个对象也好办啦，什么应用名字啦，图标啦，都可以拿到啦，这些我们之前在程序锁啊，应用管理这些都写过啦，上面也再写了一次，当复习啦。

接下来，我们就要读取这个进程占用的内存啦，其实这个操作也很简单啦，就是通过ActivityManager对象来调用它里面的方法getProcessMemoryInfo，通过传递

一个id的数组进去，就可以拿到，对应id数组里面的占用内存信息啦，所以还是挺简单的。

大家还会看到，我们上面有个方法，就是判断是不是系统应用的，其实这个方法，我们之前在应用管理那里也有写过的，但是我当时没怎么说，造成了不少人的误解，那我今天就和大家说一下吧

我们拿到的ApplicationInfo对象里面有个flags，就是标记我们应用的类别的，如FLAG_SYSTEM就是一个系统应用啦，FLAG_UPDATED_SYSTEM_APP就是一个可升级的系统应用啦，但如果用户把它升级了，那么，就应该把它当成是用户的应用的啦，所以我们上面就返回true啦

好啦，写完这个读取进程信息的类之后，我们就要回到我们的界面，显示出来的啦

因为我们读取这些信息都是很久的，所以我们就和程序锁啊，应用管理这些一样，用一个线程来加载这些东西，并显示一个进度条

private void initData()
{
//因为这个title是要显示当前进程数目和可用内存的，所以我们每次在这里都调用一下，以更新数据
initTitle();
ll_process_load.setVisibility(View.VISIBLE);
new Thread(new Runnable()
{
@Override
public void run()
{
taskInfoProvider = new TaskInfoProvider(ProcessManagerActivity.this);
taskInfos = taskInfoProvider.getAllTask(runningAppProcessInfos);

Message msg = new Message();
msg.what = LOAD_FINISH;
handler.sendMessage(msg);
}
}).start();
}

完成加载之后，就会发送一个消息给handler，然后就进来显示的操作的

private Handler handler = new Handler()
{
public void handleMessage(Message msg) 
{
switch(msg.what)
{
case LOAD_FINISH : 
ll_process_load.setVisibility(View.INVISIBLE);
adapter = new TaskInfoAdapter();
lv_process_list.setAdapter(adapter);
break;

default : 
break;
}
}
};

那么，接下来，我们就是要进行我们最麻烦的那个操作啦，就是listview的操作啦，也就是adapter的编写啦

因为我们要区分系统进程和用户进程嘛，还要加两个标签，所以那就处理起来有点麻烦的啦

首先，我们要区分系统进程，和用户进程，那么我们就用两个list来分别存放它们，在adapter的构造方法里面，对它们进行初始化

public TaskInfoAdapter()
{
//存放用户的应用进程
userTaskInfo = new ArrayList<TaskInfo>();
//存放系统的应用进程
systemTaskInfo = new ArrayList<TaskInfo>();

for(TaskInfo taskInfo : taskInfos)
{
if(taskInfo.isSystemProcess())
{
systemTaskInfo.add(taskInfo);
}
else
{
userTaskInfo.add(taskInfo);
}
}
}

因为我们要加两个标签来显示是用户进程还是系统进程嘛（也就是两个TextView），所以返回的条目就要加2啦

@Override
public int getCount()
{
//加上两个标签，一个是系统标签，一个是用户标签
return taskInfos.size() + 2;
}

因为多了两个条目，所以返回值也要特别处理一下啦

@Override
public Object getItem(int position)
{
if(position == 0)
{
return 0;//显示成用户应用的标签
}
else if(position <= userTaskInfo.size())
{
return userTaskInfo.get(position - 1);//用户应用进程的条目
}
else if(position == userTaskInfo.size() + 1)
{
return position;//显示成系统进程的标签
}
else if(position <= taskInfos.size() + 2)
{
//系统应用进程的条目
return systemTaskInfo.get(position - userTaskInfo.size() - 2);
}
else
{
return position;
}
}

最后，就是我们的getView方法啦，这个是非常的重要的，关系到我们的显示

@Override
public View getView(int position, View convertView, ViewGroup parent)
{
View view;
TaskInfoViews views;
TaskInfo taskInfo;
if(position == 0)
{
//显示成用户应用的标签
return newTextView("用户进程(" + userTaskInfo.size() + ")");
}
else if(position <= userTaskInfo.size())
{
//用户应用进程的条目
taskInfo = userTaskInfo.get(position - 1);
}
else if(position == userTaskInfo.size() + 1)
{
//显示成系统进程的标签
return newTextView("系统进程(" +  systemTaskInfo.size() + ")");
}
else if(position <= taskInfos.size() + 2)
{
//系统应用进程的条目
taskInfo = systemTaskInfo.get(position - userTaskInfo.size() - 2);
}
else
{
taskInfo = new TaskInfo();
}
if(convertView == null || convertView instanceof TextView)
{
view = View.inflate(ProcessManagerActivity.this, R.layout.process_manager_item, null);

views = new TaskInfoViews();
views.iv_process_icon = (ImageView) view.findViewById(R.id.iv_process_manager_icon);
views.tv_process_name = (TextView) view.findViewById(R.id.tv_process_manager_name);
views.tv_process_memory = (TextView) view.findViewById(R.id.tv_process_manager_memory);
views.cb_process_state = (CheckBox) view.findViewById(R.id.cb_process_manager_state);
view.setTag(views);
}
else
{
view = convertView;
views = (TaskInfoViews) view.getTag();
}
views.iv_process_icon.setImageDrawable(taskInfo.getIcon());
views.tv_process_name.setText(taskInfo.getName());
views.tv_process_memory.setText("占用内存：" + TextFormater.getSizeFromKB(taskInfo.getMemory()));
views.cb_process_state.setChecked(taskInfo.isCheck());
return view;
}

在里面，我们用到一个生成TextView的方法

private TextView newTextView(String title)
{
TextView tv_title = new TextView(ProcessManagerActivity.this);
tv_title.setText(title);
return tv_title;
}

好啦，这个adapter比较复杂，不像我们之前写的那样，直接显示就行啦，这次，多了很多判断，但实际开发中，这种情况是很常见的，所以大家最好懂得这样来定义自己复杂的adapter，不然就会很麻烦的了

如果对上面代码有什么不明白的，可以说出来

好啦，写到这里，我们的逻辑就基本上完成的啦，下面把activity的完整类和布局文件粘出来

process_manager.item.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="65dip"
    android:background="@drawable/item_background_selector">

    <ImageView 
        android:id="@+id/iv_process_manager_icon"
        android:layout_width="60dip"
        android:layout_height="60dip"
        android:layout_alignParentLeft="true"
        android:scaleType="fitXY"
        android:src="@drawable/app"
        android:contentDescription="@string/hello_world"/>

    <LinearLayout 
        android:layout_width="wrap_content"
        android:layout_height="65dip"
        android:layout_toRightOf="@id/iv_process_manager_icon"
        android:layout_marginLeft="10dip"
        android:gravity="center_vertical"
        android:orientation="vertical">

    <TextView 
        android:id="@+id/tv_process_manager_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp"
        android:textColor="#ff000000"
        android:text="@string/hello_world"/>

    <TextView 
        android:id="@+id/tv_process_manager_memory"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="16sp"
        android:textColor="#ff000000"
        android:text="@string/hello_world"/>

    </LinearLayout>

    <CheckBox 
        android:id="@+id/cb_process_manager_state"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:layout_marginRight="10dip"/>

</RelativeLayout>

com.xiaobin.security.ui.ProcessManagerActivity

package com.xiaobin.security.ui;

import java.util.ArrayList;
import java.util.List;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.ActivityManager.MemoryInfo;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;

import com.xiaobin.security.R;
import com.xiaobin.security.domain.TaskInfo;
import com.xiaobin.security.engine.TaskInfoProvider;
import com.xiaobin.security.utils.TextFormater;

public class ProcessManagerActivity extends Activity implements OnClickListener
{
private static final int LOAD_FINISH = 1;

private TextView tv_process_count;
private TextView tv_process_memory;

private LinearLayout ll_process_load;
private ListView lv_process_list;
private Button bt_process_clear;
private Button bt_process_setting;

private ActivityManager activityManager;
private List<RunningAppProcessInfo> runningAppProcessInfos;
private TaskInfoProvider taskInfoProvider;
private List<TaskInfo> taskInfos;
private TaskInfoAdapter adapter;

@SuppressLint("HandlerLeak")
private Handler handler = new Handler()
{
public void handleMessage(Message msg)
{
switch (msg.what)
{
case LOAD_FINISH:
ll_process_load.setVisibility(View.INVISIBLE);
adapter = new TaskInfoAdapter();
lv_process_list.setAdapter(adapter);
break;

default:
break;
}
}
};

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);

activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);

// 请求一个自己定义的title，但有一些Android系统是被修改过的，
// 所以有可能是无法请求的，如乐Phone或小米的手机，这些系统是被修改过的，
// 所以就要判断一下是否请求成功
boolean flags = requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);

setContentView(R.layout.process_manager);

if (flags)
{
// 设置自定义的title
getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE,
R.layout.process_manager_title);
}

tv_process_count = (TextView) findViewById(R.id.tv_process_count);
tv_process_memory = (TextView) findViewById(R.id.tv_process_memory);

ll_process_load = (LinearLayout) findViewById(R.id.ll_process_load);
lv_process_list = (ListView) findViewById(R.id.lv_process_list);
bt_process_clear = (Button) findViewById(R.id.bt_process_clear);
bt_process_setting = (Button) findViewById(R.id.bt_process_setting);
bt_process_clear.setOnClickListener(this);
bt_process_setting.setOnClickListener(this);

initData();
}

@Override
public void onClick(View v)
{
switch (v.getId())
{
case R.id.bt_process_clear:
break;

case R.id.bt_process_setting:
break;

default:
break;
}
}

private void initData()
{
// 因为这个title是要显示当前进程数目和可用内存的，所以我们每次在这里都调用一下，以更新数据
initTitle();
ll_process_load.setVisibility(View.VISIBLE);
new Thread(new Runnable()
{
@Override
public void run()
{
taskInfoProvider = new TaskInfoProvider(
ProcessManagerActivity.this);
taskInfos = taskInfoProvider.getAllTask(runningAppProcessInfos);

Message msg = new Message();
msg.what = LOAD_FINISH;
handler.sendMessage(msg);
}
}).start();
}

// 拿到当前运行的进程数目
private int getRunningAppCount()
{
runningAppProcessInfos = activityManager.getRunningAppProcesses();
return runningAppProcessInfos.size();
}

// 拿到系统剩余的内存
private String getAvailMemory()
{
// new一个内存的对象
MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
// 拿到现在系统里面的内存信息
activityManager.getMemoryInfo(memoryInfo);
// 拿到有效的内存空间
long size = memoryInfo.availMem;
return TextFormater.dataSizeFormat(size);
}

// 设置title的信息
private void initTitle()
{
tv_process_count.setText("进程数目：" + getRunningAppCount());
tv_process_memory.setText("剩余内存：" + getAvailMemory());
}

// ===========================================================================

private class TaskInfoAdapter extends BaseAdapter
{
private List<TaskInfo> userTaskInfo;
private List<TaskInfo> systemTaskInfo;

public TaskInfoAdapter()
{
// 存放用户的应用进程
userTaskInfo = new ArrayList<TaskInfo>();
// 存放系统的应用进程
systemTaskInfo = new ArrayList<TaskInfo>();

for (TaskInfo taskInfo : taskInfos)
{
if (taskInfo.isSystemProcess())
{
systemTaskInfo.add(taskInfo);
}
else
{
userTaskInfo.add(taskInfo);
}
}
}

@Override
public int getCount()
{
// 加上两个标签，一个是系统标签，一个是用户标签
return taskInfos.size() + 2;
}

@Override
public Object getItem(int position)
{
if (position == 0)
{
return 0; // 显示成用户应用的标签
}
else if (position <= userTaskInfo.size())
{
return userTaskInfo.get(position - 1); // 用户应用进程的条目
}
else if (position == userTaskInfo.size() + 1)
{
return position; // 显示成系统进程的标签
}
else if (position <= taskInfos.size() + 2)
{
// 系统应用进程的条目
return systemTaskInfo.get(position - userTaskInfo.size() - 2);
}
else
{
return position;
}
}

@Override
public long getItemId(int position)
{
return position;
}

@Override
public View getView(int position, View convertView, ViewGroup parent)
{
View view;
TaskInfoViews views;
TaskInfo taskInfo;
if (position == 0)
{
// 显示成用户应用的标签
return newTextView("用户进程(" + userTaskInfo.size() + ")");
}
else if (position <= userTaskInfo.size())
{
// 用户应用进程的条目
taskInfo = userTaskInfo.get(position - 1);
}
else if (position == userTaskInfo.size() + 1)
{
// 显示成系统进程的标签
return newTextView("系统进程(" + systemTaskInfo.size() + ")");
}
else if (position <= taskInfos.size() + 2)
{
// 系统应用进程的条目
taskInfo = systemTaskInfo.get(position - userTaskInfo.size()
- 2);
}
else
{
taskInfo = new TaskInfo();
}
if (convertView == null || convertView instanceof TextView)
{
view = View.inflate(ProcessManagerActivity.this,
R.layout.process_manager_item, null);

views = new TaskInfoViews();
views.iv_process_icon = (ImageView) view
.findViewById(R.id.iv_process_manager_icon);
views.tv_process_name = (TextView) view
.findViewById(R.id.tv_process_manager_name);
views.tv_process_memory = (TextView) view
.findViewById(R.id.tv_process_manager_memory);
views.cb_process_state = (CheckBox) view
.findViewById(R.id.cb_process_manager_state);
view.setTag(views);
}
else
{
view = convertView;
views = (TaskInfoViews) view.getTag();
}
views.iv_process_icon.setImageDrawable(taskInfo.getIcon());
views.tv_process_name.setText(taskInfo.getName());
views.tv_process_memory.setText("占用内存："
+ TextFormater.getSizeFromKB(taskInfo.getMemory()));
views.cb_process_state.setChecked(taskInfo.isCheck());
return view;
}

private TextView newTextView(String title)
{
TextView tv_title = new TextView(ProcessManagerActivity.this);
tv_title.setText(title);
return tv_title;
}

}

private class TaskInfoViews
{
ImageView iv_process_icon;
TextView tv_process_name;
TextView tv_process_memory;
CheckBox cb_process_state;
}

}

好啦，今天就讲到这里啦，有什么不明白的，可以留言

最后，和大家说一下

为了方便大家的交流，我创建了一个群，这样子大家有什么疑问也可以在群上交流

群号是298440981

今天源码下载

秒客网

Android项目实战--手机卫士28--读取进程的信息并显示出来

相关文章