android获取task

❶ 如何获取android 进程信息

1.获取系统的可用内存和总内存。

获取系统内存中应用的信息，需要用到ActivityManager这个类，然而当你用这个类拿数据的时候你会发现，拿到的数据不正确。用这个类的API获取系统的总内存和可用内存会出现数据不正确的情况。除了这个类，Android手机中有文件描述了这些信息——/proc/meminfo。meminfo文件中详细的记录了安卓手机的一些数据，包括可用内存和总内存。附上代码：
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;
}

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();
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);
size *= 1024;
buffer.close();
} catch (java.io.IOException e) {
e.printStackTrace();
}

return size;
}

操作很简单分别是读取第一行的数据和第二行的数据，将字符串分去出，将所得值乘以1024变为byte类型。

2.获取内存中运行应用的信息

首先，自然要有一个Bean文件用于存储这些信息，之后通过ActivityManager的getRunningAppProcesses()方法得到一个RunningAppProcessInfo的List。便利这个List去除我们想要的数据，存在我们的Bean文件夹中。
public static List<TaskBean> getAllTask() {
List<TaskBean>taskList=new ArrayList<>();
List<ActivityManager.RunningAppProcessInfo>runList=UIUtils.getActManager().getRunningAppProcesses();
try {
for (ActivityManager.RunningAppProcessInfo r:runList) {
TaskBean taskBean = new TaskBean();
String processName = r.processName;
taskBean.setPackageName(processName);
PackageInfo packageInfo = UIUtils.getPacManager().getPackageInfo(processName, 0);
taskBean.setIcon(packageInfo.applicationInfo.loadIcon(UIUtils.getPacManager()));
taskBean.setName(packageInfo.applicationInfo.loadLabel(UIUtils.getPacManager()).toString());
Debug.MemoryInfo[] processInfo=UIUtils.getActManager().getProcessMemoryInfo(new int[]{r.pid});
taskBean.setMemSize(processInfo[0].getTotalPrivateDirty()*1024);
if ((packageInfo.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM)!=0){
taskBean.setSystem(true);
}else {
taskBean.setUser(true);
}
if (taskList != null) {
taskList.add(taskBean);
for (int i=0;i<taskList.size();i++) {
if (taskList.get(i).getPackageName().equals(Constants.PACKAGE_INFO)){
taskList.remove(i);
}
}
}
}
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}

return taskList;
}

好了，大功告成。当你开开心心的拿到手机上调试的时候你会发现，一个数据都没有。原来，在Android5.0之后，谷歌处于完全考虑已经弃用了通过如上方法拿到进程中的信息。那么又应该怎么做呢？
public static List<TaskBean> getTaskInfos() {
List<AndroidAppProcess> processInfos = ProcessManager.getRunningAppProcesses();

List<TaskBean> taskinfos = new ArrayList<TaskBean>();
// 遍历运行的程序,并且获取其中的信息
for (AndroidAppProcess processInfo : processInfos) {
TaskBean taskinfo = new TaskBean();
// 应用程序的包名
String packname = processInfo.name;
taskinfo.setPackageName(packname);
// 湖区应用程序的内存 信息
android.os.Debug.MemoryInfo[] memoryInfos = UIUtils.getActManager()
.getProcessMemoryInfo(new int[] { processInfo.pid });
long memsize = memoryInfos[0].getTotalPrivateDirty() * 1024L;
taskinfo.setMemSize(memsize);
taskinfo.setPackageName(processInfo.getPackageName());
try {
// 获取应用程序信息
ApplicationInfo applicationInfo = UIUtils.getPacManager().getApplicationInfo(
packname, 0);
Drawable icon = applicationInfo.loadIcon(UIUtils.getPacManager());
taskinfo.setIcon(icon);
String name = applicationInfo.loadLabel(UIUtils.getPacManager()).toString();
taskinfo.setName(name);

if ((applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
// 用户进程
taskinfo.setUser(true);
} else {
// 系统进程
taskinfo.setSystem(true);
}
} catch (PackageManager.NameNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
// 系统内核进程 没有名称
taskinfo.setName(packname);
Drawable icon = UIUtils.getContext().getResources().getDrawable(
R.drawable.ic_launcher);
taskinfo.setIcon(icon);
}
if (taskinfo != null) {
taskinfos.add(taskinfo);
for (int i=0;i<taskinfos.size();i++) {
if (taskinfos.get(i).getPackageName().equals(Constants.PACKAGE_INFO)){
taskinfos.remove(i);
}
}
}
}
return taskinfos;
}

好了，接下来只需要判断安装的版本就可以了：
int sysVersion = Integer.parseInt(Build.VERSION.SDK);
taskList = sysVersion > 21 ? TaskManagerEngine.getTaskInfos() : TaskManagerEngine.getAllTask();

好了，大功告成。数据就能正常拿到了。

❷ 新手请教，android中的task是个什么东东

task就是一连串的操作组成的一个任务链.比如:从MMS里添加附件进入Camera,再按Camera菜单进入Gallery,再从Gallery设置图片为联系人进入Contacts.......虽然起了很多个Activity,但是通常情况下他们都属于同一个task.每个Activity可以在Manifest中配置自己是否另起一个task,默认是不另起的.

❸ android task 在哪

安卓手机比起一些老的智能机是比较浪费流量的. 在关闭所有软件的流量情况下. 安卓自身每天都会产生100KB左右的流量. 流量浪费在于使用者会不会使用. 我的手机每天最多,1M不到

❹ Android中怎么切换task到前台

如果你的平台是面向Android3.0(API level
11),那么恭喜你，一个函数就可以搞定：
moveTaskToFront

http://developer.android.com/reference/android/app/ActivityManager.html#moveTaskToFront(int,
int)

