Using Service to Run Background and Create Notification

Creating a service to run in the background and create notifications

I recently had this problem and I solved mine using a broadcast receiver.

While the WakefulBroadcastReceiver has been deprecated, it's parent class has not been deprecated.

Intent intent = new Intent(context, ClassReminderReceiver.class);

  PendingIntent pendingIntent = PendingIntent.getBroadcast(
     context, 1, intent, PendingIntent.FLAG_UPDATE_CURRENT);
  AlarmManager alarmManager = (AlarmManager) 
     context.getSystemService(Context.ALARM_SERVICE);
  alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, calSet.getTimeInMillis(), 
        AlarmManager.INTERVAL_DAY, pendingIntent);

I am using the Alarm manager setRepeating() and RTC_WAKEUP see Appropriate alarm type guide for appropriate alarm type

also, see the link below to see best practices on alarms.
Best practices on alarms

You need to declare your broadcast receiver in your manifest

<receiver
        android:name=".ClassReminderReceiver"
        android:enabled="true"
        android:exported="true" />

This is the Broadcast receiver class

 public class ClassReminderReceiver extends BroadcastReceiver {
     @Override
     public void onReceive(Context context, Intent intent) {
      ClassReminderNotification.notify(context);
     }
  }

You said you want to create a notification, but as @Chuong Le Van mentioned I can't see where you define a notification in your code.

Below is the ClassNotification class

class ClassReminderNotification {

static void notify(Context context) {
    createNotificationChannel(context);
    // Create an explicit intent for an Activity in your app
    Intent intent = new Intent(context, YourActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, 0);

    NotificationCompat.Builder builder = new NotificationCompat.Builder(context, 
          "class_reminder")
            .setSmallIcon(R.drawable.ic_school_black_24dp)
            .setContentTitle("Your Notification Title")
            .setContentText("Your Text")
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            // Set the intent that will fire when the user taps the notification
            .setContentIntent(pendingIntent)
            .setAutoCancel(true);

    NotificationManagerCompat notificationManager = 
    NotificationManagerCompat.from(context);

    // notificationId is a unique int for each notification that you must define
    int notificationId = 1;
    notificationManager.notify(notificationId, builder.build());

}

private static void createNotificationChannel(Context context) {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is new and not in the support library
    String CHANNEL_ID = "class_reminder";
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        CharSequence name = context.getString(R.string.channel_name);
        String description = context.getString(R.string.channel_description);
        int importance = NotificationManager.IMPORTANCE_DEFAULT;
        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, 
          importance);
        channel.setDescription(description);
        // Register the channel with the system; you can't change the importance
        // or other notification behaviors after this
        NotificationManager notificationManager = 
           context.getSystemService(NotificationManager.class);
        notificationManager.createNotificationChannel(channel);
        }
    }
}

Here is google's guide Notification overviewNotifications Overview

Here is also the official guide for building a notification Official guide on how to create a notification.

I hope this helps.

Show notification by an Android app through service running in background checking server (volley) even when the app is closed

Android has newer and better solution which perfectly suits your need

The WorkManager API is a suitable and recommended replacement for all previous Android background scheduling APIs

you can check official topics here : work manager

Call a notification listener inside a background service in android studio

So what I did wrong is that I tried to create 2 services. Instead I only needed one.
Here is the code that works. What it simply does is starting the bacgrkound service and counts the notifications.When you click report it shows all the notifications, even if the user has close the app. I have put extra code for making a notification after 5 notifications.

MainActivity.java
package com.example.notifyservice;

import android.app.NotificationManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.support.v4.app.NotificationCompat;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends AppCompatActivity {

/*
    protected final Timer myTimer = new Timer("MainActivityTimer", false);
*/

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // FIRST OF ALL
        // START SERVICE AS STICKY - BY EXPLICIT INTENT
        // to prevent being started by the system (without the sticky flag)
        Intent intent = new Intent(getApplicationContext(), NLService.class);

        // TODO: to be removed
        intent.putExtra("id", 101);
        intent.putExtra("msg", "hi");

        //starting service

        startService(intent);

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Intent i = new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS");
        startActivity(i);
        //setting button click
        findViewById(R.id.btn_start_service).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                // Ask service (async) for its status (manually after the main activity was paused or closed and missed some NLService's broadcasts)
                // the background service is sticky and the counters(added/removed) are not reset.

                //Creating an intent for sending to service
                //Intent intent = new Intent(getApplicationContext(), MyService.class);
                Intent intent = new Intent(getApplicationContext(), NLService.class);
                intent.putExtra("command", "get_status");
                //starting service
                startService(intent);

            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();

        // register broadcast receiver for the intent MyTaskStatus
        LocalBroadcastManager.getInstance(this).registerReceiver(MyReceiver, new IntentFilter(NLService.ACTION_STATUS_BROADCAST));

    }

    //Defining broadcast receiver
    private BroadcastReceiver MyReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i("MainActivity", "Broadcast Recieved: "+intent.getStringExtra("serviceMessage"));
            String message = intent.getStringExtra("serviceMessage");
            Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT).show();
        }
    };

    @Override
    protected void onStop() {
        super.onStop();

        LocalBroadcastManager.getInstance(this).unregisterReceiver(MyReceiver);
    }

}

