Existe-t-il un moyen Android natif pour obtenir une référence à l'activité en cours d'exécution à partir d'un service?

J'ai un service en cours d'exécution en arrière-plan et je souhaite mettre à jour mon activité actuelle lorsqu'un événement se produit (dans le service). Existe-t-il un moyen simple de le faire (comme celui que j'ai suggéré ci-dessus)?

Existe-t-il un moyen Android natif pour obtenir une référence à l'activité en cours d'exécution à partir d'un service?

Vous n'êtes peut-être pas propriétaire de «l'activité en cours d'exécution».

J'ai un service en cours d'exécution en arrière-plan et je souhaite mettre à jour mon activité actuelle lorsqu'un événement se produit (dans le service). Existe-t-il un moyen simple de le faire (comme celui que j'ai suggéré ci-dessus)?

1. Envoyez une diffusion Intentà l'activité - voici un exemple de projet illustrant ce modèle
2. Demandez à l'activité de fournir un PendingIntent(par exemple, via createPendingResult()) que le service appelle
3. Demandez à l'activité d'enregistrer un objet de rappel ou d'écoute avec le service via bindService(), et que le service appelle une méthode d'événement sur cet objet de rappel / d'écoute
4. Envoyez une diffusion ordonnée Intentà l'activité, avec une priorité faible BroadcastReceivercomme sauvegarde (pour augmenter une Notificationsi l'activité n'est pas à l'écran) - voici un article de blog avec plus d'informations sur ce modèle

Mise à jour : cela ne fonctionne plus avec les activités des autres applications à partir d'Android 5.0

Voici une bonne façon de le faire en utilisant le gestionnaire d'activités. Vous obtenez essentiellement les runningTasks du gestionnaire d'activités. Il retournera toujours la tâche actuellement active en premier. De là, vous pouvez obtenir le topActivity.

Exemple ici

Il existe un moyen simple d'obtenir une liste des tâches en cours d'exécution à partir du service ActivityManager. Vous pouvez demander un nombre maximum de tâches en cours d'exécution sur le téléphone et, par défaut, la tâche actuellement active est renvoyée en premier.

Une fois que vous avez cela, vous pouvez obtenir un objet ComponentName en demandant le topActivity de votre liste.

Voici un exemple.

    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();

Vous aurez besoin de l'autorisation suivante sur votre manifeste:

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

Avertissement: violation de Google Play

Google a menacé de supprimer des applications du Play Store si elles utilisent des services d'accessibilité à des fins non d'accessibilité. Cependant, cela serait en cours de réexamen .

Utilisez un AccessibilityService

• Vous pouvez détecter la fenêtre actuellement active en utilisant un fichier AccessibilityService.
• Dans le onAccessibilityEventrappel, vérifiez le type d'événement pour déterminer quand la fenêtre actuelle change.TYPE_WINDOW_STATE_CHANGED
• Vérifiez si la fenêtre est une activité en appelant PackageManager.getActivityInfo().

Avantages

• Testé et fonctionnant sous Android 2.2 (API 8) via Android 7.1 (API 25).
• Ne nécessite pas de sondage.
• Ne nécessite pas la GET_TASKSpermission.

Désavantages

• Chaque utilisateur doit activer le service dans les paramètres d'accessibilité d'Android.
• Ce n'est pas fiable à 100%. Parfois, les événements sont dans le désordre.
• Le service est toujours en cours d'exécution.
• Lorsqu'un utilisateur tente d'activer le AccessibilityService, il ne peut pas appuyer sur le bouton OK si une application a placé une superposition à l'écran. Certaines applications qui font cela sont Velis Auto Brightness et Lux. Cela peut être déroutant car l'utilisateur peut ne pas savoir pourquoi il ne peut pas appuyer sur le bouton ou comment le contourner.
• Ils AccessibilityServicene connaîtront pas l'activité en cours avant le premier changement d'activité.

Exemple

Un service

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

Fusionnez ceci dans votre manifeste:

<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>

Info service

Mettez ceci dans 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"/>

Activation du service

Chaque utilisateur de l'application devra activer explicitement le AccessibilityServicepour pouvoir l'utiliser. Consultez cette réponse StackOverflow pour savoir comment procéder.

