Existe uma maneira nativa do Android de obter uma referência à atividade atualmente em execução de um serviço?

Eu tenho um serviço em execução em segundo plano e gostaria de atualizar minha Atividade atual quando ocorrer um evento (no serviço). Existe uma maneira fácil de fazer isso (como o que sugeri acima)?

Existe uma maneira nativa do Android de obter uma referência à atividade atualmente em execução de um serviço?

Você não pode ser o proprietário da "Atividade em execução no momento".

Eu tenho um serviço em execução em segundo plano e gostaria de atualizar minha Atividade atual quando ocorrer um evento (no serviço). Existe uma maneira fácil de fazer isso (como o que sugeri acima)?

1. Envie uma transmissão Intentpara a atividade - aqui está um projeto de amostra demonstrando esse padrão
2. Faça com que a atividade forneça um PendingIntent(por exemplo, via createPendingResult()) que o serviço chama
3. Faça com que a atividade registre um objeto de retorno de chamada ou ouvinte no serviço via bindService()e faça com que o serviço chame um método de evento nesse objeto de retorno de chamada / ouvinte
4. Envie uma transmissão ordenada Intentpara a atividade, com uma prioridade baixa BroadcastReceivercomo backup (para aumentar Notificationse a atividade não estiver na tela) - aqui está uma postagem de blog com mais informações sobre esse padrão

Atualização : isso não funciona mais com as atividades de outros aplicativos a partir do Android 5.0

Aqui está uma boa maneira de fazer isso usando o gerenciador de atividades. Você basicamente recebe as tarefas em execução do gerenciador de atividades. Ele sempre retornará a tarefa atualmente ativa primeiro. De lá, você pode obter a topActivity.

Exemplo aqui

Existe uma maneira fácil de obter uma lista de tarefas em execução no serviço ActivityManager. Você pode solicitar um número máximo de tarefas em execução no telefone e, por padrão, a tarefa atualmente ativa é retornada primeiro.

Depois de conseguir, você pode obter um objeto ComponentName solicitando o topActivity da sua lista.

Aqui está um exemplo.

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

Você precisará da seguinte permissão no seu manifesto:

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

Aviso: violação do Google Play

O Google ameaçou remover aplicativos da Play Store se eles usassem serviços de acessibilidade para fins de não acessibilidade. No entanto, isso está sendo reconsiderado .

Use um AccessibilityService

• Você pode detectar a janela ativa no momento usando um AccessibilityService.
• No onAccessibilityEventretorno de chamada, verifique o tipo de evento para determinar quando a janela atual é alterada.TYPE_WINDOW_STATE_CHANGED
• Verifique se a janela é uma atividade ligando PackageManager.getActivityInfo().

Benefícios

• Testado e funcionando no Android 2.2 (API 8) através do Android 7.1 (API 25).
• Não requer pesquisa.
• Não requer a GET_TASKSpermissão.

Desvantagens

• Cada usuário deve ativar o serviço nas configurações de acessibilidade do Android.
• Isso não é 100% confiável. Ocasionalmente, os eventos ocorrem fora de ordem.
• O serviço está sempre em execução.
• Quando um usuário tenta ativar AccessibilityService, ele não pode pressionar o botão OK se um aplicativo tiver colocado uma sobreposição na tela. Alguns aplicativos que fazem isso são Velis Auto Brightness e Lux. Isso pode ser confuso porque o usuário pode não saber por que não pode pressionar o botão ou como contornar esse problema.
• Eles AccessibilityServicenão conhecerão a atividade atual até a primeira alteração de atividade.

Exemplo

Serviço

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

Mesclar isso em seu manifesto:

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

Informações de serviço

Coloque isso em 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"/>

Habilitando o serviço

Cada usuário do aplicativo precisará ativar explicitamente o AccessibilityServicepara que ele seja usado. Veja esta resposta StackOverflow para saber como fazer isso.