NLService.java

package com.example.notifyservice;

import android.app.IntentService;
import android.app.NotificationManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import android.service.notification.NotificationListenerService;
import android.service.notification.StatusBarNotification;
import android.support.annotation.RequiresApi;
import android.support.v4.app.NotificationCompat;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;

// @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
public class NLService extends NotificationListenerService {

    public static final String ACTION_STATUS_BROADCAST = "com.example.notifyservice.NLService_Status";

    private String TAG = this.getClass().getSimpleName();
    private NLServiceReceiver nlservicereciver;

    /**
     * The number of notifications added (since the service started)
     */
    private int nAdded=0;
    /**
     * The number of notifications removed (since the service started)
     */
    private int nRemoved=0;
    int temp = 5;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //retrieving data from the received intent
        if(intent.hasExtra("command")) {
            Log.i("NLService", "Started for command '"+intent.getStringExtra("command"));
            broadcastStatus();
        } else if(intent.hasExtra("id")) {
            int id = intent.getIntExtra("id", 0);
            String message = intent.getStringExtra("msg");
            Log.i("NLService", "Requested to start explicitly - id : " + id + " message : " + message);
        }
        super.onStartCommand(intent, flags, startId);

        // NOTE: We return STICKY to prevent the automatic service termination
        return START_STICKY;
    }

    private void broadcastStatus() {
        Log.i("NLService", "Broadcasting status added("+nAdded+")/removed("+nRemoved+")");
        Intent i1 = new  Intent(ACTION_STATUS_BROADCAST);
        i1.putExtra("serviceMessage","Added: "+nAdded+" | Removed: "+nRemoved);
        LocalBroadcastManager.getInstance(this).sendBroadcast(i1);
        // sendBroadcast(i1);

    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("NLService", "NLService created!");
        nlservicereciver = new NLServiceReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction("com.example.notifyservice.NOTIFICATION_LISTENER_SERVICE_EXAMPLE");
        registerReceiver(nlservicereciver,filter);
        Log.i("NLService", "NLService created!");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        unregisterReceiver(nlservicereciver);
        Log.i("NLService", "NLService destroyed!");
    }

    /* > API 21
    @Override
    public void onListenerDisconnected() {
        super.onListenerDisconnected();
        Log.w("NLService", "Notification listener DISCONNECTED from the notification service! Scheduling a reconnect...");
        // requestRebind(new ComponentName(this.getPackageName(), this.getClass().getCanonicalName()));
    }

    @Override
    public void onListenerConnected() {
        super.onListenerConnected();
        Log.w("NLService", "Notification listener connected with the notification service!");
    }
    */

    @Override
    public void onNotificationPosted(StatusBarNotification sbn) {

        Log.i(TAG,"**********  onNotificationPosted");
        Log.i(TAG,"ID :" + sbn.getId() + "t" + sbn.getNotification().tickerText + "\t" + sbn.getPackageName());
        Intent i = new  Intent("com.example.notify.NOTIFICATION_LISTENER_EXAMPLE");
        i.putExtra("notification_event","onNotificationPosted :" + sbn.getPackageName() + "\n");
        sendBroadcast(i);

        nAdded++;

        if (nAdded == temp) {
            System.out.println("reached" + temp);
            temp = temp + 5;
            System.out.println(temp);
            NotificationManager nManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
            NotificationCompat.Builder ncomp = new NotificationCompat.Builder(this);
            ncomp.setContentTitle("Notification");
            ncomp.setContentText("Notification Listener Service Example");
            ncomp.setTicker("Notification Listener Service Example");
            ncomp.setSmallIcon(R.mipmap.ic_launcher);
            ncomp.setAutoCancel(true);
            nManager.notify((int)System.currentTimeMillis(),ncomp.build());
        }
        broadcastStatus();
    }

    @Override
    public void onNotificationRemoved(StatusBarNotification sbn) {
        Log.i(TAG,"********** onNOtificationRemoved");
        Log.i(TAG,"ID :" + sbn.getId() + "t" + sbn.getNotification().tickerText +"\t" + sbn.getPackageName());
        Intent i = new  Intent("com.example.notify.NOTIFICATION_LISTENER_EXAMPLE");
        i.putExtra("notification_event","onNotificationRemoved :" + sbn.getPackageName() + "\n");

        sendBroadcast(i);

        nRemoved++;
        broadcastStatus();
    }

    class NLServiceReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {

            if(intent.getStringExtra("command").equals("list")){
                Intent i1 = new  Intent("com.example.notify.NOTIFICATION_LISTENER_EXAMPLE");
                i1.putExtra("notification_event","=====================");
                sendBroadcast(i1);
                int i=1;
                for (StatusBarNotification sbn : NLService.this.getActiveNotifications()) {
                    Intent i2 = new  Intent("com.example.notify.NOTIFICATION_LISTENER_EXAMPLE");
                    i2.putExtra("notification_event",i +" " + sbn.getPackageName() + "\n");
                    sendBroadcast(i2);
                    i++;
                }
                Intent i3 = new  Intent("com.example.notify.NOTIFICATION_LISTENER_EXAMPLE");
                i3.putExtra("notification_event","===== Notification List ====");
                sendBroadcast(i3);

            }

        }
    }

}

---

Related Topics