¿Existe una forma nativa de Android para obtener una referencia a la Actividad actualmente en ejecución desde un servicio?

Tengo un servicio ejecutándose en segundo plano, y me gustaría actualizar mi Actividad actual cuando ocurra un evento (en el servicio). ¿Hay una manera fácil de hacer eso (como la que sugerí anteriormente)?

¿Existe una forma nativa de Android para obtener una referencia a la Actividad actualmente en ejecución desde un servicio?

No puede ser el propietario de la "Actividad actualmente en ejecución".

Tengo un servicio ejecutándose en segundo plano, y me gustaría actualizar mi Actividad actual cuando ocurra un evento (en el servicio). ¿Hay una manera fácil de hacer eso (como la que sugerí anteriormente)?

1. Enviar una transmisión Intenta la actividad: aquí hay un proyecto de muestra que demuestra este patrón
2. Haga que la actividad proporcione un PendingIntent(por ejemplo, vía createPendingResult()) que el servicio invoca
3. Haga que la actividad registre una devolución de llamada u objeto de escucha con el servicio a través bindService(), y haga que el servicio llame a un método de evento en ese objeto de devolución de llamada / escucha
4. Envíe una transmisión ordenada Intenta la actividad, con una prioridad baja BroadcastReceivercomo respaldo (para generar un mensajeNotification si la actividad no está en la pantalla): aquí hay una publicación de blog con más información sobre este patrón

Actualización : esto ya no funciona con las actividades de otras aplicaciones a partir de Android 5.0

Aquí hay una buena manera de hacerlo usando el administrador de actividades. Básicamente obtienes las RunningTasks del administrador de actividades. Siempre devolverá primero la tarea actualmente activa. Desde allí puede obtener la actividad superior.

Ejemplo aquí

Hay una manera fácil de obtener una lista de tareas en ejecución del servicio ActivityManager. Puede solicitar un número máximo de tareas que se ejecutan en el teléfono y, de manera predeterminada, la tarea activa actual se devuelve primero.

Una vez que tenga eso, puede obtener un objeto ComponentName solicitando topActivity de su lista.

Aquí hay un ejemplo.

    ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
    List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1);
    Log.d("topActivity", "CURRENT Activity ::" + taskInfo.get(0).topActivity.getClassName());
    ComponentName componentInfo = taskInfo.get(0).topActivity;
    componentInfo.getPackageName();

Necesitará el siguiente permiso en su manifiesto:

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

Advertencia: violación de Google Play

Google ha amenazado con eliminar aplicaciones de Play Store si usan servicios de accesibilidad para fines de no accesibilidad. Sin embargo, se informa que esto se está reconsiderando .

Usar un AccessibilityService

• Puede detectar la ventana activa actualmente usando un AccessibilityService.
• En el onAccessibilityEvent devolución de llamada, verifique el tipo de evento para determinar cuándo cambia la ventana actual.TYPE_WINDOW_STATE_CHANGED
• Compruebe si la ventana es una actividad llamando PackageManager.getActivityInfo().

Beneficios

• Probado y funcionando en Android 2.2 (API 8) a través de Android 7.1 (API 25).
• No requiere sondeo.
• No requiere el GET_TASKS permiso.

Desventajas

• Cada usuario debe habilitar el servicio en la configuración de accesibilidad de Android.
• Esto no es 100% confiable. Ocasionalmente los eventos están fuera de servicio.
• El servicio siempre se está ejecutando.
• Cuando un usuario intenta habilitar AccessibilityService, no puede presionar el botón Aceptar si una aplicación ha colocado una superposición en la pantalla. Algunas aplicaciones que hacen esto son Velis Auto Brightness y Lux. Esto puede ser confuso porque el usuario puede no saber por qué no puede presionar el botón o cómo solucionarlo.
• El AccessibilityServiceno sabrá la actividad actual hasta el primer cambio de actividad.

Ejemplo

Servicio

