Android Studio 任务管理器功能思路和代码（一）

首先创建并注册TaskManager主页面，其次绑定task_manager的layout，由于是ListView所以需要一个task_item页面来进行列表元素设置，一下是两个页面代码

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:id="@+id/task_manager">

<TextView
style="@style/text_title_style"
android:text="任 务 管 理" />

<View style="@style/view_divide_line_style" />

<RelativeLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="5dip">

<TextView
android:id="@+id/tv_task_manager_task_count"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="15dp"
android:text="进程数:20"/>

<TextView
android:id="@+id/tv_task_manager_task_memory"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentRight="true"
android:textSize="15dp"
android:text="可用/总内存:50MB/700MB"/>
</RelativeLayout>

<RelativeLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<Button
android:id="@+id/bt_task_manager_noSelect"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="取消"
android:layout_alignParentRight="true"
android:textSize="20dp"
/>
<Button
android:id="@+id/bt_task_manager_selectAll"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="全选"
android:layout_toLeftOf="@id/bt_task_manager_noSelect"
android:textSize="20dp"
/>

</RelativeLayout>

<FrameLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent" >

<!--
android:cacheColorHint="#00000000" 缓存的颜色  默认是黄色
android:divider="#00ffffff" 分割线
android:dividerHeight="3.0dip" 分割线的宽度
-->
<ListView
android:id="@+id/lv_taskmanager"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:cacheColorHint="#00000000"
android:divider="#fff"
android:fastScrollEnabled="true"
android:dividerHeight="1.0dip"
android:paddingLeft="3.0dip"
android:paddingRight="3.0dip" />

<RelativeLayout
android:id="@+id/rl_loading"
android:layout_width="fill_parent"
android:layout_height="fill_parent" >

<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="vertical"
android:layout_centerInParent="true"
android:id="@+id/linearLayout">

<ProgressBar
android:id="@+id/pb"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
/>

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="10dip"
android:text="正在加载应用程序。。"
android:textColor="#fff"
android:textSize="22sp" />
</LinearLayout>

</RelativeLayout>
</FrameLayout>

</LinearLayout>

因为是ListView所以绑定适配器TaskManagerAdapter

class TaskManagerAdapter extends BaseAdapter {
private LayoutInflater mInflater;
public TaskManagerAdapter() {
// TODO Auto-generated constructor stub
mInflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}
public int getCount() {
// TODO Auto-generated method stub
return taskInfos.size();
}

public Object getItem(int position) {
// TODO Auto-generated method stub
return taskInfos.get(position);
}

public long getItemId(int position) {
// TODO Auto-generated method stub
return position;
}

public View getView(int position, View convertView, ViewGroup parent) {
// TODO Auto-generated method stub
View view = null;
ViewHolder holder = null;
if(convertView != null){
view = convertView;
holder = (ViewHolder) view.getTag();
}else{
view = mInflater.inflate(R.layout.task_item, null);
holder = new ViewHolder();
holder.iv_task_manager_icon = (ImageView) view.findViewById(R.id.iv_task_manager_icon);
holder.tv_task_manager_name = (TextView) view.findViewById(R.id.tv_task_manager_name);
holder.tv_task_manager_memory = (TextView) view.findViewById(R.id.tv_task_manager_memory);

}

TaskInfo taskInfo = taskInfos.get(position);

holder.iv_task_manager_icon.setImageDrawable(taskInfo.getTask_icon());
holder.tv_task_manager_name.setText(taskInfo.getTask_name());
holder.tv_task_manager_memory.setText("占用的内存:" + TextFormat.formatByte(taskInfo.getTask_memory()*1024));

return view;
}
}
static class ViewHolder{
ImageView iv_task_manager_icon;
TextView tv_task_manager_name;
TextView tv_task_manager_memory;

}

其次就是获取应用程序的信息了，所以需要一个TaskInfo类

