Czy istnieje natywny sposób na Androida, aby uzyskać odniesienie do aktualnie działającego działania z usługi?

Mam usługę działającą w tle i chciałbym zaktualizować moją bieżącą aktywność, gdy wystąpi zdarzenie (w usłudze). Czy jest na to łatwy sposób (taki jak ten, który zasugerowałem powyżej)?

Czy istnieje natywny sposób na Androida, aby uzyskać odniesienie do aktualnie działającego działania z usługi?

Możesz nie być właścicielem „aktualnie działającego działania”.

Mam usługę działającą w tle i chciałbym zaktualizować moją bieżącą aktywność, gdy wystąpi zdarzenie (w usłudze). Czy jest na to łatwy sposób (taki jak ten, który zasugerowałem powyżej)?

1. Wyślij transmisję Intentdo działania - oto przykładowy projekt demonstrujący ten wzór
2. Poproś, aby działanie dostarczyło PendingIntent(np. Przez createPendingResult()) wywołaną przez usługę
3. Niech aktywność zarejestruje obiekt zwrotny lub obiekt nasłuchujący w usłudze za pośrednictwem bindService() , a usługa wywołała metodę zdarzenia dla tego obiektu wywołania zwrotnego / obiektu nasłuchiwania
4. Wyślij zamówioną transmisję Intentdo działania, z niskim priorytetem BroadcastReceiverjako kopię zapasową (aby podnieść, Notificationjeśli aktywność nie jest wyświetlana na ekranie) - oto post na blogu z większą ilością tego wzoru

Aktualizacja : nie działa już w przypadku działań innych aplikacji od Androida 5.0

Oto dobry sposób na zrobienie tego za pomocą menedżera aktywności. Zasadniczo dostajesz runningTasks od menedżera aktywności. Zawsze najpierw zwróci aktualnie aktywne zadanie. Stamtąd możesz uzyskać najwyższą Aktywność.

Przykład tutaj

Istnieje prosty sposób na uzyskanie listy uruchomionych zadań z usługi ActivityManager. Możesz zażądać maksymalnej liczby zadań uruchomionych na telefonie, a domyślnie aktualnie aktywne zadanie jest zwracane jako pierwsze.

Gdy już to zrobisz, możesz uzyskać obiekt ComponentName, żądając topActivity z listy.

Oto przykład.

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

Będziesz potrzebować następującego pozwolenia na swój manifest:

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

Ostrzeżenie: naruszenie Google Play

Google zagroził usunięciem aplikacji ze Sklepu Play, jeśli będą korzystać z usług ułatwień dostępu w celach niedostępności. Jednakże, jest to podobno ponownie rozpatrzona .

Użyj AccessibilityService

• Możesz wykryć aktualnie aktywne okno, używając AccessibilityService.
• W onAccessibilityEventwywołaniu zwrotnym sprawdź typ zdarzenia, aby określić, kiedy zmienia się bieżące okno.TYPE_WINDOW_STATE_CHANGED
• Sprawdź, czy okno jest działaniem, dzwoniąc PackageManager.getActivityInfo().

Korzyści

• Testowane i działające w systemie Android 2.2 (API 8) poprzez Android 7.1 (API 25).
• Nie wymaga odpytywania.
• Nie wymaga GET_TASKSpozwolenia.

Niedogodności

• Każdy użytkownik musi włączyć usługę w ustawieniach ułatwień dostępu Androida.
• To nie jest w 100% niezawodne. Czasami wydarzenia są nieczynne.
• Usługa jest zawsze uruchomiona.
• Gdy użytkownik próbuje włączyć opcję AccessibilityService, nie może nacisnąć przycisku OK, jeśli aplikacja umieściła nakładkę na ekranie. Niektóre aplikacje, które to robią, to Velis Auto Brightness i Lux. Może to być mylące, ponieważ użytkownik może nie wiedzieć, dlaczego nie może nacisnąć przycisku ani jak go obejść.
• AccessibilityServiceNie będą wiedzieć, bieżącej działalności, aż do pierwszej zmiany aktywności.

Przykład

Usługa

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

Połącz to ze swoim manifestem:

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

Informacje serwisowe

Umieść to w 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"/>

Włączanie usługi

Każdy użytkownik aplikacji będzie musiał wyraźnie włączyć opcję, AccessibilityServiceaby można było z niej korzystać. Zobacz odpowiedź StackOverflow, jak to zrobić.