如果你和我一样苦逼的在用2.2的平台，那么就要稍微麻烦点了,基本上是用taskAffinity +

FLAG_ACTIVITY_NEW_TASK +

FLAG_ACTIVITY_SINGLE_TOP。

先来看一下sdk怎么说的:
1.

taskAffinity:

SDK说，如果用带FLAG_ACTIVITY_NEW_TASK标志来启动一个activity，并且这个activity与当前运行的另一个task(A)的affinity名字相同，那么就这个activity就会在那个task(A)里启动。

Ok，到这还不行，人家没说会把Task_A带到前台，接着看另一个Flag

2.

FLAG_ACTIVITY_NEW_TASK

好了，重点来了：如果Task_A中已经有了Activity_2,这时候如果以FLAG_ACTIVITY_NEW_TASK来start
Activity_2,那么这个Task_A就会被带到前台。

好了，现在Task_A已经可以到前台了，剩下最后一步：Activity_2不能创建两次，这就要求同时使用下面这个flag:

3.

FLAG_ACTIVITY_SINGLE_TOP

如果Activity_2在Task的顶端，那么这个Activity_2就不会被再此创建，而是走onNewIntent.

至此，结合上面3个特性，问题得以解决。结合代码，流程如下：

1. 在androdiManifest.xml中添加Activity_2的taskAffinity
name与Task_A相同(也就是与Activity_1的taskAffinity名字相同)，如android:taskAffinity
= "android.task.calendar"。

2.
在Task_B启动前，Activity_1先启动Activity_2并要求返回结果,startActivityForResult().