Observe que o usuário não poderá pressionar o botão OK ao tentar ativar o serviço de acessibilidade se um aplicativo tiver colocado uma sobreposição na tela, como Velis Auto Brightness ou Lux.

Isso pode ser feito por:

1. Implemente sua própria classe de aplicativo, registre-se no ActivityLifecycleCallbacks - dessa forma, você poderá ver o que está acontecendo com nosso aplicativo. Em cada retorno, o retorno de chamada atribui a atividade visível atual na tela e, na pausa, remove a atribuição. Ele usa o método registerActivityLifecycleCallbacks()que foi adicionado na 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. Na sua chamada de serviço getApplication()e transmita-o para o nome da classe do seu aplicativo (neste caso, aplicativo). Do que você pode chamar app.getActiveActivity()- isso fornecerá uma Atividade visível atual (ou nula quando nenhuma atividade estiver visível). Você pode obter o nome da Atividade chamandoactiveActivity.getClass().getSimpleName()

Não consegui encontrar uma solução com a qual nossa equipe ficasse feliz, então criamos a nossa. Usamos ActivityLifecycleCallbackspara acompanhar a atividade atual e, em seguida, expô-la através de um serviço:

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

Em seguida, configure seu contêiner de DI para retornar a instância de MyApplicationpara ContextProvider, por exemplo

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

(Observe que a implementação de getCurrent()é omitida no código acima. É apenas uma variável estática definida no construtor do aplicativo)

Usar ActivityManager

Se você deseja conhecer apenas o aplicativo que contém a atividade atual, pode fazê-lo usando ActivityManager. A técnica que você pode usar depende da versão do Android:

• Pré-pirulito: ActivityManager.getRunningTasks( exemplo )
• Pirulito: ActivityManager.getRunningAppProcesses( exemplo )

Benefícios

• Deve funcionar em todas as versões do Android atualizadas.

Desvantagens

• Não funciona no Android 5.1 ou superior (ele retorna apenas seu próprio aplicativo)
• A documentação dessas APIs diz que elas são destinadas apenas à depuração e gerenciamento de interfaces de usuário.
• Se você quiser atualizações em tempo real, precisará usar a pesquisa.
• Confia em uma API oculta: ActivityManager.RunningAppProcessInfo.processState
• Esta implementação não capta a atividade do alternador de aplicativos.

Exemplo (baseado no código do 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);
    }

}

Manifesto

Adicione a GET_TASKSpermissão para AndroidManifest.xml:

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

Estou usando isso para meus testes. É API> 19, e apenas para atividades do seu aplicativo.

@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 a API 21 ou superior. Isso funciona e fornece melhores resultados em comparação com as outras respostas, ele detecta perfeitamente o processo em primeiro 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();
        }
    }

Aqui está a minha resposta que funciona muito bem ...

Você deve conseguir a Atividade atual dessa maneira ... Se você estruturar seu aplicativo com algumas Atividades com muitos fragmentos e quiser acompanhar qual é a sua Atividade atual, levaria muito trabalho. Meu senario foi que eu tenho uma atividade com vários fragmentos. Para que eu possa acompanhar a Atividade Atual através do Objeto Aplicativo, que pode armazenar todo o estado atual das variáveis ​​Globais.

Aqui está um caminho. Quando você inicia sua Atividade, você a armazena por Application.setCurrentActivity (getIntent ()); Este aplicativo irá armazená-lo. Na sua classe de serviço, você pode simplesmente fazer como Intent currentIntent = Application.getCurrentActivity (); getApplication (). startActivity (currentIntent);

Não sei se é uma resposta estúpida, mas resolvi esse problema armazenando um sinalizador em preferências compartilhadas toda vez que inseri oCreate () de qualquer atividade, então usei o valor das preferências shered para descobrir qual é a atividade em primeiro plano.

Recentemente descobri sobre isso. Com apis como:

• minSdkVersion 19

• targetSdkVersion 26

  ActivityManager.getCurrentActivity (contexto)

Espero que isso seja útil.