Gibt es eine native Android-Methode, um von einem Dienst einen Verweis auf die aktuell ausgeführte Aktivität zu erhalten?

Ich habe einen Dienst im Hintergrund ausgeführt und möchte meine aktuelle Aktivität aktualisieren, wenn ein Ereignis auftritt (im Dienst). Gibt es eine einfache Möglichkeit, dies zu tun (wie die oben vorgeschlagene)?

Gibt es eine native Android-Methode, um von einem Dienst einen Verweis auf die aktuell ausgeführte Aktivität zu erhalten?

Möglicherweise besitzen Sie nicht die "aktuell ausgeführte Aktivität".

Ich habe einen Dienst im Hintergrund ausgeführt und möchte meine aktuelle Aktivität aktualisieren, wenn ein Ereignis auftritt (im Dienst). Gibt es eine einfache Möglichkeit, dies zu tun (wie die oben vorgeschlagene)?

1. Senden Sie eine Sendung Intentan die Aktivität - hier ist ein Beispielprojekt das dieses Muster demonstriert
2. Lassen Sie die Aktivität ein PendingIntent(z. B. viacreatePendingResult() ) angeben, das der Dienst aufruft
3. Lassen Sie die Aktivität ein Rückruf- oder Listener-Objekt über den Dienst registrieren bindService() und den Dienst eine Ereignismethode für dieses Rückruf- / Listenerobjekt aufrufen
4. Senden Sie eine bestellte Sendung Intentmit niedriger Priorität BroadcastReceiverals Backup an Notificationdie Aktivität (um eine zu aktivieren, wenn die Aktivität nicht auf dem Bildschirm angezeigt wird) - hier ist ein Blog-Beitrag mit weiteren Informationen zu diesem Muster

Update : Dies funktioniert ab Android 5.0 nicht mehr mit den Aktivitäten anderer Apps

Hier ist eine gute Möglichkeit, dies mit dem Aktivitätsmanager zu tun. Grundsätzlich erhalten Sie die runningTasks vom Aktivitätsmanager. Es wird immer zuerst die aktuell aktive Aufgabe zurückgegeben. Von dort können Sie die topActivity erhalten.

Beispiel hier

Es gibt eine einfache Möglichkeit, eine Liste der ausgeführten Aufgaben vom ActivityManager-Dienst abzurufen. Sie können eine maximale Anzahl von Aufgaben anfordern, die auf dem Telefon ausgeführt werden. Standardmäßig wird die aktuell aktive Aufgabe zuerst zurückgegeben.

Sobald Sie das haben, können Sie ein ComponentName-Objekt erhalten, indem Sie die topActivity von Ihrer Liste anfordern.

Hier ist ein Beispiel.

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

Sie benötigen die folgende Berechtigung für Ihr Manifest:

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

Warnung: Google Play-Verstoß

Google hat damit gedroht , Apps aus dem Play Store zu entfernen, wenn sie Barrierefreiheitsdienste für nicht barrierefreie Zwecke verwenden. Dies wird jedoch Berichten zufolge überdacht .

Benutze ein AccessibilityService

• Sie können das aktuell aktive Fenster mit einem erkennen AccessibilityService.
• onAccessibilityEventSuchen Sie im Rückruf nach dem Ereignistyp, um festzustellen, wann sich das aktuelle Fenster ändert.TYPE_WINDOW_STATE_CHANGED
• Überprüfen Sie durch Aufrufen, ob das Fenster eine Aktivität ist PackageManager.getActivityInfo().

Leistungen

• Getestet und funktioniert in Android 2.2 (API 8) bis Android 7.1 (API 25).
• Benötigt keine Abfrage.
• Benötigt keine GET_TASKSErlaubnis.

Nachteile

• Jeder Benutzer muss den Dienst in den Eingabehilfen von Android aktivieren.
• Dies ist nicht 100% zuverlässig. Gelegentlich sind die Ereignisse nicht in Ordnung.
• Der Dienst wird immer ausgeführt.
• Wenn ein Benutzer versucht, das zu aktivieren AccessibilityService, kann er die OK-Taste nicht drücken, wenn eine App eine Überlagerung auf dem Bildschirm platziert hat. Einige Apps, die dies tun, sind Velis Auto Brightness und Lux. Dies kann verwirrend sein, da der Benutzer möglicherweise nicht weiß, warum er die Taste nicht drücken kann oder wie er sie umgehen kann.
• Die AccessibilityServiceaktuelle Aktivität wird erst bei der ersten Änderung der Aktivität bekannt.

Beispiel

Bedienung

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

Füge dies in dein Manifest ein:

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

Serviceinfo

Geben Sie dies ein 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"/>

Aktivieren des Dienstes

Jeder Benutzer der App muss das explizit aktivieren AccessibilityService, damit es verwendet werden kann. Informationen dazu finden Sie in dieser StackOverflow-Antwort .