3.
Task_B中的Activity_4取得所需数据后，保存好（intent，或其他方法），然后startActivity(Activity_2),并带上(FLAG_ACTIVITY_NEW_TASK
| FLAG_ACTIVITY_SINGLE_TOP）标志。

4. Task_A被带到前台，并且调用到Activity_2::onNewIntent().

5.
Activity_2取得之前保存的信息(从Intent或其他地方)，调用setResult()，然后finish().

6. Activity_1中的onActivityResult()响应，得到返回结果。

❺ 关于Android获取线程执行完后的结果的问题！

其实谷歌早就意识到这个问题。Message里有一个send的方法。如下
Message msg = mhandler.obtainMessage(MSG_UPDATE, imgIndex, 0);
mhandler.sendMessage(msg);

然后重写handler的 handlerMessage方法，如下：
private Handler mhandler = new Handler(){
@Override
public void handleMessage(Message msg){
if(msg.what == MSG_UPDATE){
//你要的操作...

}
}
};

基本上就是这样啦！

❻ android不同的app是不同的task吗

getRecentTasks() 最近开的task，HOME键长按会看到这个
getRunningAppProcesses() 运行中的作为app容器的process
getRunningServices() 运行中的后台服务
getRunningTasks() 运行中的任务
如果一个Activity “mainActivity”不是作为task的root activity打开的，而是被别的Task中Activity调用，那么mainActivity对应的process是开着的，这时我们是否要显示它呢？
另外，如果一个app只有service开着而在Task中不存在这个app的Activity，算不算开着呢？
所以要根据我们的项目需求进行不同的处理，现在贴出两个常用的方法：

1.获取正在运行的进程列表：

[java] view plain
/**
* 获取正在运行的程序信息
* @param context
* @return
*/
public static List<Programe> getRunningProcess(Context context){
PackagesInfo pi = PackagesInfo.getInstance(context);

ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> run = am.getRunningAppProcesses();
PackageManager pm =context.getPackageManager();
List<Programe> list = new ArrayList<Programe>();
Programe pr = new Programe();
try {
for(RunningAppProcessInfo ra : run){
if(ra.processName.equals("system") || ra.processName.equals("com.Android.phone")){ //可以根据需要屏蔽掉一些进程
continue;
}
pr = new Programe();
pr.setIcon(pi.getInfo(ra.processName).loadIcon(pm));
pr.setName(pi.getInfo(ra.processName).loadLabel(pm).toString());
Log.v("tag","icon = " + pr.getIcon() +"name=" + pr.getName());
list.add(pr);
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}

❼ 如何获取AsyncTask 异步处理的返回值

android AsyncTask<String,void,String>
第一个参数就是你要访问的地址 第二个就是进度 第三个就是返回值
AsyncTask执行完doInBackground会自己调用一下方法
@Override
protected void onPostExecute(string orderBeans) {
super.onPostExecute(orderBeans);
在这个方法中 orderBeans就是返回的值 可以在这个方法中赋值个控件

❽ android AsyncTask 怎么返回值给UI线程

可以看下以下几点即可：
1.把AsyncTask单独写成类，不是其他Activity的子类。（这个显然可以，记住，虽然AsyncTask不是某个Activity的子类，它依然只能在主线程中创建，其四大方法中的三个依然运行在主线程中，详情见后面。）2.UI线程 通过AsyncTask和服务器交互，需要根据结果 打开不同的新的activity，可以onPostExecute() 中返回值给主线程吗？（这个问句就是错的，onPostExecute()就是在主线程中执行的，不需要返回值给主线程，只需要在此方法中将结果存储在某个变量中，就可以在主线程中获取此值。例如，在AsyncTask中增加一个getResult方法）3.另外一个问题， 可以传参数给AsyncTask，然后在onPostExecute 使用其他activity的 finish() 吗？（Yes of course。这句问话依然来自你对onPostExecute 的误解，再说一次，它就在主线程中执行。而Activity的finish方法在主线程中调用显然没问题。）简单说AsyncTask，正好把上一个回答的部分结果拷贝过来给参考：
AsyncTask是一个辅助类，就是为了将Handler、Thread等封装为一个异步执行框架，供Android Coder可以方便的使用。其主要目的是为了“在其他线程中执行一个耗时操作，并随时报告执行进度给UI线程，执行完成后将结果报告给UI线程”。
AsyncTask的使用方法其实Android developer中已经说得非常清楚了，因此择重点翻译一次：
AsyncTask使用时必须作为基类被扩展，子类至少重载一个方法doInBackground，另一个方法onPostExecute也经常被重载，代码例子如下：
6private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}

protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}

protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}

AsyncTask含有三个泛型参数： Params, 异步任务执行所需的参数类型； Progress, 异步任务执行进度的类型； Result, 异步任务执行结果的类型。 这三个参数不必全部使用，不使用的参数置为Void即可，例如:
private class MyTask extends AsyncTask<Void, Void, Void> { ... }

AsyncTask的四个重要方法。当一个异步任务被执行时，要经历四步： onPreExecute(),在UI线程中执行，它会在异步任务开始前执行，一般用来设置任务参数； doInBackground, 最重要的方法，在子线程中执行（事实上，只有它在子线程中执行，其他方法都在UI线程中执行）。当onPreExecute结束后，本方法立刻执行，它用来进行后台的耗时计算，异步任务的参数会被传给它，执行完成的结果会被送给第四步；执行途中，它还可以调用publishProgress 方法来通知UI线程当前执行的进度； onProgressUpdate, 当publishProgress 被调用后，它在UI线程中执行，刷新任务进度，一般用来刷新进度条等UI部件； onPostExecute, 当后台的异步任务完成后，会在UI线程中被调用，并获取异步任务执行完成的结果。

❾ Android 深入探讨sigleTask和singletop的区别

1.singleTask和singletop都是保真了Activity在栈中的唯一性

2.singleTask和singleTop实例存在时，都不会重新创建 new task

不同之处有如下几点：

如果singleTask启动的ActivityA位于栈底，在栈顶startActivity到这个ActivityA时会调动
onNewIntent->onStart->onResume。

但singleTask启动的的ActivityA不存在时，会重新创建ActivityA,调用方式OnCreate->OnStart->OnResume

2.如果singletop启动的ActivityB在栈底时，在栈顶startActivity到这个ActivityB时会重新调动
onCreate->onStart->onResume，但不会调用OnDestroy

并且singletop启动的的ActivityB不存在时，会重新创建ActivityB,调用方式OnCreate->OnStart->OnResume

3.singleTask在栈底时，从栈顶startActivity到栈底ActivityA,那么该栈startActivity的发起者的中间部分Activity会被销毁。而singletop是逐级跳跃到栈顶

singleTask

追加一点singleInstance,虽然也是保证唯一性，但改模式的Activity是全局性的唯一性，生命周期和应用程序相同，不能及时回收，此外的话Activity在MVC充当Controller的角色，

这点显然对singleIntance来说不适合，因此不建议使用。

4.singleTask不适合充当ChildActivity，但singletop适合

5.对作业栈，默认情况下，没有任何影响，因为栈的taskid是相同的，可以获取getTaskid()，默认情况下每个activity的taskid相同

但是，如果自定义了栈的标签（这个标签相同的singletask activity在同一个作业栈中），那么taskid就会初选差别

android:taskAffinity="com.sample.lanchmode.tester.main"，那么一旦另一个作业栈被销毁，下次必然重建（相信我，这不是废话）。

为了一句不是废话，我需要来证明一下。

当我们的初始加载WelcomeActivity界面--->HomeActivity界面时，如果将HomeActivity的启动模式设置为sigleTask+android:taskAffinity="自定义（一般是类名）",

①那么WelcomeActivity销毁后，在到达HomeActivity之后，HomeActivity回作为一个新的作业栈栈底而存在，所以由HomeActivity启动的Activity的TaskId和HomeActivity相同。

②这个过程，WelcomeActivity和HomeActivity的TaskId是不相同的，问题出现了，当我们按下 Home键，然后在点击桌面上的app图标你会发现，WelcomeActivity再次出现了，

而且再次进入了HomeActivity，并且这个HomeActivity调用了OnNewIntent，却没掉用OnCreate，所以来说他一直存在这，但你需要再次过渡才能找到它。

（对于追求捕获Home键让app退出的读者是一个喜讯，这样可以做到每次Home之后都能再次进入登录界面），在这个过程中没有直接进入HomeActivity，而是WelcomeActivity（有人说不对么，不应该是这样么，在这里不想解释）。

注意，使用了不同作业栈的Activity,会在最近打开的app显示一个应用会出现2个界面。

在这里，需要强调一下singleTask+android:taskAffinity不一定必须使用，请依据需求而定，网上有人推荐使用，但我却想说，不要盲目，并不是所有的应用都适合。

1-->
singleTask+android:taskAffinity对于效率而言，优势并不存在，比如设置进程的，但对于带有登录状态的app需要慎用，否则造成信息泄露等问题，开发中只使用singleTask即可。

2-->
singleTask+android:taskAffinity适用于单用户保密性的app（可做到Home之后下次必须登录才能查看信息），建议在这方面试试。

转载