Voglio creare un servizio e farlo funzionare in primo piano.

La maggior parte dei codici di esempio contiene notifiche. Ma non voglio mostrare alcuna notifica. È possibile?

Puoi farmi qualche esempio? Esistono alternative?

Il mio servizio app sta facendo mediaplayer. Come fare in modo che il sistema non interrompa il mio servizio tranne l'app che lo uccide da solo (come mettere in pausa o interrompere la musica con il pulsante).

Come caratteristica di sicurezza della piattaforma Android, non puoi , in nessuna circostanza, avere un servizio in primo piano senza avere anche una notifica. Questo perché un servizio in primo piano consuma una quantità maggiore di risorse ed è soggetto a diversi vincoli di pianificazione (cioè, non viene interrotto così rapidamente) rispetto ai servizi in background e l'utente deve sapere cosa potrebbe consumare la batteria. Quindi, non farlo.

Tuttavia, è possibile avere una notifica "falsa", ovvero è possibile creare un'icona di notifica trasparente (iirc). Questo è estremamente falso per i tuoi utenti e non hai motivo di farlo, a parte uccidere la loro batteria e creare così malware.

Aggiornamento: questo è stato "risolto" su Android 7.1. https://code.google.com/p/android/issues/detail?id=213309

Dall'aggiornamento 4.3, è praticamente impossibile avviare un servizio startForeground()senza mostrare una notifica.

Puoi, tuttavia, nascondere l'icona utilizzando le API ufficiali ... non è necessaria un'icona trasparente: (utilizzare NotificationCompatper supportare le versioni precedenti)

NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
builder.setPriority(Notification.PRIORITY_MIN);

Ho fatto pace con il fatto che la notifica stessa deve ancora essere lì, ma per chi vuole ancora nasconderla, potrei aver trovato una soluzione anche per questo:

1. Avvia un servizio falso startForeground()con la notifica e tutto il resto.
2. Avvia il servizio reale che desideri eseguire, anche con startForeground()(stesso ID notifica)
3. Arresta il primo servizio (falso) (puoi chiamare stopSelf()e in onDestroy chiamare stopForeground(true)).

Ecco! Nessuna notifica e il tuo secondo servizio continua a funzionare.

Non funziona più a partire da Android 7.1 e potrebbe violare le norme per gli sviluppatori di Google Play .

Chiedi invece all'utente di bloccare la notifica del servizio .

Ecco la mia implementazione della tecnica nella risposta di Lior Iluz .

Codice

ForegroundService.java

public class ForegroundService extends Service {

    static ForegroundService instance;

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

        instance = this;

        if (startService(new Intent(this, ForegroundEnablingService.class)) == null)
            throw new RuntimeException("Couldn't find " + ForegroundEnablingService.class.getSimpleName());
    }

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

        instance = null;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

ForegroundEnablingService.java

public class ForegroundEnablingService extends Service {

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (ForegroundService.instance == null)
            throw new RuntimeException(ForegroundService.class.getSimpleName() + " not running");

        //Set both services to foreground using the same notification id, resulting in just one notification
        startForeground(ForegroundService.instance);
        startForeground(this);

        //Cancel this service's notification, resulting in zero notifications
        stopForeground(true);

        //Stop this service so we don't waste RAM.
        //Must only be called *after* doing the work or the notification won't be hidden.
        stopSelf();

        return START_NOT_STICKY;
    }

    private static final int NOTIFICATION_ID = 10;

    private static void startForeground(Service service) {
        Notification notification = new Notification.Builder(service).getNotification();
        service.startForeground(NOTIFICATION_ID, notification);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

AndroidManifest.xml

<service android:name=".ForegroundEnablingService" />
<service android:name=".ForegroundService" />

Compatibilità

Testato e funzionante su:

• Emulatore ufficiale
  • 4.0.2
  • 4.1.2
  • 4.2.2
  • 4.3.1
  • 4.4.2
  • 5.0.2
  • 5.1.1
  • 6.0
  • 7.0
• Sony Xperia M
  • 4.1.2
  • 4.3
• Samsung Galaxy ?
  • 4.4.2
  • 5.X
• Genmony
  • 5.0
  • 6.0
• CyanogenMod
  • 5.1.1

Non funziona più a partire da Android 7.1.

Puoi usarlo (come suggerito da @Kristopher Micinski):

Notification note = new Notification( 0, null, System.currentTimeMillis() );
note.flags |= Notification.FLAG_NO_CLEAR;
startForeground( 42, note );

AGGIORNARE:

Tieni presente che questo non è più consentito con le versioni di Android KitKat +. E tieni presente che ciò viola più o meno il principio di progettazione in Android che rende le operazioni in background visibili agli utenti come menzionato da @Kristopher Micinski

Attenzione : sebbene questa risposta sembri funzionare, di fatto impedisce silenziosamente al tuo servizio di diventare un servizio in primo piano .

Risposta originale:

Basta impostare l'ID della notifica su zero:

// field for notification ID
private static final int NOTIF_ID = 0;

    ...
    startForeground(NOTIF_ID, mBuilder.build());
    NotificationManager mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    mNotificationManager.cancel(NOTIF_ID);
    ...

Un vantaggio che puoi ottenere è Serviceche sarai in grado di funzionare con priorità alta senza essere distrutto dal sistema Android, a meno che non sia sotto pressione della memoria.

MODIFICARE

Per farlo funzionare con Pre-Honeycomb e Android 4.4 e versioni successive, assicurati di utilizzare quello NotificationCompat.Builderfornito da Support Library v7, invece di Notification.Builder.

Puoi nascondere la notifica su Android 9+ utilizzando il layout personalizzato con layout_height = "0dp"

NotificationCompat.Builder builder = new NotificationCompat.Builder(context, NotificationUtils.CHANNEL_ID);
RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.custom_notif);
builder.setContent(remoteViews);
builder.setPriority(NotificationCompat.PRIORITY_LOW);
builder.setVisibility(Notification.VISIBILITY_SECRET);

