Android: servicio de inicio en el momento del arranque

Necesito iniciar un servicio en el momento del arranque. Busqué mucho. Están hablando de Broadcastreceiver. Como soy nuevo en el desarrollo de Android, no obtuve una imagen clara sobre los servicios en Android. Proporcione algún código fuente.

Cree un BroadcastReceivery regístrelo para recibir ACTION_BOOT_COMPLETED . También necesita el permiso RECEIVE_BOOT_COMPLETED .

Leer: Escuchar y transmitir mensajes globales y configurar alarmas

Su receptor:

public class MyReceiver extends BroadcastReceiver {   

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

     Intent myIntent = new Intent(context, YourService.class);
     context.startService(myIntent);

    }
}

Su AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.broadcast.receiver.example"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true">

        <activity android:name=".BR_Example"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    <!-- Declaring broadcast receiver for BOOT_COMPLETED event. -->
        <receiver android:name=".MyReceiver" android:enabled="true" android:exported="false">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED"/>
            </intent-filter>
        </receiver>

    </application>

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

</manifest>

Es posible registrar su propio servicio de aplicaciones para que se inicie automáticamente cuando se haya iniciado el dispositivo. Necesita esto, por ejemplo, cuando desea recibir eventos push de un servidor http y desea informar al usuario tan pronto como ocurra un nuevo evento. El usuario no tiene que iniciar la actividad manualmente antes de que se inicie el servicio ...

Es muy sencillo. Primero dé a su aplicación el permiso RECEIVE_BOOT_COMPLETED. A continuación, debe registrar un BroadcastReveiver. Lo llamamos BootCompletedIntentReceiver.

Su Manifest.xml ahora debería verse así:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="com.jjoe64">
 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
 <application>
  <receiver android:name=".BootCompletedIntentReceiver">
   <intent-filter>
    <action android:name="android.intent.action.BOOT_COMPLETED" />
   </intent-filter>
  </receiver>
  <service android:name=".BackgroundService"/>
 </application>
</manifest>

Como último paso, debe implementar el receptor. Este receptor acaba de iniciar su servicio en segundo plano.

package com.jjoe64;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;

import com.jjoe64.BackgroundService;

public class BootCompletedIntentReceiver extends BroadcastReceiver {
 @Override
 public void onReceive(Context context, Intent intent) {
  if ("android.intent.action.BOOT_COMPLETED".equals(intent.getAction())) {
   Intent pushIntent = new Intent(context, BackgroundService.class);
   context.startService(pushIntent);
  }
 }
}

De http://www.jjoe64.com/2011/06/autostart-service-on-device-boot.html

A la mayoría de las soluciones publicadas aquí les falta una pieza importante: hacerlo sin un bloqueo de activación corre el riesgo de que su Servicio se elimine antes de que termine de procesarse. Vi esta solución en otro hilo, respondiendo aquí también.

Dado que WakefulBroadcastReceiver está obsoleto en api 26, se recomienda para niveles de API inferiores a 26

Necesita obtener un bloqueo de activación. Afortunadamente, la biblioteca de soporte nos da una clase para hacer esto:

public class SimpleWakefulReceiver extends WakefulBroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        // This is the Intent to deliver to our service.
        Intent service = new Intent(context, SimpleWakefulService.class);

        // Start the service, keeping the device awake while it is launching.
        Log.i("SimpleWakefulReceiver", "Starting service @ " + SystemClock.elapsedRealtime());
        startWakefulService(context, service);
    }
}

luego, en su Servicio, asegúrese de liberar el bloqueo de activación:

    @Override
    protected void onHandleIntent(Intent intent) {
        // At this point SimpleWakefulReceiver is still holding a wake lock
        // for us.  We can do whatever we need to here and then tell it that
        // it can release the wakelock.

...
        Log.i("SimpleWakefulReceiver", "Completed service @ " + SystemClock.elapsedRealtime());
        SimpleWakefulReceiver.completeWakefulIntent(intent);
    }

No olvide agregar el permiso WAKE_LOCK y registrar su receptor en el manifiesto:

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

...