public class TaskInfo {

private Drawable task_icon;
private String task_name;
private String packageName;
private int pid;
private long task_memory;
public TaskInfo() {
super();
// TODO Auto-generated constructor stub
}
public TaskInfo(Drawable task_icon, String task_name, String packageName,
int pid, long task_memory) {
super();
this.task_icon = task_icon;
this.task_name = task_name;
this.packageName = packageName;
this.pid = pid;
this.task_memory = task_memory;
}

public Drawable getTask_icon() {
return task_icon;
}
public void setTask_icon(Drawable task_icon) {
this.task_icon = task_icon;
}
public String getTask_name() {
return task_name;
}
public void setTask_name(String task_name) {
this.task_name = task_name;
}
public String getPackageName() {
return packageName;
}
public void setPackageName(String packageName) {
this.packageName = packageName;
}
public int getPid() {
return pid;
}
public void setPid(int pid) {
this.pid = pid;
}
public long getTask_memory() {
return task_memory;
}
public void setTask_memory(long task_memory) {
this.task_memory = task_memory;
}
@Override
public String toString() {
return "TaskInfo [task_icon=" + task_icon + ", task_name=" + task_name
+ ", packageName=" + packageName + ", pid=" + pid
+ ", task_memory=" + task_memory + "]";
}

}

接下来就是逻辑功能类TaskUtil的编写了，分别是获取运行的程序的数量，获取运行的程序信息，获取系统可用内存，获取系统总内存。

public class TaskUtil {

/**
* 得到当前正在运行的进程的数量
* @param context
* @return*/

public static int getRuninngAppProcessInfoSize(Context context){
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
return ProcessManager.getRunningAppProcesses().size();
//        return ActivityManager.
}

/**
* 得到当前系统的总内存
* @param
* @return*/

public static long getTotalMemSize() {
long size=0;
File file = new File("/proc/meminfo");
try {
BufferedReader buffer = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String memInfo = buffer.readLine();
int startIndex = memInfo.indexOf(":");
int endIndex = memInfo.indexOf("k");
memInfo = memInfo.substring(startIndex + 1, endIndex).trim();
size = Long.parseLong(memInfo);
size *= 1024;
buffer.close();
} catch (java.io.IOException e) {
e.printStackTrace();
}
return size;
}

/**
* 得到当前系统的可用内存
* @param
* @return*/
public static long getAvailMem(Context context){
ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
ActivityManager.MemoryInfo outInfo = new ActivityManager.MemoryInfo();
am.getMemoryInfo(outInfo);
long availMem = outInfo.availMem/1; // byte
return availMem;
}

public static long getAviableMemSize() {
long size=0;
File file = new File("/proc/meminfo");
try {
BufferedReader buffer = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String memInfos=new String();
String memInfo = null;
int i=0;
while ((memInfos=buffer.readLine())!=null){
i++;
if (i==2){
memInfo = memInfos;
}

}
int startIndex = memInfo.indexOf(":");
int endIndex = memInfo.indexOf("k");
memInfo = memInfo.substring(startIndex + 1, endIndex).trim();
size = Long.parseLong(memInfo);
buffer.close();
} catch (java.io.IOException e) {
e.printStackTrace();
}

return size;
}

//得到进程所有的信息
public static List<TaskInfo> getTaskInfos(Context context){
List<TaskInfo> taskInfos = new ArrayList<TaskInfo>();
//应用程序包管理器
PackageManager pm = context.getPackageManager();
//应用程序管理器
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<AndroidAppProcess> runningAppProcessInfos = ProcessManager.getRunningAppProcesses();
for (AndroidAppProcess info:runningAppProcessInfos){
TaskInfo taskInfo = new TaskInfo();
String packageName = info.name;
taskInfo.setPackageName(packageName);
try {
ApplicationInfo appInfo = pm.getApplicationInfo(packageName,0);
Drawable task_icon = appInfo.loadIcon(pm);
String task_name = appInfo.loadLabel(pm).toString();
if(task_icon == null){
taskInfo.setTask_icon(conte
b4d0
xt.getResources().getDrawable(R.drawable.tubiao));

}else {
taskInfo.setTask_icon(task_icon);
}
taskInfo.setTask_name(task_name);

}catch (Exception e){
e.printStackTrace();
// 系统内核进程 没有名称
taskInfo.setTask_name(packageName);
Drawable icon = context.getResources().getDrawable(
R.mipmap.ic_launcher);
taskInfo.setTask_icon(icon);
}

//获取程序内存
int pid = info.pid;
taskInfo.setPid(pid);
Debug.MemoryInfo[] memoryInfos = am.getProcessMemoryInfo(new int[]{info.pid});
Debug.MemoryInfo memoryInfo = memoryInfos[0];
long task_memory = memoryInfo.getTotalPrivateDirty();//KB单位
taskInfo.setTask_memory(task_memory);

if (taskInfo != null) {
taskInfos.add(taskInfo);
}
}
return taskInfos;
}
}

