Mit Service den Hintergrund ausführen und Benachrichtigungen erstellen

Die Frage ist relativ alt, aber ich hoffe, dass dieser post noch relevant sein könnte für andere.

TL;DR: verwenden AlarmManager um einen task zu planen, verwenden Sie IntentService, siehe Beispiel-code hier;

Was dieser test-Anwendung(und Unterricht):

Einfache helloworld-app, die sendet Sie die Meldung alle 2 Stunden. Ein Klick auf die Benachrichtigung, öffnet sich die sekundären Aktivitäten werden in der app; löschen von Mitteilung tracks.

Wann sollten Sie es verwenden:

Sobald Sie ausführen müssen einige Aufgaben nach einem Zeitplan.
Mein eigener Fall: einmal ein Tag, ich möchte zu Holen, neue Inhalte vom server, verfassen Sie eine Mitteilung auf der Grundlage der Inhalte, die ich bekam, und zeigen Sie auf Benutzer.

, Was zu tun ist:

1. Erstellen wir als erstes 2 Aktivitäten: MainActivity, die beginnt notification-service und NotificationActivity, die gestartet werden, indem Sie auf die Benachrichtigung:

   activity_main.xml

   <?xml version="1.0" encoding="utf-8"?>
   <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:padding="16dp">
       <Button
           android:id="@+id/sendNotifications"
           android:onClick="onSendNotificationsButtonClick"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="Start Sending Notifications Every 2 Hours!" />
   </RelativeLayout>

   MainActivity.java

   public class MainActivity extends AppCompatActivity {
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
       }
   
       public void onSendNotificationsButtonClick(View view) {
           NotificationEventReceiver.setupAlarm(getApplicationContext());
       }   
   }

   und NotificationActivity ist jede beliebige Aktivität, die Sie mit oben kommen kann. NB! Vergessen Sie nicht, fügen Sie beide Tätigkeiten in AndroidManifest.

2. Dann erstellen wir WakefulBroadcastReceiver broadcast receiver, rief ich NotificationEventReceiver im code oben.

   Hier werden wir AlarmManager Feuer PendingIntent alle 2 Stunden (oder mit einer anderen Frequenz), und geben Sie die behandelten Aktionen dieser Absicht in onReceive() Methode. In unserem Fall - wakefully start IntentService, die wir angeben werden, die in den späteren Schritten. Diese IntentService würde generieren Benachrichtigungen für uns.

   Auch, dass dieser receiver enthält einige helper-Methoden, wie das erstellen von PendintIntents, die wir später verwenden werden

   NB1! Als ich bin mit WakefulBroadcastReceiver, ich muss hinzufügen, extra-Erlaubnis in mein manifest: <uses-permission android:name="android.permission.WAKE_LOCK" />

   NB2! Ich benutze es Wachen version von broadcast-receiver, wie ich will, um sicherzustellen, dass das Gerät nicht zu gehen Sie zurück zu schlafen, während mein IntentService's Betrieb. In der Hallo-Welt-es ist nicht so wichtig (wir haben keine lang andauernden Betrieb in unserem Dienst, aber stellen Sie sich vor, wenn Sie zu Holen, relativ große Dateien vom server während dieses Vorgangs). Lesen Sie mehr über das Gerät Wach hier.

   NotificationEventReceiver.java

   public class NotificationEventReceiver extends WakefulBroadcastReceiver {
   
       private static final String ACTION_START_NOTIFICATION_SERVICE = "ACTION_START_NOTIFICATION_SERVICE";
       private static final String ACTION_DELETE_NOTIFICATION = "ACTION_DELETE_NOTIFICATION";
       private static final int NOTIFICATIONS_INTERVAL_IN_HOURS = 2;
   
       public static void setupAlarm(Context context) {
           AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
           PendingIntent alarmIntent = getStartPendingIntent(context);
           alarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
                   getTriggerAt(new Date()),
                   NOTIFICATIONS_INTERVAL_IN_HOURS * AlarmManager.INTERVAL_HOUR,
                   alarmIntent);
       }
   
       @Override
       public void onReceive(Context context, Intent intent) {
           String action = intent.getAction();
           Intent serviceIntent = null;
           if (ACTION_START_NOTIFICATION_SERVICE.equals(action)) {
               Log.i(getClass().getSimpleName(), "onReceive from alarm, starting notification service");
               serviceIntent = NotificationIntentService.createIntentStartNotificationService(context);
           } else if (ACTION_DELETE_NOTIFICATION.equals(action)) {
               Log.i(getClass().getSimpleName(), "onReceive delete notification action, starting notification service to handle delete");
               serviceIntent = NotificationIntentService.createIntentDeleteNotification(context);
           }
   
           if (serviceIntent != null) {
               startWakefulService(context, serviceIntent);
           }
       }
   
       private static long getTriggerAt(Date now) {
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(now);
           //calendar.add(Calendar.HOUR, NOTIFICATIONS_INTERVAL_IN_HOURS);
           return calendar.getTimeInMillis();
       }
   
       private static PendingIntent getStartPendingIntent(Context context) {
           Intent intent = new Intent(context, NotificationEventReceiver.class);
           intent.setAction(ACTION_START_NOTIFICATION_SERVICE);
           return PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
       }
   
       public static PendingIntent getDeleteIntent(Context context) {
           Intent intent = new Intent(context, NotificationEventReceiver.class);
           intent.setAction(ACTION_DELETE_NOTIFICATION);
           return PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
       }
   }

