Comment créer un service qui surveille en permanence les informations d'utilisation des applications?
Problème à portée de main: Je dois créer un Service qui fonctionne en continu. Ce service surveille 5 applications disons 5 Android jeux installés sur votre téléphone. Ce service doit obtenir les informations suivantes: 1. Combien de fois le jeu est-il ouvert et exécuté? 2. Pendant combien de temps chaque partie s'est déroulée.
par exemple: Dites si j'ai ce service installé dans mon application. Et je l'ai laissé fonctionner pendant un mois. J'ai besoin d'informations de ce type sur l'écran de l'application:
JeNombre de fois que le jeu est exécutéDurée de je
Match 1 20 fois joué pendant 15 heures au total
Match 2 16 fois joué pendant 25 heures au total
..
..
Jeu 5 10 fois joué pendant 12 heures au total
Approche possible: Lorsqu'une application se charge, elle vient dans la mémoire. Noter l'heure du système au démarrage de l'application. Et lorsque l'application se termine ou est mise en arrière-plan en notant à nouveau l'heure.
Donc, dites si une application est mise en mémoire à 21h00 et quitte à l'arrière-plan à 21h30 ce qui nous donne un temps de jeu de 30 minutes. La prochaine fois que l'application sera lue, la durée sera ajoutée à 30 de la lecture précédente stockée dans une sorte de variable et ainsi de suite. Chaque fois qu'une application est mise en mémoire, le compteur de celle-ci doit être augmenté d'une unité. Nous donnant ainsi le nombre de fois où une application est lue.
Codage: Je n'ai aucune idée de Service dans Android car je n'ai jamais vraiment travaillé dessus. Tout tutoriel lié à mon problème sera très utile. Deuxièmement, s'il y a une autre façon de le faire. J'aimerais aussi le savoir. Je pourrais vraiment utiliser un extrait de code pour démarrer ce projet.
Comme vous avez écrit que la tâche consiste à surveiller les applications tierces, il n'y a pas d'autre solution que de lire périodiquement une liste de processus et de détecter les processus de premier plan. Vous avez besoin d'un service pour cela. Malheureusement, Android ne fournit pas de moyens tels que des événements de diffusion pour le changement de processus de premier plan.
La tâche nécessite en fait beaucoup de code, au moins beaucoup plus qu'une réponse ordinaire pourrait comprendre. J'en publie une partie ici, mais vous devriez aborder de nombreuses nuances laissées dans les coulisses, telles que la synchronisation et la persistance des informations entre les lancements. Ce n'est qu'un squelette.
Tout d'abord, permet de coder un objet d'application, qui est un bon endroit pour enregistrer tous les éléments liés à l'instance.
MonitorApp
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
}
Permet ensuite de rédiger une activité.
MonitorActivity
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);
}
}
}
L'activité lance un service de travail en arrière-plan, qui surveille réellement les processus. Vous pouvez éventuellement déplacer l'enregistrement de service de l'activité vers l'instance d'application. Le service lui-même ressemble à ceci:
MonitorService
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);
}
}
Le service utilise une classe d'assistance pour créer des listes de processus.
ProcessList
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));
}
}
}
Enfin, le manifeste.
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>
Comme vous pouvez le voir, c'est déjà beaucoup de code. Il est partiellement extrait d'une application qui fonctionne, mais j'ai fait des changements rapides pour vos besoins, donc il peut y avoir des fautes de frappe, toutes les importations sont ignorées, etc. Néanmoins, j'espère que cela aide un peu.
ADDENDA: Lollipop +
Attention: les dernières versions Android versions ont rompu l'approche susmentionnée. Voici ce que la documentation officielle dit sur la méthode getRunningTasks et autres:
Depuis Lollipop, cette méthode n'est plus disponible pour les applications tierces: l'introduction de recents centrés sur le document signifie qu'elle peut divulguer des informations sur la personne à l'appelant. Pour des raisons de compatibilité ascendante, il récupérera toujours un petit sous-ensemble de ses données: au moins les propres tâches de l'appelant, et éventuellement d'autres tâches telles que la maison qui ne sont pas sensibles.
Je pense que c'est une exagération et pourrait être fait de manière beaucoup plus sélective et pratique. Sans oublier que cela semble trop théâtral compte tenu de nombreuses fonctionnalités intégrées de Google avec des problèmes de confidentialité. Quoi qu'il en soit, nous ne pouvons rien y faire.
La seule solution consiste à implémenter Android (plus d'informations ici et ici )) et à intercepter toutes les actions avec des applications gagnant et perdant le focus de L'utilisateur doit activer le service manuellement! Votre application doit en quelque sorte demander à l'utilisateur de le faire.
Mes pensées,
Développer une application qui rend publiques certaines de leurs données à d'autres processus pour y accéder.
Google "Comment utiliser fournisseurs de contenu".
Chacune de vos candidatures devra conserver une trace de toutes les activités réalisées. Ces données seront accessibles au public.
Vous n'avez pas besoin d'exécuter un service tout le temps pour cela alors. Chaque fois que votre application de surveillance est ouverte. Il suffit de récupérer ces données dans toutes les applications souhaitées et de les afficher en conséquence.
Pour un cas, vous souhaitez soumettre ces données sur le serveur périodiquement en arrière-plan. Ensuite, vous avez besoin d'un service. Mais toujours toi pas besoin de l'exécuter pour toujours. Faites quelque chose comme ça.
i) Depuis le service, récupérez les données et téléchargez-les sur le serveur.
ii) Arrêtez le service et programmez une alarme après un certain temps T1 pour redémarrer votre propre service et recommencer l'étape 1.
iii) T1 dépend de l'exigence. Comment actualiser les données que vous souhaitez sur le serveur.
Je peux même vous dire un pointeur de morceaux de code si vous voulez savoir comment implémenter ce que j'ai dit ci-dessus. Mais je vous suggère de trouver cela sur google et de le faire vous-même en premier. Postez une autre question spécifique sur StackOverflow si vous rencontrez des difficultés.
J'espère que cela t'aides. :)
Éditer:
D'abord. C'est seulement vous qui devez coder à la fin. Prenez le pointeur et aidez à partir d'ici. Ne vous attendez pas à du code complet. Vérifiez plus de détails ci-dessous.
UNE)
Vous devez créer vos applications en tant que fournisseur de contenu. Consultez le lien ci-dessous. et suivez les exemples qu'il contient. Vous vous retrouverez dans une application dont les données seront disponibles pour les autres. C'est facile.
http://developer.Android.com/guide/topics/providers/content-providers.html
http://developer.Android.com/guide/topics/providers/content-provider-creating.html
http://www.vogella.com/articles/AndroidSQLite/article.html
Toutes vos applications de jeux doivent rendre les données publiques pour être accessibles. Maintenant, une fois que vous avez terminé avec cela.
Il ne vous reste plus qu'à accéder à toutes les données de votre application de surveillance et à les afficher.
B)
Comme je l'ai dit, si vous voulez le faire via le service. Vous n'avez pas besoin de l'exécuter pour toujours. Il suffit de démarrer le service pour une fois, de charger les données du fournisseur de contenu et de faire ce que vous voulez faire. Définissez une alarme pour appeler le service ultérieurement afin de refaire la même opération.
Je suppose que toutes les 10 minutes, votre service peut récupérer des données auprès du fournisseur de contenu (votre application de jeux que vous souhaitez surveiller). Ce sera comme suivre.
public class MonitoringService extends Service {
private static final String ACTION_FETCH = "action_fetch";
private static final int REPEAT_DATALOAD_INTERVAL_MS = 10 * 60 * 1000; // 10 Min
private static PendingIntent makeSelfPendingIntent(Context context) {
PendingIntent intent = PendingIntent.getService(
context, 0, makeSelfIntent(context), 0);
return intent;
}
private static Intent makeSelfIntent(Context context) {
Intent intent = new Intent(context, MonitoringService.class);
intent.setAction(ACTION_FETCH);
return intent;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null && intent.getAction() != null) {
String action = intent.getAction();
if (action.equals(ACTION_FETCH)) {
loadDataFromContentProviderDoWhateverYouWantThen();
setAlarmToRedoLoad();
stopSelf();
}
}
return Super.onStartCommand(intent, flags, startId);
}
private void setAlarmToRedoLoad() {
AlarmManager alarmManager = (AlarmManager)
getSystemService(Context.ALARM_SERVICE);
alarmManager.set(AlarmManager.RTC_WAKEUP,
System.currentTimeMillis() + REPEAT_DATALOAD_INTERVAL_MS,
makeSelfPendingIntent(getApplicationContext()));
}
private void loadDataFromContentProviderDoWhateverYouWantThen(){
check this link how to load data from content provider.
as your games app are content providers. It should be loaded easily.
then do whatever you want display, upload anything
http://developer.Android.com/guide/topics/providers/content-provider-basics.html
}
// Call this method from onCreate of your monitoring app
public static void start(Context context) {
Intent intent = makeSelfIntent(context);
context.startService(intent);
}
}
C) assurez-vous d'autoriser l'utilisateur de votre application de surveillance à arrêter ce service à tout moment. N'oubliez pas d'annuler l'alarme dans ce cas. donc il ne fonctionne pas en arrière-plan pour toujours.
D) Vous pouvez également créer des éléments basés sur la diffusion. Chaque fois que votre application de jeux enregistre des données, elle doit diffuser cet événement et laisser votre service être invoqué après avoir écouté cette diffusion. charge alors seulement.
E) Comme Phill l'a également déclaré, vous pouvez également utiliser Google Analytics.
La façon dont vous voulez réellement le faire dépend maintenant de vos besoins
J'espère que cela t'aides. Essayez-le et faites-moi savoir à quel autre problème vous êtes confronté
Pour obtenir l'application en cours d'exécution, vous pouvez utiliser:
ActivityManager am = (ActivityManager) mContext.getSystemService(Activity.ACTIVITY_SERVICE);
String packageName = am.getRunningTasks(1).get(0).topActivity.getPackageName();
Vous pouvez le vérifier périodiquement à partir de votre service en cours d'exécution. Vous devrez également définir une autorisation requise dans votre manifeste: Android.permission.GET_TASKS
Solutions suivantes basées sur l'hypothèse que vous possédez les cinq applications que vous essayez de surveiller. Si ce n'est pas le cas, je vous proposerai une autre solution.
Décomposons le problème maintenant.
- Service d'information sur l'application en cours d'exécution ou non.
- Service de conception
- stocker des données
Vous devez utiliser Intent pour diffuser des messages sur votre application en cours d'exécution ou non. Utilisez l'activité onPause et onResume pour diffuser des messages.
Appelez maintenant cette fonction depuis onPause et onResume,
public void broadcastMessage(String method_name){
Intent intent=new Intent("com.service.myservice");
Bundle bundle=new Bundle();
bundle.putString("app_name", this.getApplicationInfo().packageName);
bundle.putLong("time", System.currentTimeMillis());
//just to keep track if it is on pause or in on resume
bundle.putString("method", method_name);
intent.putExtras(bundle);
this.startService(intent);
}
et vous pouvez appeler cela comme la façon suivante
public void onPause(){
super.onPause();
broadcastMessage(Thread.currentThread().getStackTrace()[1].getMethodName());
}
Ou
public void onPause(){
super.onPause();
broadcastMessage("onPause");
}
Alors pourquoi onPause et onResume parce que le joueur ne joue au jeu qu'entre ces fonctions.
Conception du service
Utilisez IntentService et lisez this si vous voulez savoir pourquoi.
@Override
protected void onHandleIntent(Intent intent) {
// TODO Auto-generated method stub
Bundle bundle=intent.getExtras();
String app_name=bundle.getString("app_name");
long time=bundle.getLong("time");
//then do whatever you wanna do with this data
}
Stockage
ContentProvider est une bonne option pour stocker des données, et il est également très puissant; s'intègre et évolue bien sur Android, mais dans ce cas, il semble que vous ne souhaitiez stocker que des informations très simples et en tant que tel, vous pouvez également choisir quelque chose de très simple.
Le code ci-dessous utilise SharedPreferences.
protected void storeData(String app_name, long time) {
if ((app_name==null)||(time<=0)) return;
SharedPreferences sharedPreferences = PreferenceManager .getDefaultSharedPreferences(getApplicationContext());
Editor editor = sharedPreferences.edit();
//concatenating app name just to make key unique
long start_time=sharedPreferences.getLong(app_name+"_start_time", -1);
if (start_time==-1){
//start time is empty means this is my start time
// and user just started the app
editor.putLong(app_name+"_start_time", time);
editor.putLong(app_name+"_counter", sharedPreferences.getLong(app_name+"_counter", 0)+1);
}else{
//user is now closing the app.
long time_played=time-start_time;
long total_time=sharedPreferences.getLong(app_name+"_total_time", 0);
total_time=total_time+time_played;
//saving total time
editor.putLong(app_name+"_total_time", time);
//removing start time for next pass
editor.remove(app_name+"_start_time");
}
editor.commit();
}
public long getTotalTimeUserSpent(String app_name){
SharedPreferences sharedPreferences = PreferenceManager .getDefaultSharedPreferences(getApplicationContext());
return sharedPreferences.getLong(app_name+"_total_time", 0);
}
public long numberOfTimeUserPlayed(String app_name){
SharedPreferences sharedPreferences = PreferenceManager .getDefaultSharedPreferences(getApplicationContext());
return sharedPreferences.getLong(app_name+"_counter", 0);
}
il suffit d'appeler ces méthodes depuis onHandleIntent.
La dernière pièce du puzzle serait la distribution. Vous pouvez le distribuer sur une application distincte ou une partie de ces cinq applications. Des applications séparées sont la voie la plus simple à suivre. Mais si vous choisissez de l'utiliser dans le cadre de ces cinq applications, lisez this discussion.
Utilisez cet exemple de code pour vérifier si le navigateur est en cours d'exécution
ActivityManager activityManager = (ActivityManager) this.getSystemService( ACTIVITY_SERVICE );
List<RunningAppProcessInfo> procInfos = actvityManager.getRunningAppProcesses();
for(int i = 0; i < procInfos.size(); i++){
if(procInfos.get(i).processName.equals("com.Android.browser")) {
Toast.makeText(getApplicationContext(), "Browser is running", Toast.LENGTH_LONG).show();
}
}
Pour créer un service, vous devez créer une classe qui s'étend de la classe de base Service et implémenter la fonction dans une boucle infinie telle que while(true) dans la fonction onStartCommand(). n'oubliez pas d'ajouter votre service dans le fichier manifeste entre les balises <service></service>, un bon tutoriel est sur http://www.vogella.com/articles/AndroidServices/article.html