public class WindowChangeDetectingService extends AccessibilityService {

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

        //Configure these here for compatibility with API 13 and below.
        AccessibilityServiceInfo config = new AccessibilityServiceInfo();
        config.eventTypes = AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED;
        config.feedbackType = AccessibilityServiceInfo.FEEDBACK_GENERIC;

        if (Build.VERSION.SDK_INT >= 16)
            //Just in case this helps
            config.flags = AccessibilityServiceInfo.FLAG_INCLUDE_NOT_IMPORTANT_VIEWS;

        setServiceInfo(config);
    }

    @Override
    public void onAccessibilityEvent(AccessibilityEvent event) {
        if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
            if (event.getPackageName() != null && event.getClassName() != null) {
                ComponentName componentName = new ComponentName(
                    event.getPackageName().toString(),
                    event.getClassName().toString()
                );

                ActivityInfo activityInfo = tryGetActivity(componentName);
                boolean isActivity = activityInfo != null;
                if (isActivity)
                    Log.i("CurrentActivity", componentName.flattenToShortString());
            }
        }
    }

    private ActivityInfo tryGetActivity(ComponentName componentName) {
        try {
            return getPackageManager().getActivityInfo(componentName, 0);
        } catch (PackageManager.NameNotFoundException e) {
            return null;
        }
    }

    @Override
    public void onInterrupt() {}
}

AndroidManifest.xml

Combina esto en tu manifiesto:

<application>
    <service
        android:label="@string/accessibility_service_name"
        android:name=".WindowChangeDetectingService"
        android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
        <intent-filter>
            <action android:name="android.accessibilityservice.AccessibilityService"/>
        </intent-filter>
        <meta-data
            android:name="android.accessibilityservice"
            android:resource="@xml/accessibilityservice"/>
    </service>
</application>

Información de servicio

Pon esto en res/xml/accessibilityservice.xml:

<?xml version="1.0" encoding="utf-8"?>
<!-- These options MUST be specified here in order for the events to be received on first
 start in Android 4.1.1 -->
<accessibility-service
    xmlns:tools="http://schemas.android.com/tools"
    android:accessibilityEventTypes="typeWindowStateChanged"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:accessibilityFlags="flagIncludeNotImportantViews"
    android:description="@string/accessibility_service_description"
    xmlns:android="http://schemas.android.com/apk/res/android"
    tools:ignore="UnusedAttribute"/>

Habilitar el servicio

Cada usuario de la aplicación deberá habilitar explícitamente el AccessibilityServicepara que pueda ser utilizado. Ver esta respuesta de StackOverflow para cómo hacer esto.

Tenga en cuenta que el usuario no podrá presionar el botón Aceptar cuando intente habilitar el servicio de accesibilidad si una aplicación ha colocado una superposición en la pantalla, como Velis Auto Brightness o Lux.

Se puede hacer por:

1. Implemente su propia clase de aplicación, regístrese en ActivityLifecycleCallbacks, de esta manera puede ver lo que está sucediendo con nuestra aplicación. En cada reanudación, la devolución de llamada asigna la actividad visible actual en la pantalla y, en pausa, elimina la asignación. Utiliza el método registerActivityLifecycleCallbacks()que se agregó en API 14.

   public class App extends Application {
   
   private Activity activeActivity;
   
   @Override
   public void onCreate() {
       super.onCreate();
       setupActivityListener();
   }
   
   private void setupActivityListener() {
   registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
           @Override
           public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
           }
           @Override
           public void onActivityStarted(Activity activity) {
           }
           @Override
           public void onActivityResumed(Activity activity) {
               activeActivity = activity;
           }
           @Override
           public void onActivityPaused(Activity activity) {
               activeActivity = null;
           }
           @Override
           public void onActivityStopped(Activity activity) {
           }
           @Override
           public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
           }
           @Override
           public void onActivityDestroyed(Activity activity) {
           }
       });
   }
   
   public Activity getActiveActivity(){
       return activeActivity;
   }
   
   }