Notez que l'utilisateur ne pourra pas appuyer sur le bouton OK lorsqu'il essaie d'activer le service d'accessibilité si une application a placé une superposition à l'écran, telle que Velis Auto Brightness ou Lux.

Cela peut être fait par:

1. Implémentez votre propre classe d'application, inscrivez-vous à ActivityLifecycleCallbacks - de cette façon, vous pouvez voir ce qui se passe avec notre application. À chaque reprise, le rappel attribue l'activité visible actuelle à l'écran et en pause, il supprime l'affectation. Il utilise une méthode registerActivityLifecycleCallbacks()qui a été ajoutée dans l'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. Dans votre appel de service getApplication()et cast dans le nom de votre classe d'application (App dans ce cas). Que vous pouvez appeler app.getActiveActivity()- cela vous donnera une activité visible actuelle (ou nulle lorsqu'aucune activité n'est visible). Vous pouvez obtenir le nom de l'activité en appelantactiveActivity.getClass().getSimpleName()

Je n'ai pas trouvé de solution qui plairait à notre équipe, alors nous avons lancé la nôtre. Nous utilisons ActivityLifecycleCallbackspour garder une trace de l'activité actuelle, puis l'exposer via un service:

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
            }
        });
    }
}

Configurez ensuite votre conteneur DI pour renvoyer l'instance de MyApplicationfor ContextProvider, par exemple

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

(Notez que l'implémentation de getCurrent()est omise du code ci-dessus. Il s'agit simplement d'une variable statique définie à partir du constructeur de l'application)

Utilisation ActivityManager

Si vous souhaitez uniquement connaître l' application contenant l'activité en cours, vous pouvez le faire en utilisant ActivityManager. La technique que vous pouvez utiliser dépend de la version d'Android:

• Pre-Lollipop: ActivityManager.getRunningTasks( exemple )
• Sucette: ActivityManager.getRunningAppProcesses( exemple )

Avantages

• Devrait fonctionner dans toutes les versions d'Android à ce jour.

Désavantages

• Ne fonctionne pas sous Android 5.1+ (il ne renvoie que votre propre application)
• La documentation de ces API indique qu'elles sont uniquement destinées au débogage et à la gestion des interfaces utilisateur.
• Si vous souhaitez des mises à jour en temps réel, vous devez utiliser l'interrogation.
• S'appuie sur une API cachée: ActivityManager.RunningAppProcessInfo.processState
• Cette implémentation ne détecte pas l'activité du sélecteur d'application.

Exemple (basé sur le code 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);
    }

}

Manifeste

Ajoutez l' GET_TASKSautorisation à AndroidManifest.xml:

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

J'utilise ceci pour mes tests. C'est API> 19, et uniquement pour les activités de votre application.

@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");
}

Utilisez ce code pour l'API 21 ou supérieur. Cela fonctionne et donne un meilleur résultat par rapport aux autres réponses, il détecte parfaitement le processus de premier plan.

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();
        }
    }

Voici ma réponse qui fonctionne très bien ...

Vous devriez pouvoir obtenir l'activité actuelle de cette manière ... Si vous structurez votre application avec quelques activités avec de nombreux fragments et que vous souhaitez garder une trace de votre activité actuelle, cela prendrait beaucoup de travail. Mon senario était que j'avais une activité avec plusieurs fragments. Ainsi, je peux garder une trace de l'activité actuelle via l'objet d'application, qui peut stocker tout l'état actuel des variables globales.

Voici un moyen. Lorsque vous démarrez votre activité, vous stockez cette activité par Application.setCurrentActivity (getIntent ()); Cette application le stockera. Sur votre classe de service, vous pouvez simplement faire comme Intent currentIntent = Application.getCurrentActivity (); getApplication (). startActivity (currentIntent);

Je ne sais pas si c'est une réponse stupide, mais j'ai résolu ce problème en stockant un drapeau dans les préférences partagées chaque fois que je suis entré dans onCreate () d'une activité, puis j'ai utilisé la valeur des préférences shered pour savoir en quoi consiste l'activité de premier plan.

Récemment découvert à ce sujet. Avec des API comme:

• minSdkVersion 19

• targetSdkVersion 26

  ActivityManager.getCurrentActivity (contexte)

J'espère que c'est utile.