<service android:name=".SimpleWakefulReceiver">
    <intent-filter>
        <action android:name="com.example.SimpleWakefulReceiver"/>
    </intent-filter>
</service>

debe registrarse para BOOT_COMPLETE y REBOOT

<receiver android:name=".Services.BootComplete">
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED"/>
            <action android:name="android.intent.action.REBOOT"/>
        </intent-filter>
    </receiver> 

También registre su servicio creado en el Manifiesto y use-permiso como

<application ...>
   <service android:name=".MyBroadcastReceiver">
        <intent-filter>
            <action android:name="com.example.MyBroadcastReciver"/>
        </intent-filter>
   </service>
</application>
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

y luego en braod cast Reciever llama a tu servicio

public class MyBroadcastReceiver extends BroadcastReceiver 
{
    @Override
    public void onReceive(Context context, Intent intent)
    {
        Intent myIntent = new Intent(context, MyService.class);
        context.startService(myIntent);
    }
}

Primero registre un receptor en su archivo manifest.xml:

    <receiver android:name="com.mileagelog.service.Broadcast_PowerUp" >
        <intent-filter>
            <action android:name="android.intent.action.ACTION_POWER_CONNECTED" />
            <action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
        </intent-filter>
    </receiver>

y luego escribe una transmisión para este receptor como:

public class Broadcast_PowerUp extends BroadcastReceiver {

  @Override
  public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();

    if (action.equals(Intent.ACTION_POWER_CONNECTED)) {
        Toast.makeText(context, "Service_PowerUp Started",
                Toast.LENGTH_LONG).show();


    } else if (action.equals(Intent.ACTION_POWER_DISCONNECTED)) {



        Toast.makeText(context, "Service_PowerUp Stoped", Toast.LENGTH_LONG)
        .show();
    }
  }
}

Para reiniciar el servicio en Android Oo más, es decir, SO> 28 Use este código VERSIÓN KOTLIN 1) Agregue permiso en el manifiesto

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

2) Cree un Classy extiéndalo conBroadcastReceiver

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.os.Build
import android.util.Log
import androidx.core.content.ContextCompat



class BootCompletedReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, arg1: Intent?) {
        Log.d("BootCompletedReceiver", "starting service...")
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            ContextCompat.startForegroundService(context, Intent(context, YourServiceClass::class.java))
        } else {
            context.startService(Intent(context, YourServiceClass::class.java))
        }
    }
}

3) Declare en un archivo de manifiesto como este en la etiqueta de la aplicación

<receiver android:name=".utils.BootCompletedReceiver" >
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
            <action android:name="android.intent.action.QUICKBOOT_POWERON" />
        </intent-filter>
    </receiver>

Por favor, consulte JobScheduler para saber si hay apis superiores a 26

WakeLock fue la mejor opción para esto, pero está en desuso en el nivel de API 26. Por favor, consulte este enlace si considera niveles de API superiores a 26
https://developer.android.com/reference/android/support/v4/content/WakefulBroadcastReceiver.html# startWakefulService (android.content.Context,% 20android.content.Intent)

Dice

A partir de Android O, las restricciones de verificación de antecedentes hacen que esta clase ya no sea útil en general. (Por lo general, no es seguro iniciar un servicio desde la recepción de una transmisión, porque no tiene ninguna garantía de que su aplicación esté en primer plano en este punto y, por lo tanto, se le permita hacerlo). En su lugar, los desarrolladores deben usar Android. app.job.JobScheduler para programar un trabajo, y esto no requiere que la aplicación mantenga un bloqueo de activación mientras lo hace (el sistema se encargará de mantener un bloqueo de activación para el trabajo).

así que como dice cosider JobScheduler
https://developer.android.com/reference/android/app/job/JobScheduler

si es para hacer algo que para empezar y quedárselo puedes recibir la retransmisión ACTION_BOOT_COMPLETED

Si no se trata de primer plano, compruebe si un servicio de accesibilidad podría funcionar

otra opción es iniciar una actividad desde el receptor de transmisión y finalizarla después de iniciar el servicio dentro de onCreate (), ya que las versiones más nuevas de Android no permiten iniciar servicios desde receptores