如何创建持续监控应用使用信息的服务? [英] How to create a Service which continuously monitors app usage information?
问题描述
手头的问题:我必须创建一个连续运行的 Service.此服务监控 5 个应用程序，其中显示您手机上安装了 5 个安卓游戏.该服务需要获取以下信息:1. 游戏打开运行多少次?2. 每场比赛运行了多少时间.
Problem at Hand:
I have to create a Service which runs continuously. This service monitors 5 apps say 5 android games installed on your phone. This service needs to get the information of:
1. How many times is the game opened and run?
2. For how much time each game has run.
例如:说如果我在我的应用程序中安装了这个服务.我让它运行了一个月.我需要应用程序屏幕上的此类信息:
for example: Say If I have this service installed in my app. And I let it run for a month. I need information of this kind on the screen of the app:
游戏 游戏运行次数 游戏持续时间
游戏 1 20 次共玩 15 小时
Game 1 20 times played for 15 hours in total
游戏 2 共 16 次玩了 25 小时
Game 2 16 times played for 25 hours in total
...
...
游戏 5 10 次共玩 12 小时
Game 5 10 times played for 12 hours in total
可能的方法:当应用程序加载时，它会进入内存.在应用程序启动时注意系统时钟时间.当应用程序结束或被置于后台时再次记录时间.
Possible Approach: When an application loads it comes in the memory. Noting the system clocks time while the application starts. And when the application ends or is put in the background noting the time again.
假设一个应用程序在晚上 9:00 进入内存并在晚上 9:30 退出到后台，那么我们的游戏时间为 30 分钟.下次播放应用程序时，持续时间将从上次播放的时间添加到 30，存储在某种变量中，依此类推.每次将应用程序带入内存时，正在播放的计数器应增加 1.因此给了我们应用程序的播放次数.
So say if an application is brought to memory at 9:00 pm and exits to background at 9:30 pm that gives us a gameplay time of 30 mins. Next time the application is played the duration will be added to 30 from the previous play stored in some sort of variable and so on. Each time an application is brought into the memory the counter of it being played should increase by one. Hence giving us the number of times an application is played.
编码:我对 Android 中的 Service 一无所知，因为我从未真正研究过它们.任何与我手头问题相关的教程都会非常有帮助.其次，如果有另一种方法可以做到这一点.我也想知道.我真的可以使用一些代码片段来启动这个项目.
Coding:
I have no idea about Service in Android as I have never really worked on them. Any tutorials related to my problem at hand will be very helpful.
Secondly, if there is another way in which this could be done. I would like to know that as well. I could really use some code snippet for me to start this project.
推荐答案
正如您所写的任务是关于监视 3-rd 方应用程序，除了定期读取进程列表和检测前台之外没有其他解决方案过程.您需要为此提供服务.遗憾的是，Android 并没有为前台进程更改提供广播事件等手段.
As you wrote that the task is about monitoring 3-rd party applications, there is no solution other than periodically read a list of processes and detecting foreground process. You need a service for this. Unfortunately, Android does not provide means such as broadcast events for foreground process change.
该任务实际上需要大量代码，至少比普通答案所能包含的代码要多得多.我在这里发布了其中的一部分，但您应该解决许多幕后留下的细微差别，例如启动之间的同步和持久信息.这只是一个骨架.
The task requires a lot of code in fact, at least much more than an ordinary answer could comprise. I'm posting a part of it here, but you should address many nuances left behind the scenes, such as synchronization and persisting information between launches. This is just a skeleton.
首先，让我们编写一个应用程序对象，这是注册所有与实例相关的东西的好地方.
First, lets code an application object, which is a good place to register all instance related stuff.
监控应用
public class MonitorApp extends Application
{
// actual store of statistics
private final ArrayList<HashMap<String,Object>> processList = new ArrayList<HashMap<String,Object>>();
// fast-access index by package name (used for lookup)
private ArrayList<String> packages = new ArrayList<String>();
public ArrayList<HashMap<String,Object>> getProcessList()
{
return processList;
}
public ArrayList<String> getPackages()
{
return packages;
}
// TODO: you need to save and load the instance data
// TODO: you need to address synchronization issues
}
然后让我们起草一项活动.
Then lets draft an activity.
监控活动
import static ProcessList.COLUMN_PROCESS_NAME;
import static ProcessList.COLUMN_PROCESS_PROP;
import static ProcessList.COLUMN_PROCESS_COUNT;
import static ProcessList.COLUMN_PROCESS_TIME;
public class MonitorActivity extends Activity implements MonitorService.ServiceCallback
{
private ArrayList<HashMap<String,Object>> processList;
private MonitorService backgroundService;
private MyCustomAdapter adapter = null;
private ListView listView = null;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main); // TODO: provide your layout
listView = (ListView)findViewById(R.id.id_process_listview);
createAdapter();
this.bindService(
new Intent(this, MonitorService.class),
serviceConnection,
Context.BIND_AUTO_CREATE);
}
private void createAdapter()
{
processList = ((MonitorApp)getApplication()).getProcessList();
adapter = new MyCustomAdapter(this, processList, R.layout.complex_list_item,
new String[]
{
COLUMN_PROCESS_NAME,
COLUMN_PROCESS_PROP, // TODO: you may calculate and pre-fill this field
// from COLUMN_PROCESS_COUNT and COLUMN_PROCESS_TIME
// so eliminating the need to use the custom adapter
},
new int[]
{
android.R.id.text1,
android.R.id.text2
});
listView.setAdapter(adapter);
}
// callback method invoked by the service when foreground process changed
@Override
public void sendResults(int resultCode, Bundle b)
{
adapter.notifyDataSetChanged();
}
private class MyCustomAdapter extends SimpleAdapter
{
MyCustomAdapter(Context context, List<? extends Map<String, ?>> data, int resource, String[] from, int[] to)
{
super(context, data, resource, from, to);
}
@Override
public View getView (int position, View convertView, ViewGroup parent)
{
View result = super.getView(position, convertView, parent);
// TODO: customize process statistics display
int count = (Integer)(processList.get(position).get(COLUMN_PROCESS_COUNT));
int seconds = (Integer)(processList.get(position).get(COLUMN_PROCESS_TIME));
return result;
}
}
private ServiceConnection serviceConnection = new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName className, IBinder service)
{
LocalBinder binder = (LocalBinder)service;
backgroundService = binder.getService();
backgroundService.setCallback(MonitorActivity.this);
backgroundService.start();
}
@Override
public void onServiceDisconnected(ComponentName className)
{
backgroundService = null;
}
};
@Override
public void onResume()
{
super.onResume();
if(backgroundService != null)
{
backgroundService.setCallback(this);
}
}
@Override
public void onPause()
{
super.onPause();
if(backgroundService != null)
{
backgroundService.setCallback(null);
}
}
}
该活动启动后台工作服务，该服务实际上监控进程.您可以将服务注册从活动移到应用程序实例中.服务本身是这样的:
The activity launches a background worker service, which does actually monitor processes. You could possibly move the service registration from the activity into the application instance. The service itself is something like this:
监控服务
public class MonitorService extends Service
{
private boolean initialized = false;
private final IBinder mBinder = new LocalBinder();
private ServiceCallback callback = null;
private Timer timer = null;
private final Handler mHandler = new Handler();
private String foreground = null;
private ArrayList<HashMap<String,Object>> processList;
private ArrayList<String> packages;
private Date split = null;
public static int SERVICE_PERIOD = 5000; // TODO: customize (this is for scan every 5 seconds)
private final ProcessList pl = new ProcessList(this)
{
@Override
protected boolean isFilteredByName(String pack)
{
// TODO: filter processes by names, return true to skip the process
// always return false (by default) to monitor all processes
return false;
}
};
public interface ServiceCallback
{
void sendResults(int resultCode, Bundle b);
}
public class LocalBinder extends Binder
{
MonitorService getService()
{
// Return this instance of the service so clients can call public methods
return MonitorService.this;
}
}
@Override
public void onCreate()
{
super.onCreate();
initialized = true;
processList = ((MonitorApp)getApplication()).getProcessList();
packages = ((MonitorApp)getApplication()).getPackages();
}
@Override
public IBinder onBind(Intent intent)
{
if(initialized)
{
return mBinder;
}
return null;
}
public void setCallback(ServiceCallback callback)
{
this.callback = callback;
}
private boolean addToStatistics(String target)
{
boolean changed = false;
Date now = new Date();
if(!TextUtils.isEmpty(target))
{
if(!target.equals(foreground))
{
int i;
if(foreground != null && split != null)
{
// TODO: calculate time difference from current moment
// to the moment when previous foreground process was activated
i = packages.indexOf(foreground);
long delta = (now.getTime() - split.getTime()) / 1000;
Long time = (Long)processList.get(i).get(COLUMN_PROCESS_TIME);
if(time != null)
{
// TODO: add the delta to statistics of 'foreground'
time += delta;
}
else
{
time = new Long(delta);
}
processList.get(i).put(COLUMN_PROCESS_TIME, time);
}
// update count of process activation for new 'target'
i = packages.indexOf(target);
Integer count = (Integer)processList.get(i).get(COLUMN_PROCESS_COUNT);
if(count != null) count++;
else
{
count = new Integer(1);
}
processList.get(i).put(COLUMN_PROCESS_COUNT, count);
foreground = target;
split = now;
changed = true;
}
}
return changed;
}
public void start()
{
if(timer == null)
{
timer = new Timer();
timer.schedule(new MonitoringTimerTask(), 500, SERVICE_PERIOD);
}
// TODO: startForeground(srvcid, createNotification(null));
}
public void stop()
{
timer.cancel();
timer.purge();
timer = null;
}
private class MonitoringTimerTask extends TimerTask
{
@Override
public void run()
{
fillProcessList();
ActivityManager activityManager = (ActivityManager)MonitorService.this.getSystemService(ACTIVITY_SERVICE);
List<RunningTaskInfo> taskInfo = activityManager.getRunningTasks(1);
String current = taskInfo.get(0).topActivity.getPackageName();
// check if current process changed
if(addToStatistics(current) && callback != null)
{
final Bundle b = new Bundle();
// TODO: pass necessary info to UI via bundle
mHandler.post(new Runnable()
{
public void run()
{
callback.sendResults(1, b);
}
});
}
}
}
private void fillProcessList()
{
pl.fillProcessList(processList, packages);
}
}
该服务利用一个帮助程序类来构建进程列表.
The service utilizes a helper class for building process lists.
进程列表
public abstract class ProcessList
{
// process package name
public static final String COLUMN_PROCESS_NAME = "process";
// TODO: arbitrary property (can be user-fiendly name)
public static final String COLUMN_PROCESS_PROP = "property";
// number of times a process has been activated
public static final String COLUMN_PROCESS_COUNT = "count";
// number of seconds a process was in foreground
public static final String COLUMN_PROCESS_TIME = "time";
private ContextWrapper context;
ProcessList(ContextWrapper context)
{
this.context = context;
}
protected abstract boolean isFilteredByName(String pack);
public void fillProcessList(ArrayList<HashMap<String,Object>> processList, ArrayList<String> packages)
{
ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> procInfo = activityManager.getRunningAppProcesses();
HashMap<String, Object> hm;
final PackageManager pm = context.getApplicationContext().getPackageManager();
for(int i = 0; i < procInfo.size(); i++)
{
String process = procInfo.get(i).processName;
String packageList = Arrays.toString(procInfo.get(i).pkgList);
if(!packageList.contains(process))
{
process = procInfo.get(i).pkgList[0];
}
if(!packages.contains(process) && !isFilteredByName(process))
{
ApplicationInfo ai;
String applicationName = "";
for(int k = 0; k < procInfo.get(i).pkgList.length; k++)
{
String thisPackage = procInfo.get(i).pkgList[k];
try
{
ai = pm.getApplicationInfo(thisPackage, 0);
}
catch(final NameNotFoundException e)
{
ai = null;
}
if(k > 0) applicationName += " / ";
applicationName += (String)(ai != null ? pm.getApplicationLabel(ai) : "(unknown)");
}
packages.add(process);
hm = new HashMap<String, Object>();
hm.put(COLUMN_PROCESS_NAME, process);
hm.put(COLUMN_PROCESS_PROP, applicationName);
processList.add(hm);
}
}
// optional sorting
Comparator<HashMap<String, Object>> comparator = new Comparator<HashMap<String, Object>>()
{
public int compare(HashMap<String, Object> object1, HashMap<String, Object> object2)
{
return ((String)object1.get(COLUMN_PROCESS_NAME)).compareToIgnoreCase((String)object2.get(COLUMN_PROCESS_NAME));
}
};
Collections.sort(processList, comparator);
packages.clear();
for(HashMap<String, Object> e : processList)
{
packages.add((String)e.get(COLUMN_PROCESS_NAME));
}
}
}
最后是清单.
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.yourpackage"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="8" android:targetSdkVersion="18" />
<uses-permission android:name="android.permission.GET_TASKS" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:name=".MonitorActivity"
android:label="@string/app_name"
android:configChanges="orientation|keyboardHidden" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:name=".MonitorService" />
</application>
</manifest>
如您所见，它已经有很多代码了.它部分提取自一个正在运行的应用程序，但我根据您的需要进行了快速更改，因此可能存在拼写错误、跳过所有导入等.不过，我希望这会有所帮助.
As you may see, it's already a lot of code. It's partially extracted from a working application, but I made fast changes for your needs, so there may be typos, all imports are skipped, etc. Nevertheless, I hope this helps a bit.
附录:Lollipop+
注意:最新的 Android 版本打破了上述方法.以下是官方文档关于 getRunningTasks 方法和其他方法的说明:
Beware: the latest Android versions broke the abovementioned approach. Here is what the official documentation says about getRunningTasks method and others:
从 LOLLIPOP 开始，此方法不再适用于第三方应用程序:引入以文档为中心的最近记录意味着它可以将个人信息泄露给调用者.为了向后兼容，它仍将返回其数据的一小部分:至少是调用者自己的任务，可能还有一些其他任务，例如已知不敏感的 home.
As of LOLLIPOP, this method is no longer available to third party applications: the introduction of document-centric recents means it can leak person information to the caller. For backwards compatibility, it will still retu rn a small subset of its data: at least the caller's own tasks, and possibly some other tasks such as home that are known to not be sensitive.
我认为这是一种矫枉过正，可以通过更有选择性和更方便的方式来完成.更不用说考虑到谷歌的许多内置功能与隐私问题，这似乎太戏剧化了.无论如何，我们对此无能为力.
I think this is an overkill and could be done in much more selective and convenient way. Not to mention that this seems too theatrical considering many built-in features from Google with privacy concerns. Anyway, we can do nothing with this.
唯一的解决方法是实现 Android 无障碍服务(更多信息这里和此处)并拦截所有应用程序从那里获得和失去焦点的操作.用户应手动启用该服务！您的应用程序应该以某种方式引导用户这样做.
The only workaround is to implement Android accessibility service (more info here and here) and intercept all actions with applications gaining and losing focus from there. The user should enable the service manually! Your application should somehow direct the user to do so.
这篇关于如何创建持续监控应用使用信息的服务?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
