Więc nie jestem pewien, gdzie / jak zaimplementować tę metodę, aby moja usługa działała na pierwszym planie. Obecnie rozpoczynam swoją służbę w innej działalności:

Intent i = new Intent(context, myService.class); 
context.startService(i);

A potem w metodzie onCreate () myServices próbuję uruchomić metodę startForeground () ...?

Notification notification = new Notification();
startForeground(1, notification);

Więc tak, jestem trochę zagubiony i nie jestem pewien, jak to zaimplementować.

Zacząłbym od całkowitego wypełnienia pliku Notification. Oto przykładowy projekt demonstrujący użycie startForeground().

Z głównej aktywności uruchom usługę następującym kodem:

Intent i = new Intent(context, MyService.class); 
context.startService(i);

Następnie w swojej usłudze onCreate()utworzyłbyś swoje powiadomienie i ustawił je jako pierwszy plan w następujący sposób:

Intent notificationIntent = new Intent(this, MainActivity.class);

PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
                notificationIntent, 0);

Notification notification = new NotificationCompat.Builder(this)
                .setSmallIcon(R.mipmap.app_icon)
                .setContentTitle("My Awesome App")
                .setContentText("Doing some work...")
                .setContentIntent(pendingIntent).build();

startForeground(1337, notification);

To jest mój kod, aby ustawić usługę na pierwszym planie:

private void runAsForeground(){
    Intent notificationIntent = new Intent(this, RecorderMainActivity.class);
    PendingIntent pendingIntent=PendingIntent.getActivity(this, 0,
            notificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK);

    Notification notification=new NotificationCompat.Builder(this)
                                .setSmallIcon(R.drawable.ic_launcher)
                                .setContentText(getString(R.string.isRecording))
                                .setContentIntent(pendingIntent).build();

    startForeground(NOTIFICATION_ID, notification);

}

Muszę zbudować powiadomienie przy użyciu PendingIntent, aby móc rozpocząć moją główną aktywność od powiadomienia.

Aby usunąć powiadomienie, po prostu wywołaj stopForeground (true);

Jest wywoływana w onStartCommand (). Proszę zapoznać się z moim kodem na: https://github.com/bearstand/greyparrot/blob/master/src/com/xiong/richard/greyparrot/Mp3Recorder.java

Rozwiązanie dla Oreo 8.1

Napotkałem pewne problemy, takie jak RemoteServiceException z powodu nieprawidłowego identyfikatora kanału w najnowszych wersjach Androida. Oto jak to rozwiązałem:

Aktywność :

override fun onCreate(savedInstanceState: Bundle?) {
    val intent = Intent(this, BackgroundService::class.java)

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        startForegroundService(intent)
    } else {
        startService(intent)
    }
}

TłoUsługa:

override fun onCreate() {
    super.onCreate()
    startForeground()
}

private fun startForeground() {

    val service = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    val channelId =
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                createNotificationChannel()
            } else {
                // If earlier version channel ID is not used
                // https://developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html#NotificationCompat.Builder(android.content.Context)
                ""
            }

    val notificationBuilder = NotificationCompat.Builder(this, channelId )
    val notification = notificationBuilder.setOngoing(true)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setPriority(PRIORITY_MIN)
            .setCategory(Notification.CATEGORY_SERVICE)
            .build()
    startForeground(101, notification)
}


@RequiresApi(Build.VERSION_CODES.O)
private fun createNotificationChannel(): String{
    val channelId = "my_service"
    val channelName = "My Background Service"
    val chan = NotificationChannel(channelId,
            channelName, NotificationManager.IMPORTANCE_HIGH)
    chan.lightColor = Color.BLUE
    chan.importance = NotificationManager.IMPORTANCE_NONE
    chan.lockscreenVisibility = Notification.VISIBILITY_PRIVATE
    val service = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    service.createNotificationChannel(chan)
    return channelId
}

ODPOWIEDNIK JAVA

public class YourService extends Service {

    // Constants
    private static final int ID_SERVICE = 101;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);
        return START_STICKY;
    }

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

        // do stuff like register for BroadcastReceiver, etc.

        // Create the Foreground Service
        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        String channelId = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O ? createNotificationChannel(notificationManager) : "";
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, channelId);
        Notification notification = notificationBuilder.setOngoing(true)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setPriority(PRIORITY_MIN)
                .setCategory(NotificationCompat.CATEGORY_SERVICE)
                .build();

        startForeground(ID_SERVICE, notification);
    }

    @RequiresApi(Build.VERSION_CODES.O)
    private String createNotificationChannel(NotificationManager notificationManager){
        String channelId = "my_service_channelid";
        String channelName = "My Foreground Service";
        NotificationChannel channel = new NotificationChannel(channelId, channelName, NotificationManager.IMPORTANCE_HIGH);
        // omitted the LED color
        channel.setImportance(NotificationManager.IMPORTANCE_NONE);
        channel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);
        notificationManager.createNotificationChannel(channel);
        return channelId;
    }
}