Pamiętaj, że użytkownik nie będzie mógł nacisnąć przycisku OK podczas próby włączenia usługi ułatwień dostępu, jeśli aplikacja umieściła na ekranie nakładkę, taką jak Velis Auto Brightness lub Lux.

Można to zrobić przez:

1. Zaimplementuj własną klasę aplikacji, zarejestruj się w ActivityLifecycleCallbacks - w ten sposób zobaczysz, co się dzieje z naszą aplikacją. Przy każdym wznowieniu oddzwonienie przypisuje bieżącą widoczną aktywność na ekranie, a po wstrzymaniu usuwa przypisanie. Wykorzystuje metodę registerActivityLifecycleCallbacks()dodaną w 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. W zgłoszeniu serwisowym getApplication()i rzuć go na nazwę klasy aplikacji (w tym przypadku App). Niż możesz zadzwonić app.getActiveActivity()- to da ci bieżącą widoczną Aktywność (lub zero, gdy żadna aktywność nie jest widoczna). Nazwę działania można uzyskać, dzwoniącactiveActivity.getClass().getSimpleName()

Nie mogłem znaleźć rozwiązania, z którego nasz zespół byłby zadowolony, więc wprowadziliśmy własne. Używamy ActivityLifecycleCallbacksdo śledzenia bieżącej aktywności, a następnie ujawniamy ją za pośrednictwem usługi:

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

Następnie skonfiguruj kontener DI, aby zwracał instancję MyApplicationdla ContextProvidernp

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

(Zauważ, że implementacja getCurrent()jest pominięta w powyższym kodzie. Jest to po prostu zmienna statyczna ustawiona w konstruktorze aplikacji)

Posługiwać się ActivityManager

Jeśli chcesz tylko znać aplikację zawierającą bieżącą aktywność, możesz to zrobić za pomocą ActivityManager. Technika, której możesz użyć, zależy od wersji Androida:

• Pre-Lollipop: ActivityManager.getRunningTasks( przykład )
• Lollipop: ActivityManager.getRunningAppProcesses( przykład )

Korzyści

• Powinien działać we wszystkich dotychczasowych wersjach Androida.

Niedogodności

• Nie działa w systemie Android 5.1+ (zwraca tylko własną aplikację)
• Dokumentacja tych interfejsów API mówi, że są one przeznaczone wyłącznie do debugowania i zarządzania interfejsami użytkownika.
• Jeśli chcesz otrzymywać aktualizacje w czasie rzeczywistym, musisz użyć odpytywania.
• Opiera się na ukrytym interfejsie API: ActivityManager.RunningAppProcessInfo.processState
• Ta implementacja nie rejestruje aktywności przełącznika aplikacji.

Przykład (na podstawie kodu 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);
    }

}

Oczywisty

Dodaj GET_TASKSuprawnienie do AndroidManifest.xml:

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

Używam tego do moich testów. Jest to API> 19, ale tylko dla działań Twojej aplikacji.

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

Użyj tego kodu dla API 21 lub nowszego. Działa to i daje lepszy wynik w porównaniu do innych odpowiedzi, doskonale wykrywa proces pierwszego planu.

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

Oto moja odpowiedź, która działa dobrze ...

Powinieneś być w stanie uzyskać bieżącą Aktywność w ten sposób ... Jeśli zbudujesz aplikację z kilkoma Aktywnościami z wieloma fragmentami i chcesz śledzić, jaka jest twoja Aktywność, zajmie to jednak dużo pracy. Moim senario było to, że mam jedną Aktywność z wieloma Fragmentami. Mogę więc śledzić bieżącą aktywność za pośrednictwem obiektu aplikacji, który może przechowywać cały bieżący stan zmiennych globalnych.

Oto sposób. Kiedy zaczynasz swoją aktywność, przechowujesz ją przez Application.setCurrentActivity (getIntent ()); Ta aplikacja będzie go przechowywać. W klasie usług możesz po prostu zrobić jak Intent currentIntent = Application.getCurrentActivity (); getApplication (). startActivity (currentIntent);

Nie wiem, czy to głupia odpowiedź, ale rozwiązałem ten problem, przechowując flagę we wspólnych preferencjach za każdym razem, gdy wpisywałem funkcję onCreate () dowolnej aktywności, a następnie wykorzystałem wartość z preferencji ścinania, aby dowiedzieć się, co to jest aktywność na pierwszym planie.

Niedawno się o tym dowiedziałem. Z apis jako:

• minSdkVersion 19

• targetSdkVersion 26

  ActivityManager.getCurrentActivity (kontekst)

Mam nadzieję, że to się przyda.