下面列出了怎么用android.app.ActivityManager.RunningAppProcessInfo的API类实例代码及写法，或者点击链接到github查看源代码。
private boolean isForegroundActivity(int uid, int pid) {
try {
List<RunningAppProcessInfo> procs =
ActivityManager.getService().getRunningAppProcesses();
int N = procs.size();
for (int i = 0; i < N; i++) {
RunningAppProcessInfo proc = procs.get(i);
if (proc.pid == pid && proc.uid == uid
&& proc.importance <= IMPORTANCE_FOREGROUND_SERVICE) {
return true;
}
}
} catch (RemoteException e) {
Slog.w(TAG, "am.getRunningAppProcesses() failed");
}
return false;
}
private void updateProcessInfo() {
String mText = "";
mTextView.setText(mText);
// 获取ActivityManager
ActivityManager activityManager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
// 获取进程信息***************************************************
List<RunningAppProcessInfo> infos = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo info : infos) {
String name = info.processName;
int uid = info.uid;
int pid = info.pid;
mText = mTextView.getText().toString();
mText += name + "\n\n";
mTextView.setText(mText + " uid=" + uid + " pid=" + pid);
}
}
/**
* 判断进程是否运行
* @return
*/
public static boolean isProessRunning(Context context, String proessName) {
boolean isRunning = false;
ActivityManager am = (ActivityManager) context
.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> lists = am.getRunningAppProcesses();
for (RunningAppProcessInfo info : lists) {
if (info.processName.equals(proessName)) {
isRunning = true;
}
}
return isRunning;
}
private boolean isApplicationInForeground() {
ActivityManager activityManager = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
List<RunningAppProcessInfo> processInfos = activityManager.getRunningAppProcesses();
if (processInfos != null) {
for (RunningAppProcessInfo processInfo : processInfos) {
if (processInfo.processName.equals(getApplication().getPackageName())) {
if (processInfo.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
for (String d : processInfo.pkgList) {
return true;
}
}
}
}
}
return false;
}
public void toggleChecked(final boolean b) {
if (b) {
selectedInList1.clear();
for (RunningAppProcessInfo r : display_process) {
selectedInList1.add(r.processName);
}
if (selectedInList1.size() > 0 && commands.getVisibility() == View.GONE) {
commands.setAnimation(AnimationUtils.loadAnimation(activity, R.anim.grow_from_bottom));
commands.setVisibility(View.VISIBLE);
horizontalDivider6.setVisibility(View.VISIBLE);
}
} else {
selectedInList1.clear();
if (commands.getVisibility() == View.VISIBLE) {
horizontalDivider6.setVisibility(View.GONE);
commands.setAnimation(AnimationUtils.loadAnimation(activity, R.anim.shrink_from_top));
commands.setVisibility(View.GONE);
}
}
notifyDataSetChanged();
}
/**
* 判断当前应用程序是否后台运行
*/
public static boolean isBackground(Context context) {
ActivityManager activityManager = (ActivityManager) context
.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager
.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(context.getPackageName())) {
if (appProcess.importance == RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
// 后台运行
return true;
} else {
// 前台运行
return false;
}
}
}
return false;
}
private boolean isAppOnForeground() {
ActivityManager aManager=((ActivityManager)getSystemService(Context.ACTIVITY_SERVICE));
List<RunningAppProcessInfo> appProcesses = aManager.getRunningAppProcesses();
if (appProcesses == null) return false;
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(getPackageName())){
Log.e("StopListennerActivity", "appProcess.importance="+appProcess.importance);
// inRunningTasks(aManager);
if(appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true;
}else{
return false;
}
}
}
return false;
}
@SuppressLint({"NewApi"})
public static boolean isAppOnForeground(Context mContext) {
ActivityManager activityManager = (ActivityManager) mContext.getSystemService("activity");
String packageName = mContext.getPackageName();
LogInfo.log("PushReceiver", "packageName =" + packageName);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses == null) {
LogInfo.log("PushReceiver", "------appProcesses == null-----");
return false;
}
for (RunningAppProcessInfo appProcess : appProcesses) {
LogInfo.log("PushReceiver", "------appProcess.processName =" + appProcess.processName);
if (appProcess.processName.equals(packageName) && appProcess.importance == 100) {
for (RunningTaskInfo rti : activityManager.getRunningTasks(100)) {
if (!(rti == null || rti.baseActivity == null || mContext.getPackageName() == null || !mContext.getPackageName().equals(rti.baseActivity.getPackageName()) || VERSION.SDK_INT < 11)) {
activityManager.moveTaskToFront(rti.id, 1);
}
}
return true;
}
}
return false;
}
/**
* whether this process is named with processName
*
* @param context 上下文
* @param processName 进程名
* @return <ul>
* return whether this process is named with processName
* <li>if context is null, return false</li>
* <li>if {@link ActivityManager#getRunningAppProcesses()} is null,
* return false</li>
* <li>if one process of
* {@link ActivityManager#getRunningAppProcesses()} is equal to
* processName, return true, otherwise return false</li>
* </ul>
*/
public static boolean isNamedProcess(Context context, String processName) {
if (context == null || TextUtils.isEmpty(processName)) {
return false;
}
int pid = android.os.Process.myPid();
ActivityManager manager = (ActivityManager) context
.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> processInfoList = manager
.getRunningAppProcesses();
if (processInfoList == null) {
return true;
}
for (RunningAppProcessInfo processInfo : manager
.getRunningAppProcesses()) {
if (processInfo.pid == pid
&& processName.equalsIgnoreCase(processInfo.processName)) {
return true;
}
}
return false;
}
/**
* 获取当前进程的名称
* @return 进程名
*/
public static String getCurProcessName() {
if (curProcessName != null) {
return curProcessName;
}
Application application = CC.getApplication();
if (application == null) {
return PROCESS_UNKNOWN;
}
try {
ActivityManager manager = (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
if (manager != null) {
List<RunningAppProcessInfo> processes = manager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : processes) {
if (appProcess.pid == android.os.Process.myPid()) {
curProcessName = appProcess.processName;
return curProcessName;
}
}
}
} catch (Exception e){
CCUtil.printStackTrace(e);
}
return PROCESS_UNKNOWN;
}
public static String[] getCurProcessPkgList() {
Application application = CC.getApplication();
if (application == null) {
return null;
}
try {
ActivityManager manager = (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
if (manager != null) {
List<RunningAppProcessInfo> processes = manager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : processes) {
if (appProcess.pid == android.os.Process.myPid()) {
return appProcess.pkgList;
}
}
}
} catch (Exception e){
CCUtil.printStackTrace(e);
}
return null;
}
/**
* Asks if the current process is "org.fdroid.fdroid:acra".
* <p>
* This is helpful for bailing out of the {@link FDroidApp#onCreate} method early, preventing
* problems that arise from executing the code twice. This happens due to the `android:process`
* statement in AndroidManifest.xml causes another process to be created to run
* {@link org.fdroid.fdroid.acra.CrashReportActivity}. This was causing lots of things to be
* started/run twice including {@link CleanCacheService} and {@link WifiStateChangeService}.
* <p>
* Note that it is not perfect, because some devices seem to not provide a list of running app
* processes when asked. In such situations, F-Droid may regress to the behaviour where some
* services may run twice and thus cause weirdness or slowness. However that is probably better
* for end users than experiencing a deterministic crash every time F-Droid is started.
*/
private boolean isAcraProcess() {
ActivityManager manager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> processes = manager.getRunningAppProcesses();
if (processes == null) {
return false;
}
int pid = android.os.Process.myPid();
for (RunningAppProcessInfo processInfo : processes) {
if (processInfo.pid == pid && ACRA_ID.equals(processInfo.processName)) {
return true;
}
}
return false;
}
public static boolean isBackground(Context context) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(context.getPackageName())) {
/*
* BACKGROUND=400 EMPTY=500 FOREGROUND=100 GONE=1000
* PERCEPTIBLE=130 SERVICE=300 ISIBLE=200
*/
Log.i(context.getPackageName(), "此appimportace =" + appProcess.importance
+ ",context.getClass().getName()=" + context.getClass().getName());
if (appProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
Log.i(context.getPackageName(), "处于后台" + appProcess.processName);
return true;
} else {
Log.i(context.getPackageName(), "处于前台" + appProcess.processName);
return false;
}
}
}
return false;
}
private static final void waitKilled(int pid) {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100, 0);
} catch (Throwable e) {
//
}
//
List<RunningAppProcessInfo> processes = AMSUtils.getRunningAppProcessesNoThrows(RePluginInternal.getAppContext());
if (processes == null || processes.isEmpty()) {
continue;
}
boolean found = false;
for (RunningAppProcessInfo info : processes) {
if (info.pid == pid) {
found = true;
}
}
if (!found) {
return;
}
}
}
public boolean isAppOnForeground() {
// Returns a list of application processes that are running on the
// device
String packageName = context.getPackageName();
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses == null)
return false;
for (RunningAppProcessInfo appProcess : appProcesses) {
// importance:
// The relative importance level that the system places
// on this process.
// May be one of IMPORTANCE_FOREGROUND, IMPORTANCE_VISIBLE,
// IMPORTANCE_SERVICE, IMPORTANCE_BACKGROUND, or IMPORTANCE_EMPTY.
// These constants are numbered so that "more important" values are
// always smaller than "less important" values.
// processName:
// The name of the process that this object is associated with.
if (appProcess.processName.equals(packageName) && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true;
}
}
return false;
}
public static boolean isBackground(Context context) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(context.getPackageName())) {
/*
* BACKGROUND=400 EMPTY=500 FOREGROUND=100 GONE=1000
* PERCEPTIBLE=130 SERVICE=300 ISIBLE=200
*/
Log.i(context.getPackageName(), "此appimportace =" + appProcess.importance
+ ",context.getClass().getName()=" + context.getClass().getName());
if (appProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
Log.i(context.getPackageName(), "处于后台" + appProcess.processName);
return true;
} else {
Log.i(context.getPackageName(), "处于前台" + appProcess.processName);
return false;
}
}
}
return false;
}
public static void cleanMemory(Context context){
System.out.println("---> 清理前可用内存:"+getAvailMemory(context)+"MB");
ActivityManager activityManager=(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningAppProcessInfo> processList = activityManager.getRunningAppProcesses();
if (processList != null) {
for (int i = 0; i < processList.size(); ++i) {
RunningAppProcessInfo runningAppProcessInfo= processList.get(i);
// 一般数值大于RunningAppProcessInfo.IMPORTANCE_SERVICE
// 的进程即为长时间未使用进程或者空进程
// 一般数值大于RunningAppProcessInfo.IMPORTANCE_VISIBLE
// 的进程都是非可见进程,即在后台运行
if (runningAppProcessInfo.importance > RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
String[] pkgList = runningAppProcessInfo.pkgList;
for (int j = 0; j < pkgList.length; ++j) {
System.out.println("===> 正在清理:"+pkgList[j]);
activityManager.killBackgroundProcesses(pkgList[j]);
}
}
}
}
System.out.println("---> 清理后可用内存:"+getAvailMemory(context)+"MB");
}
/**
* Gets the memory usage of MyTracks process. This method would get the Pss
* memory. Pss is the amount of memory shared with other processes, accounted
* in a way that the amount is divided evenly between the processes that share
* it. This is memory that would not be released if the process was
* terminated, but is indicative of the amount that this process is
* "contributing" to the overall memory load.
*
* @param context
*/
public static String getMyTracksPssMemoryInfo(Context context) {
int MyTracksProcessId = -1;
ActivityManager activityManager = (ActivityManager) context
.getSystemService(Activity.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> runningAppProcesses = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
if (runningAppProcessInfo.processName.equalsIgnoreCase(MYTRACKS_PROCESS_NAME)) {
MyTracksProcessId = runningAppProcessInfo.pid;
break;
}
}
if (MyTracksProcessId == -1) {
Assert.fail();
}
int pids[] = { MyTracksProcessId };
android.os.Debug.MemoryInfo[] memoryInfoArray = activityManager.getProcessMemoryInfo(pids);
int memoryUsage = memoryInfoArray[0].getTotalPss();
return String.format(Locale.US, " MyTracks TotalPss Memory: %d (kB) ", memoryUsage);
}
/**
* 程序是否在前台
* @deprecated 注：如果对于APP启动后有常驻Service，也判断为了前台(也不准)
* @param context
*/
@Deprecated
public static boolean isAppOnForeground(final Context context) {
if (context == null) {
return false;
}
Context appContext = context.getApplicationContext();
ActivityManager activityManager = (ActivityManager) appContext.getSystemService(Context.ACTIVITY_SERVICE);
if (activityManager == null) {
return false;
}
String packageName = appContext.getPackageName();
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses != null) {
for (RunningAppProcessInfo appProcess : appProcesses) {
// The name of the process that this object is associated with.
if (appProcess.processName.equals(packageName) && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true;
}
}
}
return false;
}
/**
* 获取进程的名称<br/>
* 通过进程id在运行的栈中查找获取进程名称（包名+进程名）
*
* @param context
* @param pid
* @return
*/
public static String getProcessNameByPid(Context context, final int pid) {
String processName = null;
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
if (activityManager == null) {
return "";
}
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses != null) {
for (RunningAppProcessInfo appProcess : appProcesses) {
if (pid == appProcess.pid) {
processName = appProcess.processName;
break;
}
}
}
CommonLog.d(TAG, "getProcessNameByPid,pid=", pid, ",processName=", processName);
return processName;
}
/**
* 检查当前进程名是否是包含进程名的进程
*
* @param context
* @return
*/
public static boolean checkTheProcess(final Context context, String endProcessName) {
ActivityManager activityManager = (ActivityManager) context.getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
int myPid = android.os.Process.myPid();
if (activityManager == null) {
return false;
}
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses != null) {
for (RunningAppProcessInfo appProcess : appProcesses) {
if (myPid == appProcess.pid) {
CommonLog.d(TAG, "process.pid appProcess.processName=" + appProcess.processName + ", endProcessName=" + endProcessName);
if (appProcess.processName.endsWith(endProcessName)) {
return true;
}
break;
}
}
}
return false;
}
/** APP is not runing true:false */
public static boolean isBackground(Context context) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
//判断所有的app进程,报名是否等于该app
if (appProcess.processName.equals(context.getPackageName())) {
if (appProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
return true; //"处于后台"
} else {
return false;//"处于前台"
}
}
}
return false;
}
/**
* 判断当前应用程序是否后台运行
*/
public static boolean isBackground(Context context) {
ActivityManager activityManager = (ActivityManager) context
.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager
.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(context.getPackageName())) {
if (appProcess.importance == RunningAppProcessInfo.IMPORTANCE_BACKGROUND) {
// 后台运行
return true;
} else {
// 前台运行
return false;
}
}
}
return false;
}
/**
* Populate running process info into the runningAppInfo WeakReference list
* and return its value.
*
* @param context the Context
* @return the value of the runningAppInfo WeakReference list after setting it.
*/
public static List<RunningAppProcessInfo> getRunningProcessInfo(Context context) {
if (runningAppInfo != null && runningAppInfo.get() != null) {
return runningAppInfo.get();
}
ActivityManager manager =
(ActivityManager) context.getSystemService(Activity.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> runningAppProcesses = manager.getRunningAppProcesses();
for (RunningAppProcessInfo info : runningAppProcesses) {
if (info == null || info.processName == null) continue;
info.processName = StringHelper.formatProcessName(info.processName);
}
runningAppInfo = new WeakReference<>(runningAppProcesses);
return runningAppProcesses;
}
/**
* Helper to query whether an application is currently running
* and its code has not been evicted from memory.
*
* @param context Application's context
* @param appName The package name or process name of the application.
* @return true if the application is running, false otherwise.
*/
public static boolean isRunning(final Context context, String appName) {
List<RunningAppProcessInfo> runningProcessInfo = Process.getRunningProcessInfo(context);
List<RunningServiceInfo> services = Service.getRunningServiceInfo(context);
for (RunningAppProcessInfo info : runningProcessInfo) {
if (info.processName.equals(appName) &&
info.importance != RunningAppProcessInfo.IMPORTANCE_EMPTY) {
return true;
}
}
for (RunningServiceInfo service : services) {
String name = StringHelper.formatProcessName(service.process);
if (name.equals(appName)) return true;
}
return false;
}
public static String importanceStringLegacy(String description) {
String importance;
switch (description) {
case "system" :
importance = importanceString(RunningAppProcessInfo.IMPORTANCE_BACKGROUND);
break;
case "user" :
importance = importanceString(Config.IMPORTANCE_APP);
break;
case "user-service" :
importance = importanceString(RunningAppProcessInfo.IMPORTANCE_SERVICE);
break;
default :
importance = "Unknown";
break;
}
return importance;
}
public static boolean isBackground(Context context) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess.processName.equals(context.getPackageName())) {
/*
* BACKGROUND=400 EMPTY=500 FOREGROUND=100 GONE=1000
* PERCEPTIBLE=130 SERVICE=300 ISIBLE=200
*/
Log.i(context.getPackageName(), "此appimportace =" + appProcess.importance
+ ",context.getClass().getName()=" + context.getClass().getName());
if (appProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
Log.i(context.getPackageName(), "处于后台" + appProcess.processName);
return true;
} else {
Log.i(context.getPackageName(), "处于前台" + appProcess.processName);
return false;
}
}
}
return false;
}
private static String getProcessName(Context context) {
try {
String currentProcessName = null;
int pid = android.os.Process.myPid();
ActivityManager manager =
(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
for (RunningAppProcessInfo processInfo : manager.getRunningAppProcesses()) {
if (processInfo.pid == pid) {
currentProcessName = processInfo.processName;
break;
}
}
return currentProcessName;
} catch (SecurityException ex) {
return null;
}
}
public static String getCurrentProcessName(Context context) {
if (context == null)
return sCurrentProcessName;
synchronized (sGetCurrentProcessNameLock) {
if (sCurrentProcessName == null) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> infos = activityManager.getRunningAppProcesses();
if (infos == null)
return null;
for (RunningAppProcessInfo info : infos) {
if (info.pid == android.os.Process.myPid()) {
sCurrentProcessName = info.processName;
return sCurrentProcessName;
}
}
}
}
return sCurrentProcessName;
}
private void doGc(RunningAppProcessInfo myInfo) {
int activityCount = mRunningProcessList.getActivityCountByPid(myInfo.pid);
int serviceCount = mRunningProcessList.getServiceCountByPid(myInfo.pid);
int providerCount = mRunningProcessList.getProviderCountByPid(myInfo.pid);
if (activityCount <= 0 && serviceCount <= 0 && providerCount <= 0) {
//杀死空进程。
Log.i(TAG, "doGc kill process(pid=%s,uid=%s processName=%s)", myInfo.pid, myInfo.uid, myInfo.processName);
try {
android.os.Process.killProcess(myInfo.pid);
} catch (Throwable e) {
Log.e(TAG, "error on killProcess", e);
}
} else if (activityCount <= 0 && serviceCount > 0 /*&& !mRunningProcessList.isPersistentApplication(myInfo.pid)*/) {
List<String> names = mRunningProcessList.getStubServiceByPid(myInfo.pid);
if (names != null && names.size() > 0) {
for (String name : names) {
Intent service = new Intent();
service.setClassName(mHostContext.getPackageName(), name);
AbstractServiceStub.startKillService(mHostContext, service);
Log.i(TAG, "doGc kill process(pid=%s,uid=%s processName=%s) service=%s", myInfo.pid, myInfo.uid, myInfo.processName, service);
}
}
}
}