App per monitorare altre applicazioni su android

Problema a portta di mano : Devo creare un Service che funziona continuamente. Questo servizio monitora 5 applicazioni che dicono 5 giochi Android installati sul tuo telefono. Questo servizio ha bisogno di get le informazioni di: 1. Quante volte il gioco viene aperto e eseguito? 2. Per quanto tempo il gioco è stato eseguito.

ad esempio: dire se ho installato questo servizio nella mia app. E l'ho lasciato funzionare per un mese. Ho bisogno di informazioni di questo tipo sullo schermo dell'app:

  • Visualizzazione dell'indicatore della traiettoria
  • android 6.0.1 forza la connessione wifi senza accesso a Internet
  • Come arrestare il telefono dalla ricarica via USB a livello di programmazione
  • Cosa fare con AsyncTask in onPause ()?
  • Come accedere alle viste dell'attività originale dal servizio di background nascosto
  • Se dichiaro un frammento in un layout XML, come posso passarlo un bundle?
  • Gioco Numero di volte in cui viene eseguito il gioco Durata del gioco

    Gioco 1 20 volte giocato per 15 ore in totale

    Gioco 2 16 volte giocato per 25 ore in totale

    ..

    ..

    Gioco 5 10 volte giocato per 12 ore in totale

    Possibile approccio : Quando viene caricata un'applicazione viene in memory. Notando che il sistema esegue l'orologio durante l'avvio dell'applicazione. E quando l'applicazione finisce o viene messo in sottofondo notando nuovamente l'ora.

    Quindi dite se l'applicazione viene portta alla memory alle 9:00 pm ed esce in background alle 9:30 pm che ci dà un tempo di gioco di 30 minuti. la prossima riproduzione dell'applicazione la durata verrà aggiunta a 30 dalla riproduzione precedente memorizzata in una sorta di variabile e così via. Ogni volta che un'applicazione viene portta in memory, il contatore di esso viene riprodotto aumentando di uno, quindi fornendoci il numero di volte in cui viene eseguita un'applicazione.

    Codifica: Non ho idea di Service in Android perché non ho mai lavorato veramente su di loro. Qualsiasi tutorial legato al mio problema a portta di mano sarà molto utile. In secondo luogo se c'è un altro modo in cui questo potrebbe essere fatto. Vorrei sapere anche quello. Potrei davvero usare qualche snippet di codice per avviare questo progetto.

  • Hai bisogno di una tabella dei codici chiave per Android e presentatore
  • Il codice format dello studio Android non sarà la linea di rottura automatica
  • Android - spegni le luci delle chiavi hardware
  • come get elenco di liste pieghevoli per android usando il phonegap
  • Finestra di dialogo con EditText e Spinner
  • Limitazione dei risultati di riconoscimento vocale su Android
  • 6 Solutions collect form web for “App per monitorare altre applicazioni su android”

    Come ha scritto che il task è di monitorare le applicazioni di 3ª parte, non esiste alcuna soluzione se non leggere periodicamente un elenco di processi e rilevare il process in primo piano . Hai bisogno di un servizio per questo. Purtroppo, Android non fornisce mezzi come events di trasmissione per il cambiamento di process in primo piano.

    Il task richiede molto codice, alless molto di più di una risposta ordinaria. Sto postando una parte di esso qui, ma dovresti affrontare molte sfumature lasciate dietro le quinte, come la sincronizzazione e le informazioni persistenti tra i lanci. Questo è solo uno scheletro.

    Innanzitutto, consente di codificare un object di applicazione, che è un buon posto per registrare tutte le cose correlate all'istanza.

    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 } 

    Poi consente di disegnare un'attività.

    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'attività lancia un servizio di background worker, che controlla effettivamente i processi. Potresti spostare la logging del servizio dall'attività nell'istanza dell'applicazione. Il servizio stesso è qualcosa di simile:

    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); } } 

    Il servizio utilizza una class di helper per elenchi di processi di costruzione.

    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)); } } } 

    Infine, il manifesto.

    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> 

    Come potete vedere, è già un sacco di codice. È estratto parzialmente da un'applicazione di lavoro, ma ho fatto cambiamenti veloci per le tue esigenze, in modo che ci siano errori di battitura, tutte le importzioni vengono saltate, ecc. Tuttavia, spero che questo aiuta un po '.

    ADDENDUM: Lollipop +

    Attenzione: le ultime versioni Android hanno interrotto l'approccio summenzionato. Ecco cosa dice la documentazione ufficiale su metodo getRunningTasks e altri:

    A partire da LOLLIPOP, questo metodo non è più disponibile per applicazioni di terze parti: l'introduzione di centinaia di documenti centrati consente di perdere informazioni personali al chiamante. Per la compatibilità all'indietro, rimarrà ancora un piccolo sottoinsieme dei suoi dati: alless le attività del chiamante e eventualmente altre attività come la casa notoriamente non sensibili.

    Penso che sia un sovraccarico e potrebbe essere fatto in modo molto più selettivo e conveniente. Per non parlare che questo sembra troppo teatrale considerando molte funzioni integrate di Google con problemi di privacy. Comunque, non possiamo fare niente con questo.

    L'unica soluzione è implementare il servizio di accessibilità di Android (maggiori informazioni qui e qui ) e intercettare tutte le azioni con le applicazioni che guadagnano e perdono l'attenzione da lì. L'utente deve abilitare manualmente il servizio! L'applicazione dovrebbe in qualche modo dirigere l'utente a farlo.

    I miei pensieri,

    1. Sviluppare un'applicazione che renda pubblici ad alcuni dei propri dati ad altri processi per accedervi.

      Google "Come utilizzare i fornitori di contenuti ".

      Ogni utente della tua applicazione dovrà tenere registro di tutte le attività svolte. Questi dati saranno pubblici da accedere.

    2. Non è necessario eseguire un servizio per tutto questo tempo . Ogni volta che l'applicazione di monitoraggio viene aperta. Devi solo prelevare i dati da tutte le applicazioni che desideri e visualizzarle di conseguenza.

    3. Per un caso si desidera submit i dati sul server periodicamente in background. Allora hai bisogno di un servizio . Ma ancora non hai bisogno di eseguirlo per sempre . Fare qualcosa di simile.

      i) dai dati del servizio recuperare e caricare sul server.

      ii) Interrompere il servizio e programmare un allarme dopo un certo tempo T1 per avviare nuovamente il proprio servizio per eseguire nuovamente il passo 1.

      iii) T1 dipende dal requisito. Come aggiornare i dati desiderati sul server.

    Posso anche dirti puntatore dei codici se vuoi per come implementare quello che ho detto sopra. Ma ti suggerisco di trovare quello su google e farlo prima. Inserisci un'altra domanda specifica su StackOverflow se hai difficoltà in questo.

    Spero che questo ti aiuti. 🙂

    Edit:

    In primo luogo. È solo tu che deve codificare alla fine. Prendi puntatore e aiuto da qui. Non aspettatevi il codice completo. Controlla i dettagli qui sotto.

    UN)

    È necessario rendere le tue applicazioni come Fornitore di contenuti. Controlla il link qui sotto. e seguire gli esempi in essa. Si finirà in un'applicazione i cui dati saranno a disposizione degli altri. È facile andare avanti.

    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

    Tutte le applicazioni di giochi devono rendere accessibili i dati pubblici. Ora una volta che si è finiti con questo.

    Ora è sufficiente accedere a tutti i dati nell'applicazione di monitoraggio e visualizzarla.

    B)

    Come ho detto se vuoi farlo tramite il servizio. Non è necessario eseguirlo per sempre. Basta avviare il servizio per una volta, carichi i dati dal provider di contenuti e fai tutto quello che vuoi fare. Impostare un allarme per ricall il servizio in una fase successiva per eseguire la stessa operazione.

    Suppongo che each 10 minuti il ​​tuo servizio possa recuperare i dati forniti dal provider di contenuti (il tuo gioco app che desideri monitorare). Sarà come seguire.

     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) Assicurati di consentire all'utente dell'applicazione di monitoraggio di interrompere il servizio in qualsiasi momento. Non dimenticare di annullare l'allarme in quel caso. quindi non funziona in background per sempre.

    D) È anche ansible rendere le cose in base alla trasmissione. Ogni volta che i tuoi giochi app salvarono i dati dovrebbero trasmettere questo evento e lasciare che il tuo servizio venga richiamato dopo aver ascoltato quella trasmissione. carica quindi solo.

    E) Come Phill ha affermato, puoi andare anche per Google Analytics.

    Come si vuole effettivamente fare questo è ora dipende dal tuo requisito

    Spero che questo ti aiuti. Provalo e fai sapere quale problema si sta affrontando

    Utilizzare questo codice di esempio per controllare se il browser è in esecuzione

     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(); } } 

    Per creare un servizio è necessario creare una class che si estende dalla class di base di servizio e implementa la function in un ciclo infinito, ad esempio while(true) nella function onStartCommand() . non dimenticate di aggiungere il tuo servizio nel file manifesto tra i <service></service> , un buon tutorial è su http://www.vogella.com/articles/AndroidServices/article.html

    Seguenti soluzioni basate sull'ipotesi che possediate tutte e cinque le applicazioni che state cercando di monitorare. Se altrimenti vi fornirò un'altra soluzione.

    Facciamo ora il problema.

    1. Servizio di informazioni sull'applicazione dell'applicazione o less.
    2. Progettazione del servizio
    3. memorizzare i dati

    È necessario utilizzare Intent per pubblicare i messaggi relativi all'applicazione dell'applicazione o less. Utilizza attività onPause e onResume per submit messaggi.

    Ora call questa function da onPause e 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); } 

    e puoi call questo come il seguente modo

     public void onPause(){ super.onPause(); broadcastMessage(Thread.currentThread().getStackTrace()[1].getMethodName()); } 

    O

     public void onPause(){ super.onPause(); broadcastMessage("onPause"); } 

    Quindi perché onPause e onResume perché il giocatore sta giocando solo tra queste funzioni chiamate.

    Progettazione del servizio

    Utilizza IntentService e legga questo se vuoi sapere perché.

     @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 } 

    Memorizzazione

    ContentProvider è una buona opzione per la memorizzazione dei dati, ed è anche molto potente; integra e scala bene su Android, ma in questo caso sembra che tu voglia solo memorizzare alcune informazioni molto semplici e in quanto tale puoi anche scegliere qualcosa di molto semplice.

    Il codice bellow utilizza 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); } 

    basta call questo metodo da onHandleIntent .

    L'ultimo pezzo di puzzle sarebbe la distribuzione. Puoi distribuirlo in un'applicazione separata o in una parte di queste cinque applicazioni. Applicazioni separate è il path più semplice da prendere. Ma se scegli di utilizzare questo come parte di tutte le cinque di queste applicazioni, legga questa discussione.

    Per get l'applicazione in esecuzione corrente è ansible utilizzare:

     ActivityManager am = (ActivityManager) mContext.getSystemService(Activity.ACTIVITY_SERVICE); String packageName = am.getRunningTasks(1).get(0).topActivity.getPackageName(); 

    È ansible controllare periodicamente dal servizio in esecuzione. È inoltre necessario definire un'authorization richiesta nel tuo manifesto: android.permission.GET_TASKS

    Installazione di Covenant Eyes sul dispositivo Android verificherà tutto il traffico Internet sul browser preinstallato del telefono e segnalare applicazioni aggiuntive che vengono utilizzate sul dispositivo.

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.