Android-Dienst muss immer ausgeführt werden (Niemals pausieren oder stoppen)

"Ist es möglich, diesen Dienst immer auszuführen, wenn die Anwendung angehalten wird, und etwas anderes?"

Ja.

1. In der Service-Methode onStartCommand geben Sie START_STICKY zurück.

   public int onStartCommand(Intent intent, int flags, int startId) {
           return START_STICKY;
   }
   

2. Starten Sie den Dienst im Hintergrund mit startService (MyService), damit er unabhängig von der Anzahl der gebundenen Clients immer aktiv bleibt. 

   Intent intent = new Intent(this, PowerMeterService.class);
   startService(intent);
   

3. Erstellen Sie die Mappe.

   public class MyBinder extends Binder {
           public MyService getService() {
                   return MyService.this;
           }
   }
   

4. Definieren Sie eine Serviceverbindung.

   private ServiceConnection m_serviceConnection = new ServiceConnection() {
           public void onServiceConnected(ComponentName className, IBinder service) {
                   m_service = ((MyService.MyBinder)service).getService();
           }
   
           public void onServiceDisconnected(ComponentName className) {
                   m_service = null;
           }
   };
   

5. Binden Sie den Dienst mithilfe von bindService.

           Intent intent = new Intent(this, MyService.class);
           bindService(intent, m_serviceConnection, BIND_AUTO_CREATE);
   

6. Für Ihren Dienst möchten Sie möglicherweise eine Benachrichtigung erhalten, um die entsprechende Aktivität zu starten, sobald diese geschlossen wurde.

   private void addNotification() {
           // create the notification
           Notification.Builder m_notificationBuilder = new Notification.Builder(this)
                   .setContentTitle(getText(R.string.service_name))
                   .setContentText(getResources().getText(R.string.service_status_monitor))
                   .setSmallIcon(R.drawable.notification_small_icon);
   
           // create the pending intent and add to the notification
           Intent intent = new Intent(this, MyService.class);
           PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
           m_notificationBuilder.setContentIntent(pendingIntent);
   
           // send the notification
           m_notificationManager.notify(NOTIFICATION_ID, m_notificationBuilder.build());
   }
   

7. Sie müssen das Manifest ändern, um die Aktivität im Single-Top-Modus zu starten.

             Android:launchMode="singleTop"
   

8. Beachten Sie, dass das System möglicherweise beendet wird, wenn das System die Ressourcen benötigt und Ihr Service nicht sehr aktiv ist. Wenn dies nicht akzeptabel ist, bringen Sie den Dienst mit startForeground in den Vordergrund.

           startForeground(NOTIFICATION_ID, m_notificationBuilder.build());
   

Um einen Dienst in einem eigenen Prozess zu starten, müssen Sie Folgendes in der XML-Deklaration angeben.

<service
  Android:name="WordService"
  Android:process=":my_process" 
  Android:icon="@drawable/icon"
  Android:label="@string/service_name"
  >
</service> 

Hier finden Sie ein gutes Tutorial, das mir wirklich nützlich war

http://www.vogella.com/articles/AndroidServices/article.html

Hoffe das hilft

Eine einfache Lösung besteht darin, den Dienst neu zu starten, wenn das System ihn stoppt.

Ich fand diese sehr einfache Implementierung dieser Methode:

So machen Sie den Android-Dienst unaufhaltsam

Sie können startForeground für den Dienst implementieren. Selbst wenn dieser Dienst stirbt, können Sie ihn mit START_STICKY für startCommand() erneut starten. Nicht sicher, ob dies die richtige Implementierung ist.

Wenn Sie bereits einen Dienst haben und möchten, dass er ständig funktioniert, müssen Sie zwei Dinge hinzufügen:

1. im Dienst selbst:

   public int onStartCommand(Intent intent, int flags, int startId) {
       return START_STICKY;
   }
   

2. Im Manifest:

   Android:launchMode="singleTop"
   