需要注意的是安卓5.0版本后就无法通过ActivityManager来获取运行程序信息了，需要用ProcessManager类来获取运行程序信息，所以需要通过该网页下载下面包导入才行。

http://download.csdn.net/detail/luoyangwyb/9241279

该网址是来自于一个高手的博客分享。

还有一个根据数值大小转换成不同的单位的类

public class TextFormat {
public static String formatByte(long size) {

//如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义
if (size < 1024) {
return String.valueOf(size) + "byte";
} else {
size = size / 1024;
}
//如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位
//因为还没有到达要使用另一个单位的时候
//接下去以此类推
if (size < 1024) {
return String.valueOf(size) + "KB";
} else {
size = size / 1024;
}
if (size < 1024) {
//因为如果以MB为单位的话，要保留最后1位小数，
//因此，把此数乘以100之后再取余
size = size * 100;
return String.valueOf((size / 100)) + "."
+ String.valueOf((size % 100)) + "MB";
} else {
//否则如果要以GB为单位的，先除于1024再作同样的处理
size = size * 100 / 1024;
return String.valueOf((size / 100)) + "."
+ String.valueOf((size % 100)) + "GB";
}
}
}

接下来就是最终的主页面TaskManager类的编写了。

通过onCreate方法加载页面，然后找就绑定id为监听做准备。接下来就是调用程序运行数量，再开新线程去传输加载完成新号，来通过Handler接受数据并处理页面，当通过加载完成时，调用可用内存和总内存方法，隐藏加载进度条，并显示ListView即可

public class TaskManager extends Activity {

protected static final int SUCCESS_GET_TASKINFO = 0;
private TextView tv_task_manager_task_count;
private TextView tv_task_manager_task_memory;
private RelativeLayout rl_loading;
private ListView lv_taskmanager;

private boolean isChecked;

private ActivityManager am;
private List<TaskInfo> taskInfos;

private SharedPreferences sp;
private TaskManagerAdapter mAdapter;

private LinearLayout task_manager;

private Handler mHandler = new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case SUCCESS_GET_TASKINFO:

//可用内存
String availMemStr = TextFormat.formatByte(TaskUtil.getAvailMem(getApplication()));
//总内存
String totalMemStr = TextFormat.formatByte(TaskUtil.getTotalMemSize());
tv_task_manager_task_memory.setText("可用/总内存:" + availMemStr +"/" + totalMemStr);

mAdapter = new TaskManagerAdapter();
rl_loading.setVisibility(View.GONE);
lv_taskmanager.setAdapter(mAdapter);
break;

default:
break;
}
};
};

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

setContentView(R.layout.task_manager);
tv_task_manager_task_count = (TextView) findViewById(R.id.tv_task_manager_task_count);
tv_task_manager_task_memory = (TextView) findViewById(R.id.tv_task_manager_task_memory);
rl_loading = (RelativeLayout) findViewById(R.id.rl_loading);
lv_taskmanager = (ListView) findViewById(R.id.lv_taskmanager);
task_manager = (LinearLayout) findViewById(R.id.task_manager);

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

// 进程数目
int size = TaskUtil.getRuninngAppProcessInfoSize(this);
tv_task_manager_task_count.setText("进程数：" + size);

new Thread(){
@Override
public void run() {
taskInfos = TaskUtil.getTaskInfos(getApplicationContext());

Message msg = new Message();
msg.what = SUCCESS_GET_TASKINFO;
mHandler.sendMessage(msg);
}
}.start();
}
}

今天还没有做完，仅仅完成显示运行程序的功能，并没有实现程序结束选定分类等功能。 接下来继续努力吧。