Wie Google Kalender oder Instagram machen ihre apps die ganze Zeit und läuft auch nach Kraft zu stoppen

Sieht aus wie Kraftstopp sollte verhindern, dass App aus laufen und es ist sogar deaktivieren alle App-Alarme. Allerdings habe ich festgestellt, dass die Benachrichtigung in Google Kalender noch gut gezeigt, auch nach Kraft zu stoppen, und ich die ganze Zeit sehen Instagram App läuft, auch wenn ich es töten, ist es nur neu starten automatisch und es ist noch einmal dort.

Also, was ist ein Weg, um App läuft ständig? Ich mache App mit Erinnerungen und müssen Benachrichtigungen in bestimmten Zeit anzeigen, egal wie App zuvor zuvor geschlossen wurde.

  • Wie kann man den geplanten Alarm sparen, nachdem die App von Android oder Task Killer getötet wurde?
  • Wie man aufwacht Android Wear, wenn es im Schlafmodus ist?
  • Benachrichtigungen in bestimmten Zeit jeden Tag android
  • Wie kann man debuggen, welche AlarmManager-Alarme von deiner Anwendung aus laufen?
  • SharedPreferences in BroadcastReceiver scheint nicht zu aktualisieren?
  • Android AlarmManager löst jede "Runde" 10 Minuten aus
  • Datenbank wird nicht entfernt, wenn die Android-Anwendung deinstalliert wird
  • Höhe der Statusleiste?
  • Was ist das Android UiThread (UI Thread)
  • Formatierung der Zeit auf Android, während folgende Einstellungen (24 Stunden Uhr vs. AM / PM, etc ..)
  • Verwickelt mit Google-Test
  • Wie lese ich die im internen Speicher gespeicherte Bilddatei?
  • 6 Solutions collect form web for “Wie Google Kalender oder Instagram machen ihre apps die ganze Zeit und läuft auch nach Kraft zu stoppen”

    Wenn Sie einen Dienst in der Anwendungsklasse starten, wird Ihr Service immer ausgeführt, obwohl, wenn ein Benutzer den Task-Manager beendet oder erzwingt, wird er erneut ausgeführt.

    So erstellen Sie Service speziell im Android Studio Klicken Sie mit der rechten Maustaste auf App aus Project Explorer und dann auf Neu> Service> Service

    Erstellen Sie einen Service:

    public class ServiceName extends Service { @Nullable @Override public IBinder onBind(Intent intent) { return null; } @Override public int onStartCommand(Intent intent, int flags, int startId) { // do your jobs here return super.onStartCommand(intent, flags, startId); } } 

    Erstellen Sie nun eine Anwendungsklasse und starten Sie Service in der Anwendungsklasse

     public class App extends Application { @Override public void onCreate() { super.onCreate(); startService(new Intent(this, ServiceName.class)); } } 

    Ich sehe dort zwei Möglichkeiten.

    Erstens ist eine Ausnahme über Thread.setDefaultUncaughtExceptionHandler() , die mit Java Thread.setDefaultUncaughtExceptionHandler() , ist es nicht von Android SDK.

    Um prägnant zu sein, machen Sie Ihre benutzerdefinierte Application Klasse implementieren UncaughtExceptionHandler und registrieren Sie es als Hörer auf eine Ausnahme in der Anwendung. Sobald ein Crash passiert, wird dieser Rückruf abgefeuert, wo man einen Job in naher Zukunft verzögern kann (zB spawn AlarmManager , um die App wieder in 50ms zu starten).


    Die zweite Möglichkeit ist, dass Sie Ihre Komponenten in verschiedenen Prozessen starten können. Von docs :

    Android: prozess

    Der Name des Prozesses, in dem der Dienst ausgeführt werden soll. Normalerweise werden alle Komponenten einer Anwendung im Standardprozess für die Anwendung erstellt. Es hat den gleichen Namen wie das Anwendungspaket. Das Prozessattribut des Elements kann für alle Komponenten einen anderen Standard setzen. Aber die Komponente kann die Voreinstellung mit ihrem eigenen Prozessattribut überschreiben, so dass Sie Ihre Anwendung über mehrere Prozesse verteilen können.

    Ein Absturz, der auf verschiedenen Prozess passiert wird nicht den Prozess, der Gastgeber Ihre Benutzeroberfläche zum Absturz.

    Nun für Starter haben sie ein Job Scheduler-System, das Aufträge plant, um ausgeführt zu werden, können diese Jobs gestoppt, gestartet oder wieder aufgenommen werden. Sie implementieren einen Mechanismus, um Crash zu erkennen, denken Sie Java-Skript wo, wenn eine Anwendung abstürzt, kann es neu gestartet werden (nodemon oder für immer), in android gibt es Dienste, die gestartet oder wieder aufgenommen werden können. Es gibt dieses spezielle Dienstverhalten, um abgestürzte Dienste neu zu starten .

    START_REDELIVER_INTENT- teilt dem System mit, den Service nach dem Crash neu zu starten und auch die zum Zeitpunkt des Crashs vorhandenen Absicht neu zu machen.

    Die Android 5.0 Lollipop (API 21) Version führt eine Job Scheduler API über die JobScheduler Klasse ein. Diese API ermöglicht es, Aufträge zu sammeln, wenn das Gerät über mehr Ressourcen verfügt. Im Allgemeinen kann diese API verwendet werden, um alles zu planen, das für den Benutzer nicht zeitkritisch ist.

    Sie können auch Alarme, Rundfunkempfänger und Threading mit reaktiver Programmierung kombinieren, um den Job auszuführen.Alarms (basierend auf der AlarmManager-Klasse) geben Ihnen einen Weg, um zeitbasierte Operationen außerhalb der Lebensdauer Ihrer Anwendung durchzuführen. Zum Beispiel könnten Sie einen Alarm verwenden, um einen langwierigen Betrieb zu starten, z. B. das Starten eines Dienstes einmal pro Tag, um eine Wettervorhersage herunterzuladen.

    Sie können Observablen an bestimmte Aufgaben anhängen, die bestimmte Operationen durchführen, Sie können asynchrone i / o, rechnerische Operationen oder sogar "unendliche" Datenströme implementieren, indem Sie Ihre eigenen Observable entwerfen.

    Nur um mit Sagar Damanis Antwort zu ergänzen, ist ein Service-Aufruf erforderlich, um Ihre lange Operation im Hintergrund laufen zu lassen, aber sie laufen auch in sepearate Prozesse. Wenn Sie einen Dienst oder eine Aktivität in der androidMenifes.xml deklarieren, fügen Sie auch das Attribut android: process = "" hinzu. Daher wird es immer beharrlich sein, wenn der Benutzer tötet / Kraft stoppt die Aktivität.

    Basierend auf meinem begrenzten Wissen, müssen Sie AlarmManager , WakefulBroadcastReceiver und einen Service oder IntentService für all diese Hintergrundaufgabe erstellen. Lesen Sie hier mehr darüber. Ich habe einen Service, den ich für meine Firebase Messaging App verwendet habe und es funktioniert gut, auch nachdem der Benutzer die App getötet hat. In meinem Fall verbinde ich mit Firebase zu einem festen Zeitraum mit dem folgenden Service.

    Zuerst habe ich die folgende Klasse, um den AlarmManager .

     public class FirebaseHandler { private Context context; private static final long FIREBASE_ALARM_CYCLE_TIME = 300000; // constructors public FirebaseHandler(Context context) { this.context = context; } // set alarm public void setAlarm() { // create pending intent Intent intent = new Intent(context, AlarmReceiver.class); intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); final PendingIntent pendingIntent = PendingIntent.getBroadcast( context, AlarmReceiver.ALARM_REQUEST_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT); // create alarm AlarmManager alarm = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); alarm.setInexactRepeating( AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + FIREBASE_ALARM_CYCLE_TIME, FIREBASE_ALARM_CYCLE_TIME, pendingIntent); } } 

    Ich new FirebaseHandler(getApplicationContext()).setAlarm() einfach ein, indem new FirebaseHandler(getApplicationContext()).setAlarm() irgendwo in der Aktivität. Die AlarmReceiver Klasse ist wie folgt.

     public class AlarmReceiver extends WakefulBroadcastReceiver { public static final int ALARM_REQUEST_CODE = 12345; @Override public void onReceive(Context context, Intent wakefulIntent) { Intent intent = new Intent(context, FirebaseAlarmService.class); startWakefulService(context, intent); } } 

    Die FirebaseAlarmService Klasse ist wie folgt.

     public class FirebaseAlarmService extends Service { private static final String CLASSNAME = FirebaseAlarmService.class.getSimpleName(); private HandlerThread handlerThread; // onStartCommand @Override public int onStartCommand(final Intent intent, int flags, final int startId) { // start a new thread // this depends on your need. I need to do a continuous operation for some time // you can use IntentService too handlerThread = new HandlerThread(CLASSNAME); handlerThread.start(); Handler handler = new Handler(handlerThread.getLooper()); Runnable runnable = new Runnable() { @Override public void run() { // all your codes here for the background task... // remember to release the wake lock and stop service AlarmReceiver.completeWakefulIntent(wakefulIntent); stopSelf(); } return START_NOT_STICKY; } // this is the part that does the trick @Override public void onTaskRemoved(Intent rootIntent) { super.onTaskRemoved(rootIntent); // when the service is killed, start it again new FirebaseHandler(getApplicationContext()).setAlarm(); } // onDestroy @Override public void onDestroy() { super.onDestroy(); // make sure to quit the thread handlerThread.quit(); } } 

    Zusammenfassend setzt FirebaseHandler einen AlarmManager , der regelmäßig WakefulBroadcastReceiver AlarmManager , der regelmäßig einen Service startet. Wenn der Dienst getötet wird, startet der Dienst selbst den AlarmManager erneut onTaskRemoved .

    Im AndroidManifest müssen Sie die folgende Berechtigung für die Wake Lock hinzufügen.

     <uses-permission android:name="android.permission.WAKE_LOCK" /> 

    Denken Sie auch daran, den Empfänger hinzuzufügen.

     <receiver android:name=".receiver.AlarmReceiver" android:process=":remote" /> 

    BONUS: Vielleicht möchten Sie den Service starten, sobald das Telefon neu gestartet wird oder die App über PlayStore aktualisiert wird. Erstellen Sie einen weiteren WakefulBroadcastReceiver .

     public class BootBroadcastReceiver extends WakefulBroadcastReceiver { @Override public void onReceive(Context context, Intent wakefulIntent) { // check if user is login, then set the alarm if (isLogin) { new FirebaseHandler(context).setAlarm(); } // remove wake lock WakefulBroadcastReceiver.completeWakefulIntent(wakefulIntent); } } 

    AndroidManifest im AndroidManifest die erforderliche Berechtigung hinzu.

     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> 

    Füge den Absichtsfilter hinzu.

     <receiver android:name=".receiver.BootBroadcastReceiver"> <intent-filter> <!-- get notified on reboot --> <action android:name="android.intent.action.BOOT_COMPLETED" /> <!-- get notified on app updated --> <action android:name="android.intent.action.MY_PACKAGE_REPLACED" /> </intent-filter> </receiver> 

    TIPPS: Manchmal findest du, dass die obige Methode nicht funktioniert. Das ist meistens nicht deine schuld Es sind die Sicherheitseinstellungen des Telefons, die das verursacht haben, vor allem Mi Telefone. Der Benutzer muss die App "vertrauen" und "Auto-Start" in den Telefoneinstellungen aktivieren, dann sollte alles gut funktionieren.

    Anzeigen von Benachrichtigungen ist eine gemeinsame Funktionalität von Android Services und es gibt bereits viele Fragen, wie zu verhindern, dass Dienste gestoppt werden / oder von Kraft schließen.

    Die relevanten Fragen sind nachfolgend aufgeführt:

    Android: Wie kann ich die Anwendung automatisch neu starten, nachdem es "Kraft geschlossen" wurde?

    Wie zu verhindern, dass Android-Service getötet wird (Service mit Benachrichtigung)

    Wie man einen Service in Android neu starten?

    Halten Sie den Dienst laufen

    Starten Sie den Service neu, auch wenn die App kraftbetont ist und halten Sie den Dienst im Hintergrund auch nach dem Schließen der App Wie?

    Um sie zusammenzufassen, ist der erste Schritt, einen BroadcastReceiver zu implementieren, der auf BOOT_COMPLETED hört. Dies bedeutet, dass Ihr Dienst aktiv wird, wenn das Android-Gerät eingeschaltet ist. Um dies zu tun, legst du den folgenden Code in das Manifest:

     <receiver android:name=".MyBootCompletedReceiver"> <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED"/> </intent-filter> </receiver> 

    Achten Sie auch darauf, die fertige Bootberechtigung einzuschließen:

     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/> 

    Dann implementiere den BroadcastReceiver:

     public class MyBootCompletedReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { Intent myService = new Intent(context, MyLongRunningService.class); context.startService(myService); } } 

    Wenn du den Service START_STICKY , kannst du START_STICKY der dem Android OS sagt, den Dienst neu zu starten, wenn er vom Betriebssystem unter Bedingungen von begrenzten Ressourcen gequetscht wird:

     public class MyLongRunningService extends Service { @Override public void onCreate() { super.onCreate(); //inject dependencies if necessary } public int onStartCommand(Intent intent, int flags, int startId) { //setup, then return START_STICKY; } } 

    Im Allgemeinen werden Services, die von Apps gestartet werden, vom Android-Betriebssystem gestoppt, wenn das Gerät auf Ressourcen gerät ist. Wenn Sie START_STICKY wird dem Betriebssystem START_STICKY dass der Dienst neu START_STICKY , wenn er gestoppt werden soll. Daher wird durch die Sicherstellung, dass der Service gestartet wird, wenn das Gerät eingeschaltet ist und indem es darauf hinweist, dass es neu gestartet wird, wenn es unter Bedingungen niedriger Ressource gestoppt wird, haben Sie einen Service ausgeführt, der ständig läuft.

    Dies ist das grundlegendste Muster für die Gewährleistung Ihres Service (und damit Anwendung) läuft die ganze Zeit, was war Ihre Anforderung.

    Es gibt zusätzliche Maßnahmen, die Sie annehmen können, die in den anderen Antworten hierher umrissen werden, aber sie sollten als Ergänzung zur Implementierung eines Dienstes gesehen werden, der auf BOOT_COMPLETED beginnt und der Neustart BOOT_COMPLETED , wenn er unter Bedingungen von niedrigen Ressourcen gestoppt wird .

    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.