custom_notif.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="0dp">
</LinearLayout>

Testato su Pixel 1, Android 9. Questa soluzione non funziona su Android 8 o meno

Aggiornamento: non funziona più in Android 4.3 e versioni successive

C'è una soluzione alternativa. Prova a creare una notifica senza impostare l'icona e la notifica non verrà visualizzata. Non so come funziona, ma funziona :)

    Notification notification = new NotificationCompat.Builder(this)
            .setContentTitle("Title")
            .setTicker("Title")
            .setContentText("App running")
            //.setSmallIcon(R.drawable.picture)
            .build();
    startForeground(101,  notification);

Aggiornamento: non funziona più in Android 4.3 e versioni successive

Ho impostato il parametro icon sul costruttore per Notification su zero, quindi ho passato la notifica risultante a startForeground (). Nessun errore nel registro e nessuna notifica viene visualizzata. Non so, però, se il servizio sia stato messo in primo piano con successo: esiste un modo per verificarlo?

Modificato: verificato con dumpsys, e in effetti il ​​servizio è in primo piano sul mio sistema 2.3. Non ho ancora verificato con altre versioni del sistema operativo.

Blocca la notifica del servizio in primo piano

La maggior parte delle risposte qui o non funziona, interrompe il servizio in primo piano o viola le norme di Google Play .

L'unico modo per nascondere in modo affidabile e sicuro la notifica è farla bloccare dall'utente.

Android 4.1 - 7.1

L'unico modo è bloccare tutte le notifiche dalla tua app:

1. Invia l'utente alla schermata dei dettagli dell'app:

   Uri uri = Uri.fromParts("package", getPackageName(), null);
   Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).setData(uri);
   startActivity(intent);
   

2. Avere notifiche dell'app per il blocco degli utenti

Nota che questo blocca anche i toast della tua app.

Android 8.0 - 8.1

Non vale la pena bloccare la notifica su Android O perché il sistema operativo lo sostituirà semplicemente con un "in esecuzione in background " o " utilizzando la batteria notifica ".

Android 9+

Utilizza un canale di notifica per bloccare la notifica del servizio senza influire sulle altre notifiche.

1. Assegna la notifica di servizio al canale di notifica

2. Invia l'utente alle impostazioni del canale di notifica

   Intent intent = new Intent(Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS)
       .putExtra(Settings.EXTRA_APP_PACKAGE, getPackageName())
       .putExtra(Settings.EXTRA_CHANNEL_ID, myNotificationChannel.getId());
   startActivity(intent);
   

3. Fai in modo che l'utente blocchi le notifiche del canale

versione 4.3 (18) e successive non è possibile nascondere la notifica del servizio, ma è possibile disabilitare l'icona, versione 4.3 (18) e successive è possibile nascondere la notifica

Notification noti = new Notification();
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.JELLY_BEAN) {
    noti.priority = Notification.PRIORITY_MIN;
}
startForeground(R.string.app_name, noti);

Ho scoperto che su Android 8.0 è ancora possibile non utilizzare un canale di notifica.

public class BootCompletedIntentReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if ("android.intent.action.BOOT_COMPLETED".equals(intent.getAction())) {

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

                Intent notificationIntent = new Intent(context, BluetoothService.class);    
                context.startForegroundService(notificationIntent);

            } else {
                //...
            }

        }
    }
}

E in BluetoothService.class:

 @Override
    public void onCreate(){    
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

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

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

            Notification notification = new Notification.Builder(this)
                    .setContentTitle("Title")
                    .setContentText("App is running")
                    .setSmallIcon(R.drawable.notif)
                    .setContentIntent(pendingIntent)
                    .setTicker("Title")
                    .setPriority(Notification.PRIORITY_DEFAULT)
                    .build();

            startForeground(15, notification);

        }

    }

Non viene visualizzata una notifica persistente, tuttavia vedrai la notifica "x app Android in esecuzione in background".

Aggiornamento: non funziona più su Android 7.1 e versioni successive

Ecco un modo per impostare oom_adj della tua app su 1 (testato nell'emulatore SDK ANDROID 6.0) Aggiungi un servizio temporaneo, nella chiamata di servizio principale startForgroundService(NOTIFICATION_ID, notificion). Quindi avvia di nuovo la chiamata di servizio temporanea startForgroundService(NOTIFICATION_ID, notificion)con lo stesso ID di notifica, dopo un po 'nella chiamata di servizio temporanea stopForgroundService (true) per ignorare l'ontificazione in corso.

Puoi anche dichiarare la tua applicazione come persistente.

<application
    android:icon="@drawable/icon"
    android:label="@string/app_name"
    android:theme="@style/Theme"
    *android:persistent="true"* >
</application>

Questo essenzialmente imposta la tua app su una priorità di memoria più alta, diminuendo la probabilità che venga uccisa.

Ho sviluppato un semplice lettore multimediale un paio di mesi fa. Quindi quello che credo è se stai facendo qualcosa del tipo:

Intent i = new Intent(this, someServiceclass.class);

startService (i);

Quindi il sistema non dovrebbe essere in grado di terminare il tuo servizio.

riferimento : leggere il paragrafo che discute quando il sistema interrompe il servizio