Oprócz odpowiedzi RAWA , ten spokój kodu:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    startForegroundService(intent)
} else {
    startService(intent)
}

Możesz zmienić na:

ContextCompat.startForegroundService(context, yourIntent);

Jeśli zajrzysz do tej metody, zobaczysz, że ta metoda wykonuje całą pracę sprawdzającą.

Jeśli chcesz, aby IntentService była usługą pierwszoplanową

wtedy powinieneś zastąpić onHandleIntent()to w ten sposób

Override
protected void onHandleIntent(@Nullable Intent intent) {


    startForeground(FOREGROUND_ID,getNotification());     //<-- Makes Foreground

   // Do something

    stopForeground(true);                                // <-- Makes it again a normal Service                         

}

Jak dokonać zgłoszenia?

prosty. Oto getNotification()metoda

public Notification getNotification()
{

    Intent intent = new Intent(this, SecondActivity.class);
    PendingIntent pendingIntent = PendingIntent.getActivity(this,0,intent,0);


    NotificationCompat.Builder foregroundNotification = new NotificationCompat.Builder(this);
    foregroundNotification.setOngoing(true);

    foregroundNotification.setContentTitle("MY Foreground Notification")
            .setContentText("This is the first foreground notification Peace")
            .setSmallIcon(android.R.drawable.ic_btn_speak_now)
            .setContentIntent(pendingIntent);


    return foregroundNotification.build();
}

Głębsze zrozumienie

Co się dzieje, gdy usługa staje się usługą pierwszoplanową

To się stało

Co to jest usługa pierwszoplanowa?

Usługa pierwszoplanowa,

• zapewnia, że ​​użytkownik jest aktywnie świadomy tego, że coś dzieje się w tle, dostarczając powiadomienie.

• (co najważniejsze) nie jest zabijany przez System, gdy zaczyna brakować pamięci

Przypadek użycia usługi pierwszego planu

Wdrażanie funkcji pobierania utworów w aplikacji muzycznej

Dodaj podany kod Service class dla "OS> = Build.VERSION_CODES.O" w onCreate ()

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

     .................................
     .................................

    //For creating the Foreground Service
    NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    String channelId = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O ? getNotificationChannel(notificationManager) : "";
    NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, channelId);
    Notification notification = notificationBuilder.setOngoing(true)
            .setSmallIcon(R.mipmap.ic_launcher)
           // .setPriority(PRIORITY_MIN)
            .setCategory(NotificationCompat.CATEGORY_SERVICE)
            .build();

    startForeground(110, notification);
}



@RequiresApi(Build.VERSION_CODES.O)
private String getNotificationChannel(NotificationManager notificationManager){
    String channelId = "channelid";
    String channelName = getResources().getString(R.string.app_name);
    NotificationChannel channel = new NotificationChannel(channelId, channelName, NotificationManager.IMPORTANCE_HIGH);
    channel.setImportance(NotificationManager.IMPORTANCE_NONE);
    channel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);
    notificationManager.createNotificationChannel(channel);
    return channelId;
}

Dodaj to uprawnienie w pliku manifestu:

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

Obsługa zamiaru startCommand of service przy użyciu.

 stopForeground(true)

To wywołanie usunie usługę ze stanu pierwszego planu , umożliwiając jej zabicie, jeśli potrzeba więcej pamięci. Nie zatrzymuje to działania usługi . W tym celu musisz wywołać stopSelf () lub powiązane metody.

Przekazywanie wartości true lub false wskazuje, czy chcesz usunąć powiadomienie, czy nie.

val ACTION_STOP_SERVICE = "stop_service"
val NOTIFICATION_ID_SERVICE = 1
...  
override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
    super.onStartCommand(intent, flags, startId)
    if (ACTION_STOP_SERVICE == intent.action) {
        stopForeground(true)
        stopSelf()
    } else {
        //Start your task

        //Send forground notification that a service will run in background.
        sendServiceNotification(this)
    }
    return Service.START_NOT_STICKY
}

Obsługuj swoje zadanie, gdy funkcja niszczenia jest wywoływana przez stopSelf () .

override fun onDestroy() {
    super.onDestroy()
    //Stop whatever you started
}

Utwórz powiadomienie, aby usługa działała na pierwszym planie.