Sie müssen keine Bindung hinzufügen, es sei denn, Sie benötigen sie im Dienst.

Ich hatte dieses Problem überwunden und mein Beispielcode lautet wie folgt.

Fügen Sie die folgende Zeile in Ihre Hauptaktivität ein, hier ist BackGroundClass die Serviceklasse. Sie können diese Klasse in New -> JavaClass erstellen (Fügen Sie in dieser Klasse den Prozess (Aufgaben) hinzu, in dem Sie im Hintergrund ausgeführt werden müssen). . Bezeichnen Sie sie aus Bequemlichkeitsgründen zunächst mit dem Benachrichtigungsklingelton als Hintergrundprozess.

 startService(new Intent(this, BackGroundClass .class));

Fügen Sie in der BackGroundClass einfach meine Codierungen ein und Sie können das Ergebnis sehen.

import Android.app.Service;
import Android.content.Intent;
import Android.media.MediaPlayer;
import Android.os.IBinder;
import Android.provider.Settings;
import Android.support.annotation.Nullable;
import Android.widget.Toast;

public class BackgroundService  extends Service {
    private MediaPlayer player;
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
     player = MediaPlayer.create(this,Settings.System.DEFAULT_RINGTONE_URI);
        player.setLooping(true);
         player.start();
        return START_STICKY;
    }
 @Override
    public void onDestroy() {
        super.onDestroy();
         player.stop();
    }
}

Versuchen Sie in AndroidManifest.xml, dies hinzuzufügen.

<service Android:name=".BackgroundService"/>

Starten Sie das Programm, öffnen Sie einfach die Anwendung. Möglicherweise finden Sie die Benachrichtigungswarnung im Hintergrund. Sie können zwar die Anwendung beenden, aber Sie haben möglicherweise noch einen Klingelton gehört, es sei denn, Sie haben die Anwendung ausgeschaltet oder die Anwendung deinstalliert. Dies bedeutet, dass sich die Benachrichtigungswarnung im Hintergrundprozess befindet. So können Sie einen Prozess für den Hintergrund hinzufügen. 

Art Achtung: Bitte nicht mit TOAST überprüfen, da es nur einmal ausgeführt wird, obwohl es sich im Hintergrund befindet.

Hoffe es wird helfen ... !!

Ich habe einen einfachen und klaren Weg gefunden, den Service immer laufen zu lassen. 

Dieser Typ hat es so klar erklärt und einen guten Algorithmus verwendet. Sein Ansatz besteht darin, eine Rundsendung zu senden, wenn der Dienst kurz vor dem Tod steht, und dann den Dienst neu zu starten. 

Sie sollten es ausprobieren: http://fabcirablog.weebly.com/blog/creating-a-never-ending-background-service-in-Android

Fügen Sie dies im Manifest hinzu.

      <service
        Android:name=".YourServiceName"
        Android:enabled="true"
        Android:exported="false" />

Fügen Sie eine Serviceklasse hinzu.

public class YourServiceName extends Service {


    @Override
    public void onCreate() {
        super.onCreate();

      // Timer task makes your service will repeat after every 20 Sec.
       TimerTask doAsynchronousTask = new TimerTask() {
            @Override
            public void run() {
                handler.post(new Runnable() {
                    public void run() {
                       // Add your code here.

                     }

               });
            }
        };
  //Starts after 20 sec and will repeat on every 20 sec of time interval.
        timer.schedule(doAsynchronousTask, 20000,20000);  // 20 sec timer 
                              (enter your own time)
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // TODO do something useful

      return START_STICKY;
    }

}

Sie benötigen keinen Rundfunkempfänger. Wenn Sie etwas Schmerz nehmen würden, kopieren Sie eines der api (serviceconnection) aus dem obigen Beispiel von Stephen Donecker und fügen Sie es in google ein. Sie würden dies erhalten, https://www.concretepage.com/Android/android-local-bound- Service-Beispiel-mit-Binder-und-Service-Verbindung