2. En su llamada de servicio getApplication()y transmítala al nombre de la clase de su aplicación (Aplicación en este caso). De lo que puede llamar app.getActiveActivity(), eso le dará una Actividad visible actual (o nula cuando no hay actividad visible). Puede obtener el nombre de la Actividad llamandoactiveActivity.getClass().getSimpleName()

No pude encontrar una solución con la que nuestro equipo estaría contento, así que desarrollamos la nuestra. Usamos ActivityLifecycleCallbackspara hacer un seguimiento de la actividad actual y luego exponerla a través de un servicio:

public interface ContextProvider {
    Context getActivityContext();
}

public class MyApplication extends Application implements ContextProvider {
    private Activity currentActivity;

    @Override
    public Context getActivityContext() {
         return currentActivity;
    }

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

        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                MyApplication.this.currentActivity = activity;
            }

            @Override
            public void onActivityStarted(Activity activity) {
                MyApplication.this.currentActivity = activity;
            }

            @Override
            public void onActivityResumed(Activity activity) {
                MyApplication.this.currentActivity = activity;
            }

            @Override
            public void onActivityPaused(Activity activity) {
                MyApplication.this.currentActivity = null;
            }

            @Override
            public void onActivityStopped(Activity activity) {
                // don't clear current activity because activity may get stopped after
                // the new activity is resumed
            }

            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

            }

            @Override
            public void onActivityDestroyed(Activity activity) {
                // don't clear current activity because activity may get destroyed after
                // the new activity is resumed
            }
        });
    }
}

Luego configure su contenedor DI para devolver la instancia de MyApplicationfor ContextProvider, eg

public class ApplicationModule extends AbstractModule {    
    @Provides
    ContextProvider provideMainActivity() {
        return MyApplication.getCurrent();
    }
}

(Tenga en cuenta que la implementación de getCurrent()se omite del código anterior. Es solo una variable estática que se establece desde el constructor de la aplicación)

Utilizar ActivityManager

Si solo desea conocer la aplicación que contiene la actividad actual, puede hacerlo utilizando ActivityManager. La técnica que puede usar depende de la versión de Android:

• Pre-Lollipop: ActivityManager.getRunningTasks( ejemplo )
• Piruleta: ActivityManager.getRunningAppProcesses( ejemplo )

Beneficios

• Debería funcionar en todas las versiones de Android hasta la fecha.

Desventajas

• No funciona en Android 5.1+ (solo devuelve tu propia aplicación)
• La documentación para estas API dice que solo están destinadas a la depuración y administración de interfaces de usuario.
• Si desea actualizaciones en tiempo real, debe usar el sondeo.
• Se basa en una API oculta: ActivityManager.RunningAppProcessInfo.processState
• Esta implementación no recoge la actividad de cambio de aplicación.

Ejemplo (basado en el código de KNaito )

public class CurrentApplicationPackageRetriever {

    private final Context context;

    public CurrentApplicationPackageRetriever(Context context) {
        this.context = context;
    }

    public String get() {
        if (Build.VERSION.SDK_INT < 21)
            return getPreLollipop();
        else
            return getLollipop();
    }

    private String getPreLollipop() {
        @SuppressWarnings("deprecation")
        List<ActivityManager.RunningTaskInfo> tasks =
            activityManager().getRunningTasks(1);
        ActivityManager.RunningTaskInfo currentTask = tasks.get(0);
        ComponentName currentActivity = currentTask.topActivity;
        return currentActivity.getPackageName();
    }