//This is from Util class so as not to cloud your service
fun sendServiceNotification(myService: Service) {
    val notificationTitle = "Service running"
    val notificationContent = "<My app> is using <service name> "
    val actionButtonText = "Stop"
    //Check android version and create channel for Android O and above
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        //You can do this on your own
        //createNotificationChannel(CHANNEL_ID_SERVICE)
    }
    //Build notification
    val notificationBuilder = NotificationCompat.Builder(applicationContext, CHANNEL_ID_SERVICE)
    notificationBuilder.setAutoCancel(true)
            .setDefaults(NotificationCompat.DEFAULT_ALL)
            .setWhen(System.currentTimeMillis())
            .setSmallIcon(R.drawable.ic_location)
            .setContentTitle(notificationTitle)
            .setContentText(notificationContent)
            .setVibrate(null)
    //Add stop button on notification
    val pStopSelf = createStopButtonIntent(myService)
    notificationBuilder.addAction(R.drawable.ic_location, actionButtonText, pStopSelf)
    //Build notification
    val notificationManagerCompact = NotificationManagerCompat.from(applicationContext)
    notificationManagerCompact.notify(NOTIFICATION_ID_SERVICE, notificationBuilder.build())
    val notification = notificationBuilder.build()
    //Start notification in foreground to let user know which service is running.
    myService.startForeground(NOTIFICATION_ID_SERVICE, notification)
    //Send notification
    notificationManagerCompact.notify(NOTIFICATION_ID_SERVICE, notification)
}

Daj przycisk zatrzymania w powiadomieniu, aby zatrzymać usługę, gdy użytkownik tego potrzebuje.

/**
 * Function to create stop button intent to stop the service.
 */
private fun createStopButtonIntent(myService: Service): PendingIntent? {
    val stopSelf = Intent(applicationContext, MyService::class.java)
    stopSelf.action = ACTION_STOP_SERVICE
    return PendingIntent.getService(myService, 0,
            stopSelf, PendingIntent.FLAG_CANCEL_CURRENT)
}

Uwaga: jeśli aplikacja jest przeznaczona dla interfejsu API na poziomie 26 lub wyższym, system nakłada ograniczenia na używanie lub tworzenie usług w tle, chyba że sama aplikacja znajduje się na pierwszym planie.

Jeśli aplikacja musi utworzyć usługę pierwszego planu, powinna wywołać aplikację startForegroundService(). Ta metoda tworzy usługę w tle, ale metoda sygnalizuje systemowi, że usługa będzie promować się na pierwszy plan.

Po utworzeniu usługi usługa musi wywołać jej startForeground() method within five seconds.

W moim przypadku było zupełnie inaczej, ponieważ nie miałem żadnej aktywności, aby uruchomić usługę w Oreo.

Poniżej znajdują się kroki, które wykonałem, aby rozwiązać ten problem z usługą pierwszego planu -

public class SocketService extends Service {
    private String TAG = this.getClass().getSimpleName();

    @Override
    public void onCreate() {
        Log.d(TAG, "Inside onCreate() API");
        if (Build.VERSION.SDK_INT >= 26) {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this);
            mBuilder.setSmallIcon(R.drawable.ic_launcher);
            mBuilder.setContentTitle("Notification Alert, Click Me!");
            mBuilder.setContentText("Hi, This is Android Notification Detail!");
            NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

            // notificationID allows you to update the notification later on.
            mNotificationManager.notify(100, mBuilder.build());
            startForeground(100, mBuilder.mNotification);
        }
        Toast.makeText(getApplicationContext(), "inside onCreate()", Toast.LENGTH_LONG).show();
    }


    @Override
    public int onStartCommand(Intent resultIntent, int resultCode, int startId) {
        Log.d(TAG, "inside onStartCommand() API");

        return startId;
    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "inside onDestroy() API");

    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return null;
    }
}

A potem, aby zainicjować tę usługę, uruchomiłem poniżej cmd -

adb -s "+ serial_id +" shell am startforegroundservice -n com.test.socket.sample / .SocketService

Więc to pomaga mi rozpocząć obsługę bez aktywności na urządzeniach Oreo :)

Rozwiązanie @mikebertiean prawie załatwiło sprawę, ale miałem ten problem z dodatkowym skrętem - używam systemu Gingerbread i nie chciałem dodawać dodatkowego pakietu tylko po to, aby uruchomić powiadomienie. Wreszcie znalazłem: https://android.googlesource.com/platform/frameworks/support.git+/f9fd97499795cd47473f0344e00db9c9837eea36/v4/gingerbread/android/support/v4/app/NotificationCompatGingerbread.java

potem trafiam na dodatkowy problem - powiadomienie po prostu zabija moją aplikację po jej uruchomieniu (jak rozwiązać ten problem: Android: Jak uniknąć kliknięcia Powiadomienia wywołuje onCreate () ), więc w sumie mój kod w usłudze wygląda tak (C # / Xamarin):

Intent notificationIntent = new Intent(this, typeof(MainActivity));
// make the changes to manifest as well
notificationIntent.SetFlags(ActivityFlags.ClearTop | ActivityFlags.SingleTop);
PendingIntent pendingIntent = PendingIntent.GetActivity(this, 0, notificationIntent, 0);
Notification notification = new Notification(Resource.Drawable.Icon, "Starting service");
notification.SetLatestEventInfo(this, "MyApp", "Monitoring...", pendingIntent);
StartForeground(1337, notification);