3. Nun erstellen wir eine IntentService tatsächlich Benachrichtigungen erstellen.

   Gibt es, wir geben Sie onHandleIntent() die Antworten auf NotificationEventReceiver's Absicht passierten wir in startWakefulService Methode.

   Wenn es die Löschen-Aktion - wir melden es unserer Analysen, zum Beispiel. Wenn es zu Start-Meldung Absicht - dann mit NotificationCompat.Builder wir Komponieren neue Meldung und zeigt es durch NotificationManager.notify. Beim verfassen der Mitteilung, wir sind auch Einstellung pending intents für klicken Sie auf und entfernen von Aktionen. Ziemlich Einfach.

   NotificationIntentService.java

   public class NotificationIntentService extends IntentService {
   
       private static final int NOTIFICATION_ID = 1;
       private static final String ACTION_START = "ACTION_START";
       private static final String ACTION_DELETE = "ACTION_DELETE";
   
       public NotificationIntentService() {
           super(NotificationIntentService.class.getSimpleName());
       }
   
       public static Intent createIntentStartNotificationService(Context context) {
           Intent intent = new Intent(context, NotificationIntentService.class);
           intent.setAction(ACTION_START);
           return intent;
       }
   
       public static Intent createIntentDeleteNotification(Context context) {
           Intent intent = new Intent(context, NotificationIntentService.class);
           intent.setAction(ACTION_DELETE);
           return intent;
       }
   
       @Override
       protected void onHandleIntent(Intent intent) {
           Log.d(getClass().getSimpleName(), "onHandleIntent, started handling a notification event");
           try {
               String action = intent.getAction();
               if (ACTION_START.equals(action)) {
                   processStartNotification();
               }
               if (ACTION_DELETE.equals(action)) {
                   processDeleteNotification(intent);
               }
           } finally {
               WakefulBroadcastReceiver.completeWakefulIntent(intent);
           }
       }
   
       private void processDeleteNotification(Intent intent) {
           //Log something?
       }
   
       private void processStartNotification() {
           //Do something. For example, fetch fresh data from backend to create a rich notification?
   
           final NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
           builder.setContentTitle("Scheduled Notification")
                   .setAutoCancel(true)
                   .setColor(getResources().getColor(R.color.colorAccent))
                   .setContentText("This notification has been triggered by Notification Service")
                   .setSmallIcon(R.drawable.notification_icon);
   
           PendingIntent pendingIntent = PendingIntent.getActivity(this,
                   NOTIFICATION_ID,
                   new Intent(this, NotificationActivity.class),
                   PendingIntent.FLAG_UPDATE_CURRENT);
           builder.setContentIntent(pendingIntent);
           builder.setDeleteIntent(NotificationEventReceiver.getDeleteIntent(this));
   
           final NotificationManager manager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);
           manager.notify(NOTIFICATION_ID, builder.build());
       }
   }

4. Fast fertig. Jetzt Stell ich auch broadcast-receiver für BOOT_COMPLETED, TIMEZONE_CHANGED, und TIME_SET Ereignisse zu re-setup meine AlarmManager, einmal Gerät neu gestartet wurde oder die Zeitzone geändert hat (Zum Beispiel, Benutzer-geflogen aus den USA nach Europa und Sie nicht wollen, Benachrichtigung, pop-up, in der Mitte der Nacht, aber war klebrig, um die lokale Zeit 🙂 ).

   NotificationServiceStarterReceiver.java

   public final class NotificationServiceStarterReceiver extends BroadcastReceiver {
   
       @Override
       public void onReceive(Context context, Intent intent) {
           NotificationEventReceiver.setupAlarm(context);
       }
   }

5. Müssen wir auch registrieren, alle unsere services, broadcast Receiver in der AndroidManifest:

   <?xml version="1.0" encoding="utf-8"?>
   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="klogi.com.notificationbyschedule">
   
       <uses-permission android:name="android.permission.INTERNET" />
       <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
       <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
       <uses-permission android:name="android.permission.WAKE_LOCK" />
   
       <application
           android:allowBackup="true"
           android:icon="@mipmap/ic_launcher"
           android:label="@string/app_name"
           android:supportsRtl="true"
           android:theme="@style/AppTheme">
           <activity android:name=".MainActivity">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN" />
   
                   <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
           </activity>
   
           <service
               android:name=".notifications.NotificationIntentService"
               android:enabled="true"
               android:exported="false" />
   
           <receiver android:name=".broadcast_receivers.NotificationEventReceiver" />
           <receiver android:name=".broadcast_receivers.NotificationServiceStarterReceiver">
               <intent-filter>
                   <action android:name="android.intent.action.BOOT_COMPLETED" />
                   <action android:name="android.intent.action.TIMEZONE_CHANGED" />
                   <action android:name="android.intent.action.TIME_SET" />
               </intent-filter>
           </receiver>
   
           <activity
               android:name=".NotificationActivity"
               android:label="@string/title_activity_notification"
               android:theme="@style/AppTheme.NoActionBar"/>
       </application>
   
   </manifest>

Das ist es!

Den Quellcode für dieses Projekt finden Sie hier. Ich hoffe, Sie finden diesen Beitrag hilfreich.

InformationsquelleAutor der Antwort Konstantin Loginov