Teil-1 persistent foreGround Android-Service, der von UI beginnt, arbeitet auch im Sleep-Modus, startet auch beim Neustart des Telefons

Status:--- Ich akzeptiere auch die Antwort von Karakuri und Sharad Mhaske , aber da Sharad Mhaske nach dem Beginn der Prämie antwortet, sollte die Prämie zu ihm gehen.

Teil-2 gemacht: Teil-2 persistent foreGround Android-Service, der von UI beginnt, arbeitet auch im Schlafmodus, startet auch beim Telefonstart

  • Xperia Z Emulator
  • Holen Sie sich SSID, wenn WIFI angeschlossen ist
  • Android Socket Ausgabe auf Samsung Galaxy S4 (SGS4)
  • Android IntentService startet nicht
  • Android: layout_height 50% der Bildschirmgröße
  • HTML5 oder Android
  • Im stack overflow kann nur eine Antwort akzeptiert werden . Ich sehe beide Antworten als akzeptabel, aber man muss gewählt werden (ich habe zufällig entschieden).

    Zuschauer sind eingeladen, up / down Abstimmung Antworten / Frage zu schätzen die Anstrengung! . Ich habe die Antwort von Karakuri, um den Ruf zu entschädigen.

    Scenario:---

    1. Ich möchte den Benutzer auf eine Start / Stopp-Taste klicken und einen Service aus der UI-Aktivität starten / stoppen. Ich habe die Benutzeroberfläche so egal, dass. Aber nur die Logik des Button-Klick-Ereignisses.

    2. Ich möchte nicht, dass der Service an die UI-Aktivität gebunden ist . Wenn die Aktivität beendet ist, sollte der Dienst weiterlaufen.

    3. Wollen Sie die meiste Anstrengung machen , dass der Service beharrlich ist und nicht auf jeden Fall aufhört. Wird es das meiste Gewicht geben und es als ForGroundSerice laufen ForGroundSerice da es eine höhere Hierarchie von Bedeutung hat. (Hoffe das ist ok?)

    4. Es sei denn, die Stopptaste wird von meinem Apps-UI geklickt , wünschte nicht, dass es gestoppt wird (oder sollte sich selbst neu starten) Auch wenn android reclaim Speicher. Ich und der Benutzer des Telefons, beide sind / werden sich dessen bewusst sein. Der Service ist von größter Bedeutung. Auch im Schlaf.

      Details = meine App mach einige Operationen, schlaf für Benutzer zur Verfügung gestellt Zeit (15 Minuten in der Regel), weckt und führt Operationen wieder. Das endet nie)

      Wenn ich AlarmManager brauche, wie man das implementiert? Oder irgendwie anders Oder setzen Sie einfach die Operationen in eine nie endende while loop and sleep for 15 minuts am Ende?

    5. Wenn der Dienst gestartet wird (durch Anklicken der Starttaste). Es sollte einen Eintrag machen, damit es automatisch startet, wenn das Telefon neu startet.

    QUESTION:---

    Primary Question:

    1. Nur kann man nicht eine optimale Strategie für das Szenario … und auch auf kleine Bits von Code , die man zu verwenden und wie.

    2. Gesammelte Bits und Stücke von stackoverflow.com Fragen, developer.android.com und einige Google Ergebnisse, aber kann nicht in Integration implementieren.

    3. Bitte lesen Sie den Abschnitt Anfragen aus .

    Secondary Question:

    Die Kommentare in meinem Code sind die kleinen Fragen.

    Research and Code:---

    Strategie:

      want this to happen every time the user opens the UI. //Start Button:----- //check if ForGroundService is running or not. if not running, make var/settings/etc "serviceStatus" as false <-------(how and where to stare this and below stated boolean?) //start ForGroundService <-------(how?) //make "SericeStatus" as true //check if "ServiceStartOnBoot" is false //Put ForGroundService to start on boot -------(to make it start when ever the phone reboots/restarts) <-------(how?) //make "ServiceStartOnBoot" as true // the boolean can also be used to check the service status. //Stop Button:------ //makes SericeStatus and ServiceStartOnBoot as false //stops service and deletes the on boot entry/strategy 

    Aktivitäts-UI-Klasse, die den Dienst startet / stoppt:

     public class SettingsActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_settings); //some button here to start / stop and their onClick Listners Intent mySericeIntent = new Intent(this, TheService.class); } private void startMyForGroundService(){ startService(mySericeIntent); } private void stopMyForGroundSerice(){ stopService(mySericeIntent); /////// is this a better approach?. stopService(new Intent(this, TheService.class)); /////// or making Intent mySericeIntent = new Intent(this, TheService.class); /////// and making start and stop methods use the same? /////// how to call stopSelf() here? or any where else? whats the best way? } } 

    Die Serviceklasse:

      public class TheService extends Service{ @Override public IBinder onBind(Intent arg0) { // TODO Auto-generated method stub return null; } @Override public int onStartCommand(Intent intent, int flags, int startId) { startForeground(1, new Notification()); ////// will do all my stuff here on in the method onStart() or onCreat()? return START_STICKY; ///// which return is better to keep the service running untill explicitly killed. contrary to system kill. ///// http://developer.android.com/reference/android/app/Service.html#START_FLAG_REDELIVERY //notes:-// if you implement onStartCommand() to schedule work to be done asynchronously or in another thread, //then you may want to use START_FLAG_REDELIVERY to have the system re-deliver an Intent for you so that it does not get lost if your service is killed while processing it } @Override public void onDestroy() { stop(); } public void stop(){ //if running // stop // make vars as false // do some stopping stuff stopForeground(true); /////// how to call stopSelf() here? or any where else? whats the best way? } } 

    Die Menifest-Datei:

      <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.myapp" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="10" android:targetSdkVersion="17" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <uses-permission android:name="android.permission.INTERNET" /> <application android:allowBackup="true" android:debuggable="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > <activity android:name="com.example.myapp.MainActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <activity android:name="com.example.myapp.SettingsActivity" android:label="@string/title_activity_settings" > </activity> </application> </manifest> 

    References:---

    Android – Implementierung startForeground für einen Service? Zeigte Antwort 1, Beispielcode.

    Versuchen, einen Dienst beim Booten auf Android zu starten

    Android: Starten Sie den Dienst beim Booten?

    Http://developer.android.com/guide/components/services.html

    Http://developer.android.com/reference/android/app/Service.html

    Http://developer.android.com/training/run-background-service/create-service.html nicht von mir vorgegeben.

    Http://developer.android.com/guide/components/processes-and-threads.html Mein Ausgangspunkt der Forschung

    Requests:---

    Ich denke, diese Frage ist eine normale Praxis für die meisten Menschen, die mit Dienstleistungen zu tun haben. In dieser Vision, bitte nur beantworten, wenn Sie Erfahrung im Szenario haben und können umfassend erklären, die Aspekte und Strategie mit maximalem Beispielcode als komplette Version, so wäre es eine Hilfe für die Gemeinschaft als auch.

    Abstimmung auf und ab (mit Verantwortung) auf die Antworten, wie es für mich wichtig ist, die ihre Ansichten, Zeit und Erfahrung teilten und mir und der Gemeinschaft geholfen haben.

  • Neue wählbare TextView in Android 3 (API <= 11) Komponente
  • Android - Layout_Gravity programmgesteuert für LinearLayout einstellen
  • Firebase JobDispatcher - wie funktioniert es im Vergleich zu früheren APIs (JobScheduler und GcmTaskService)?
  • Android 4.3 Virtual Device CPU / ABI - Keine Systembilder installiert (Eclipse)
  • Aktualisierungsbalken in der Benachrichtigungsleiste aktualisieren
  • So aktualisieren Sie die Versionsnummer der Antwort native app
  • 3 Solutions collect form web for “Teil-1 persistent foreGround Android-Service, der von UI beginnt, arbeitet auch im Sleep-Modus, startet auch beim Neustart des Telefons”

    Que: Willst du die meiste Anstrengung machen, dass der Service persistent ist und nicht auf jeden Fall aufhört. Wird es das meiste Gewicht geben und es als ForGroundSerice laufen lassen, da es eine höhere Hierarchie von Bedeutung hat. (Hoffe das ist ok?)

    Antwort: Du musst den Service mit START_STICKY Intent Flag starten.

     @Override public int onStartCommand(Intent intent, int flags, int startId) { // We want this service to continue running until it is explicitly // stopped, so return sticky. return START_STICKY; } 

    Que: Wenn ich AlarmManager brauche, wie man das implementiert? Oder irgendwie anders Oder setzen Sie einfach die Operationen in eine nie endende Loop und schlafen für 15 Minuten am Ende?

    Antwort: Sie müssen Alarmmanager im Dienst für die Zeit nach einer Aufgabe registrieren . // Alarmmanager innerhalb des Dienstes registrieren.

     PendingIntent pendingIntent = PendingIntent.getBroadcast(getApplicationContext(), 0, new Intent("com.xxxxx.tq.TQServiceManager"), PendingIntent.FLAG_UPDATE_CURRENT); AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE); alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + 1000 , 30 * 1000 , pendingIntent); 

    // Jetzt habe ich einen Rundfunkempfänger, um diese Absicht zu erhalten.

     class Alarmreceiver extends Broadcastreceiver { //u can to task in onreceive method of receiver. } 

    // Diese Klasse in Manifest für Alarmempfänger-Aktion registrieren.

    Que: Wenn der Dienst gestartet wird (durch Anklicken der Starttaste). Es sollte einen Eintrag machen, damit es automatisch startet, wenn das Telefon neu startet.

    Antwort: Verwenden Sie Broadcast Reciver, um auf Onboot abgeschlossene Absicht zu hören.

     public class StartAtBootServiceReceiver extends BroadcastReceiver{ @Override public void onReceive(Context context, Intent intent) { try { if( "android.intent.action.BOOT_COMPLETED".equals(intent.getAction())) { ComponentName comp = new ComponentName(context.getPackageName(), LicensingService.class.getName()); ComponentName service = context.startService(new Intent().setComponent(comp)); if (null == service){ // something really wrong here //Log.Write("Could not start service " + comp.toString(),Log._LogLevel.NORAML); } } else { //Log.Write("Received unexpected intent " + intent.toString(),Log._LogLevel.NORAML); } } catch (Exception e) { //Log.Write("Unexpected error occured in Licensing Server:" + e.toString(),Log._LogLevel.NORAML); } } } 

    // muss diesen Receiver für Action_BOOTCOMPLETED Intent in manifest.xml Datei registrieren Hope das hilft dir, Dinge auszuprobieren 🙂

    Wenn du einen Service mit startService() , läuft es auch dann, wenn die Aktivität geschlossen wird. Es wird nur gestoppt, wenn du stopService() oder wenn du jemals stopSelf() anruft (oder wenn das System deinen Prozess zum Abrufen des Speichers tötet).

    Um den Dienst beim Booten zu starten, machen Sie einen BroadcastReceiver, der gerade den Service startet:

     public class MyReceiver extends BroadcastReceiver { public void onReceive(Context context, Intent intent) { Intent service = new Intent(context, MyService.class); context.startService(service); } } 

    Dann füge diese zu deinem Manifest hinzu:

     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> <application ... > <receiver android:name="MyReceiver" android:enabled="false" > <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED" /> </intent-filter> </receiver> </application> 

    Beachten Sie, dass der Empfänger zuerst nicht aktiviert ist. Wenn der Benutzer Ihren Dienst startet, verwenden Sie PackageManager, um den Empfänger zu aktivieren. Wenn der Benutzer Ihren Dienst stoppt, verwenden Sie PackageManager, um den Empfänger zu deaktivieren. In deiner Aktivität:

     PackageManager pm = getPackageManager(); ComponentName receiver = new ComponentName(this, MyReceiver.class); pm.setComponentEnabledSetting(receiver, PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); 

    Verwenden Sie dieselbe Methode mit PackageManager.COMPONENT_ENABLED_STATE_DISABLED , um es zu deaktivieren.

    Ich habe so etwas selber gemacht, aber ich habe viel gelernt, während ich es entwickelt habe und entdeckte, dass es nicht ganz nötig ist, den Service laufen zu lassen, der den ganzen Tag abläuft. Was ich gemacht habe, ist folgendes:

    Implementieren Sie einen Service, der auf Ereignisse reagiert. In meiner Besonderheit wollte ich meine Wifi und mobile Datenverbindung automatisieren. So reagiere ich auf Ereignisse wie Wifi-Verbindung und Trennung, Bildschirm ein- und ausschalten, etc. Also dieser Service führt aus, was jemals ausgeführt werden muss, um auf dieses Ereignis zu reagieren und dann stoppt, Scheduling alle weiteren Aktionen mit dem AlarmManager wenn nötig.

    Jetzt können diese Ereignisse von Timern wie Sie sich alle 15 Minuten sagen, es tut etwas und schläft, das klingt für mich, dass Sie wirklich nicht wollen, dass der Service läuft rund um die Uhr, sondern nur die Ausführung von alle 15 Minuten. Das ist mit dem AlarmManager vollkommen erreichbar, ohne dass Ihr Service für immer läuft.

    Ich empfehle, diesen Service aus dem WakefulIntentService von commonsware zu implementieren .

    Diese Klasse verarbeitet das WakeLock schon für dich, damit du Code auch dann auslöschen kannst, wenn das Telefon schläft. Es wird einfach aufwachen und wieder schlafen gehen

    Jetzt. Über Ihre Frage bezüglich der Aktivität, die den Service beginnt und stoppt. Sie können in der Schaltfläche implementieren, dass es den AlarmManager Alarm startet oder abbricht. Auch können Sie die sharedPreferences verwenden, um eine einfache Boolesche zu speichern, die Ihnen sagt, ob es aktiviert ist oder nicht, so dass das nächste Mal, wenn Ihr Service läuft, es den Wert lesen kann und wissen, ob es weitergehen oder stoppen soll.

    Wenn du es als einen ereignisreaktiven Service implementierst, wie ich schon sagte, kann dein Knopf sogar auf Sendungen reagieren, damit deine Aktivität nicht einmal den Service direkt anrufen muss, sondern nur eine Absicht sendet und der Service kann ihn wie andere Events auswählen. Verwenden Sie dazu einen BroadcastReceiver.

    Ich werde versuchen, Beispiele zu geben, aber seien Sie vorsichtig, dass das, was Sie fragen, ist viel Code, um es an einem Ort …

    BootReceiver:

     public class BootReceiver extends BroadcastReceiver { private static final String TAG = BootReceiver.class.getSimpleName(); @Override public void onReceive(final Context context, final Intent intent) { final Intent in = new Intent(context, ActionHandlerService.class); in.setAction(Actions.BOOT_RECEIVER_ACTION); //start the service with a flag telling the event that triggered Log.i(TAG, "Boot completed. Starting service."); WakedIntentService.sendWakefulWork(context, in); } } 

    Bedienung:

     public class ActionHandlerService extends WakedIntentService { private enum Action { WIFI_PULSE_ON, WIFI_PULSE_OFF, DATA_PULSE_ON, DATA_PULSE_OFF, SCREEN_ON, SCREEN_OFF, WIFI_CONNECTS, WIFI_DISCONNECTS, WIFI_CONNECT_TIMEOUT, WIFI_RECONNECT_TIMEOUT, START_UP, BOOT_UP } public ActionHandlerService() { super(ActionHandlerService.class.getName()); } @Override public void run(final Intent intent) { mSettings = PreferenceManager.getDefaultSharedPreferences(this); mSettingsContainer.enabled = mSettings.getBoolean(getString(R.string.EnabledParameter), false); if (intent != null) { final String action = intent.getAction(); if (action != null) { Log.i(TAG, "received action: " + action); if (action.compareTo(Constants.Actions.SOME_EVENT) == 0) { //Do what ever you want } else { Log.w(TAG, "Unexpected action received: " + action); } } else { Log.w(TAG, "Received null action!"); } } else { Log.w(TAG, "Received null intent!"); } } } 

    Und dein Manifest könnte so etwas machen:

     <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" package="com.yourcompany.yourapp" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="7" android:targetSdkVersion="17" /> <uses-permission android:name="android.permission.WAKE_LOCK" /> <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> <application android:allowBackup="false" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > <activity android:name="com.yourcompany.yourapp.activities.HomeActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <service android:name="com.yourcompany.yourapp.services.ActionHandlerService" /> <receiver android:name="com.yourcompany.yourapp.receivers.BootReceiver" > <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED" /> <category android:name="android.intent.category.HOME" /> </intent-filter> </receiver> </application> </manifest> 
    Das Android ist ein Google Android Fan-Website, Alles über Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.