    private String getLollipop() {
        final int PROCESS_STATE_TOP = 2;

        try {
            Field processStateField = ActivityManager.RunningAppProcessInfo.class.getDeclaredField("processState");

            List<ActivityManager.RunningAppProcessInfo> processes =
                activityManager().getRunningAppProcesses();
            for (ActivityManager.RunningAppProcessInfo process : processes) {
                if (
                    // Filters out most non-activity processes
                    process.importance <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
                    &&
                    // Filters out processes that are just being
                    // _used_ by the process with the activity
                    process.importanceReasonCode == 0
                ) {
                    int state = processStateField.getInt(process);

                    if (state == PROCESS_STATE_TOP) {
                        String[] processNameParts = process.processName.split(":");
                        String packageName = processNameParts[0];

                        /*
                         If multiple candidate processes can get here,
                         it's most likely that apps are being switched.
                         The first one provided by the OS seems to be
                         the one being switched to, so we stop here.
                         */
                        return packageName;
                    }
                }
            }
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }

        return null;
    }

    private ActivityManager activityManager() {
        return (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    }

}

Manifiesto

Agregue el GET_TASKSpermiso a AndroidManifest.xml:

<!--suppress DeprecatedClassUsageInspection -->
<uses-permission android:name="android.permission.GET_TASKS" />

Estoy usando esto para mis pruebas. Sin embargo, es API> 19, y solo para actividades de su aplicación.

@TargetApi(Build.VERSION_CODES.KITKAT)
public static Activity getRunningActivity() {
    try {
        Class activityThreadClass = Class.forName("android.app.ActivityThread");
        Object activityThread = activityThreadClass.getMethod("currentActivityThread")
                .invoke(null);
        Field activitiesField = activityThreadClass.getDeclaredField("mActivities");
        activitiesField.setAccessible(true);
        ArrayMap activities = (ArrayMap) activitiesField.get(activityThread);
        for (Object activityRecord : activities.values()) {
            Class activityRecordClass = activityRecord.getClass();
            Field pausedField = activityRecordClass.getDeclaredField("paused");
            pausedField.setAccessible(true);
            if (!pausedField.getBoolean(activityRecord)) {
                Field activityField = activityRecordClass.getDeclaredField("activity");
                activityField.setAccessible(true);
                return (Activity) activityField.get(activityRecord);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    throw new RuntimeException("Didn't find the running activity");
}

Use este código para API 21 o superior. Esto funciona y ofrece mejores resultados en comparación con las otras respuestas, detecta perfectamente el proceso en primer plano.

if (Build.VERSION.SDK_INT >= 21) {
    String currentApp = null;
    UsageStatsManager usm = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
    long time = System.currentTimeMillis();
    List<UsageStats> applist = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time - 1000 * 1000, time);
    if (applist != null && applist.size() > 0) {
        SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
        for (UsageStats usageStats : applist) {
            mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);

        }
        if (mySortedMap != null && !mySortedMap.isEmpty()) {
            currentApp = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
        }
    }

Aquí está mi respuesta que funciona bien ...

Debería poder obtener la Actividad actual de esta manera ... Si estructura su aplicación con algunas Actividades con muchos fragmentos y desea realizar un seguimiento de cuál es su Actividad actual, requeriría mucho trabajo. Mi senario fue que tengo una actividad con múltiples fragmentos. Por lo tanto, puedo realizar un seguimiento de la actividad actual a través del objeto de aplicación, que puede almacenar todo el estado actual de las variables globales.

Aquí hay un camino. Cuando inicia su Actividad, almacena esa Actividad por Application.setCurrentActivity (getIntent ()); Esta aplicación lo almacenará. En su clase de servicio, simplemente puede hacer como Intent currentIntent = Application.getCurrentActivity (); getApplication (). startActivity (currentIntent);

No sé si es una respuesta estúpida, pero resolví este problema almacenando una marca en las preferencias compartidas cada vez que ingresé en Crear () de cualquier actividad, luego utilicé el valor de las preferencias compartidas para descubrir cuál es la actividad en primer plano.

Recientemente me enteré de esto. Con apis como:

• minSdkVersion 19

• targetSdkVersion 26

  ActivityManager.getCurrentActivity (contexto)

Espero que esto sea de alguna utilidad.