Beachten Sie, dass der Benutzer die OK-Taste nicht drücken kann, wenn er versucht, den Eingabehilfedienst zu aktivieren, wenn eine App eine Überlagerung auf dem Bildschirm platziert hat, z. B. Velis Auto Brightness oder Lux.

Dies kann geschehen durch:

1. Implementieren Sie Ihre eigene Anwendungsklasse, registrieren Sie sich für ActivityLifecycleCallbacks - auf diese Weise können Sie sehen, was mit unserer App los ist. Bei jedem erneuten Lebenslauf weist der Rückruf die aktuell sichtbare Aktivität auf dem Bildschirm zu und bei einer Pause wird die Zuordnung entfernt. Es verwendet eine Methode, registerActivityLifecycleCallbacks()die in API 14 hinzugefügt wurde.

   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. Rufen getApplication()Sie in Ihrem Service-Aufruf Ihren App-Klassennamen an (in diesem Fall App). Dann können Sie anrufen app.getActiveActivity()- das gibt Ihnen eine aktuell sichtbare Aktivität (oder null, wenn keine Aktivität sichtbar ist). Sie können den Namen der Aktivität erhalten, indem Sie anrufenactiveActivity.getClass().getSimpleName()

Ich konnte keine Lösung finden, mit der unser Team zufrieden wäre, also haben wir unsere eigene gerollt. Wir verwenden ActivityLifecycleCallbacks, um die aktuellen Aktivitäten zu verfolgen und sie dann über einen Dienst verfügbar zu machen:

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

Konfigurieren Sie dann Ihren DI-Container so, dass die Instanz von MyApplicationfor zurückgegeben wird ContextProvider, z

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

(Beachten Sie, dass die Implementierung getCurrent()von im obigen Code weggelassen wird. Es handelt sich nur um eine statische Variable, die vom Anwendungskonstruktor festgelegt wurde.)

Verwenden ActivityManager

Wenn Sie nur die Anwendung kennen möchten, die die aktuelle Aktivität enthält, können Sie dies mit verwenden ActivityManager. Welche Technik Sie verwenden können, hängt von der Version von Android ab:

• Pre-Lollipop: ActivityManager.getRunningTasks( Beispiel )
• Lutscher: ActivityManager.getRunningAppProcesses( Beispiel )

Leistungen

• Sollte bisher in allen Android-Versionen funktionieren.

Nachteile

• Funktioniert nicht in Android 5.1+ (es wird nur Ihre eigene App zurückgegeben)
• Die Dokumentation für diese APIs heißt es, dass sie nur zum Debuggen und Verwalten von Benutzeroberflächen vorgesehen sind.
• Wenn Sie Echtzeit-Updates wünschen, müssen Sie Polling verwenden.
• Verlässt sich auf eine versteckte API: ActivityManager.RunningAppProcessInfo.processState
• Diese Implementierung nimmt die App Switcher-Aktivität nicht auf.

Beispiel (basierend auf KNaitos Code )

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

}

Manifest

Fügen Sie die GET_TASKSBerechtigung hinzu zu AndroidManifest.xml:

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

Ich benutze dies für meine Tests. Es ist API> 19 und nur für Aktivitäten Ihrer App.

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

Verwenden Sie diesen Code für API 21 oder höher. Dies funktioniert und liefert im Vergleich zu den anderen Antworten ein besseres Ergebnis. Es erkennt den Vordergrundprozess perfekt.

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

Hier ist meine Antwort, die gut funktioniert ...

Sie sollten in der Lage sein, aktuelle Aktivitäten auf diese Weise abzurufen ... Wenn Sie Ihre App mit einigen Aktivitäten mit vielen Fragmenten strukturieren und verfolgen möchten, was Ihre aktuelle Aktivität ist, würde dies jedoch viel Arbeit erfordern. Mein Szenario war, dass ich eine Aktivität mit mehreren Fragmenten habe. So kann ich die aktuelle Aktivität über das Anwendungsobjekt verfolgen, in dem der gesamte aktuelle Status globaler Variablen gespeichert werden kann.

Hier ist ein Weg. Wenn Sie Ihre Aktivität starten, speichern Sie diese Aktivität nach Application.setCurrentActivity (getIntent ()). Diese Anwendung speichert es. In Ihrer Serviceklasse können Sie einfach Intent currentIntent = Application.getCurrentActivity () ausführen. getApplication (). startActivity (currentIntent);

Ich weiß nicht, ob es eine dumme Antwort ist, aber ich habe dieses Problem gelöst, indem ich jedes Mal, wenn ich onCreate () einer Aktivität eingegeben habe, ein Flag in freigegebenen Einstellungen gespeichert habe. Dann habe ich den Wert aus shered-Einstellungen verwendet, um herauszufinden, was die Vordergrundaktivität ist.

Erst kürzlich davon erfahren. Mit apis als:

• minSdkVersion 19

• targetSdkVersion 26

  ActivityManager.getCurrentActivity (Kontext)

Hoffe, das nützt nichts.