¿Cómo obtener el contexto actual de actividad en primer plano en Android?

171

Cada vez que se ejecuta mi transmisión, quiero mostrar alerta a la actividad en primer plano.

Deepali
fuente
desde donde desea obtener el contexto de la actividad. Es esta será su actividad de aplicación u otra aplicación.
AAnkit
Esta es una actividad de la aplicación. He realizado la codificación de diálogo de alerta en la función broadcastreceiver onreceive ().
Deepali
una actividad de la aplicación! ¿Es esta tu aplicación? y por qué quieres esto, por alguna razón, puede haber una alternativa para lo mismo
AAnkit
Quiero mostrar alertas en mi actividad en primer plano. Es su otra forma de mostrar alertas a la actividad en primer plano sin contexto.
Deepali
1
en recepción solo obtienes COntext como parámetro, puedes decir context.getApplicationContext ()
AAnkit el

Respuestas:

39

Sabiendo que ActivityManager administra Activity , entonces podemos obtener información de ActivityManager . Obtenemos la actividad actual en primer plano ejecutando

ActivityManager am = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
ComponentName cn = am.getRunningTasks(1).get(0).topActivity;

ACTUALIZACIÓN 2018/10/03
getRunningTasks () está DEPRECADO. ver las soluciones a continuación.

Este método fue desaprobado en el nivel 21 de API. A partir de Build.VERSION_CODES.LOLLIPOP, este método ya no está disponible para aplicaciones de terceros: la introducción de recientes documentos centrados significa que puede filtrar información de la persona a la persona que llama. Para la compatibilidad con versiones anteriores, aún devolverá un pequeño subconjunto de sus datos: al menos las tareas propias de la persona que llama, y ​​posiblemente algunas otras tareas como el hogar que se sabe que no son sensibles.

KAlO2
fuente
16
No lo creo, Martin, de la ayuda del SDK de getRunningTasks "Nota: este método solo está destinado a depurar y presentar interfaces de usuario de administración de tareas. Esto nunca debe usarse para la lógica central en una aplicación"
Ruhalde
3
Aparentemente, esto solo admite un subconjunto limitado de tareas en ejecución en Android 5 / Lollipop.
Sam
77
La documentación de ActivityManager.getRunningTasks () dice "Este método fue desaprobado en el nivel 21 de API".
markshep
210

( Nota: se agregó una API oficial en la API 14: consulte esta respuesta https://stackoverflow.com/a/29786451/119733 )

NO USE la respuesta ANTERIOR (waqas716).

Tendrá un problema de pérdida de memoria debido a la referencia estática a la actividad. Para obtener más detalles, consulte el siguiente enlace http://android-developers.blogspot.fr/2009/01/avoiding-memory-leaks.html

Para evitar esto, debe administrar las referencias de actividades. Agregue el nombre de la aplicación en el archivo de manifiesto:

<application
    android:name=".MyApp"
    ....
 </application>

Su clase de aplicación:

  public class MyApp extends Application {
        public void onCreate() {
              super.onCreate();
        }

        private Activity mCurrentActivity = null;
        public Activity getCurrentActivity(){
              return mCurrentActivity;
        }
        public void setCurrentActivity(Activity mCurrentActivity){
              this.mCurrentActivity = mCurrentActivity;
        }
  }

Crea una nueva actividad:

public class MyBaseActivity extends Activity {
    protected MyApp mMyApp;

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mMyApp = (MyApp)this.getApplicationContext();
    }
    protected void onResume() {
        super.onResume();
        mMyApp.setCurrentActivity(this);
    }
    protected void onPause() {
        clearReferences();
        super.onPause();
    }
    protected void onDestroy() {        
        clearReferences();
        super.onDestroy();
    }

    private void clearReferences(){
        Activity currActivity = mMyApp.getCurrentActivity();
        if (this.equals(currActivity))
            mMyApp.setCurrentActivity(null);
    }
}

Entonces, ahora en lugar de extender la clase de Actividad para sus actividades, simplemente extienda MyBaseActivity. Ahora, puede obtener su actividad actual de la aplicación o el contexto de Actividad de esa manera:

Activity currentActivity = ((MyApp)context.getApplicationContext()).getCurrentActivity();
gezdy
fuente
9
Simplemente puede usar WeakReference y lograr el mismo resultado con menos código.
Nacho Coloma
55
@Nacho Nunca recomendaría usar WeakReferencesen Android, el GC los recopila más rápido de lo que piensas.
rekire
44
@MaximKorobov Sí, es posible si llama a finish () desde onCreate (), si usa su actividad solo para iniciar otra actividad y detiene esta. En este escenario, omite onPause () y onStoo (). Vea la nota inferior de: developer.android.com/training/basics/activity-lifecycle/…
Rodrigo Leitão
2
@rekire @NachoColoma El uso de WeakReferenceno se recomienda para el almacenamiento en caché, esto no es almacenamiento en caché, es decir mCurrentActivity, solo tendrá una referencia cuando esté vivo, por lo WeakReferenceque nunca se recolectará mientras Activityesté en la parte superior. Sin embargo, lo que sugiere @NachoColoma es incorrecto porque WeakReferenceaún puede hacer referencia a una actividad no reanudada (no activa / no superior) si la variable no se borra.
TWiStErRob
14
A partir del nivel 14 de la API de Android, debería ser posible usarlo Application .ActivityLifecycleCallbacks, lo que sería más central y no tendría que agregar ningún código de administración en todas sus actividades. Ver también developer.android.com/reference/android/app/…
Filou
68

Me expando en la parte superior de la respuesta de @ gezdy.

En cada actividad, en lugar de tener que "registrarse" Applicationcon la codificación manual, podemos utilizar la siguiente API desde el nivel 14, para ayudarnos a lograr un propósito similar con menos codificación manual.

public void registerActivityLifecycleCallbacks (Application.ActivityLifecycleCallbacks callback)

http://developer.android.com/reference/android/app/Application.html#registerActivityLifecycleCallbacks%28android.app.Application.ActivityLifecycleCallbacks%29

En Application.ActivityLifecycleCallbacks, puede obtener cuál Activityestá "adjunto" o "desconectado" a esto Application.

Sin embargo, esta técnica solo está disponible desde el nivel API 14.

Cheok Yan Cheng
fuente
1
¿Qué pasa con todas las otras respuestas? Claramente, esta es una API diseñada para este propósito. Gracias, Cheok Yan Cheng
Michael Bushe
2
@MichaelBushe: en 2012, cuando se escribieron las otras respuestas, dependiendo del nivel 14 de API no era algo en lo que confiar en todos los dispositivos, dado que la API solo se había lanzado recientemente (octubre de 2011).
ToolmakerSteve
44
Encontré una respuesta que muestra cómo usar este enfoque: stackoverflow.com/a/11082332/199364 El beneficio es que no es necesario hacer nada para las actividades mismas ; todo el código está en su clase de devolución de llamada personalizada. Simplemente crea una clase que implements Application.ActivityLifecycleCallbacks, y agrega los métodos para implementar eso. Luego, en el constructor de esa clase (o onCreate o init u otro método que se ejecuta cuando la instancia se vuelve activa / lista), coloque getApplication().registerActivityLifecycleCallbacks(this);como la última línea.
ToolmakerSteve
Creo que su respuesta es la mejor
burulangtu
2
gran respuesta. El único inconveniente es que aún necesita guardar la actividad en algún lugar si necesita consultar su clase para la actividad actual. así que aún debe evitar la pérdida de memoria y anular la referencia.
Raphael C
56

Actualización 2 : hay una API oficial agregada para esto, utilice ActivityLifecycleCallbacks en su lugar.

ACTUALIZAR:

Como señaló @gezdy, y estoy agradecido por eso. establezca la referencia a nulo también para la actividad actual, en lugar de actualizarse en cada onResume, configúrelo como nulo en cada onDestroy de cada actividad para evitar problemas de pérdida de memoria.

Hace un tiempo necesitaba la misma funcionalidad y aquí está el método para lograrlo. En cada una de sus actividades, anule estos métodos del ciclo de vida.

@Override
protected void onResume() {
    super.onResume();
    appConstantsObj.setCurrentActivity(this);

}

@Override
protected void onPause() {
   clearReferences();
   super.onPause();
}

@Override
protected void onDestroy() {        
   clearReferences();
   super.onDestroy();
}

private void clearReferences(){
          Activity currActivity = appConstantsObj.getCurrentActivity();
          if (this.equals(currActivity))
                appConstantsObj.setCurrentActivity(null);
}

Ahora en su clase de transmisión puede acceder a la actividad actual para mostrar alertas en ella.

Waqas
fuente
3
Esta respuesta realmente debería obtener más votos positivos, una solución simple, pero poderosa cuando tienes clases que necesitan manipular actividades, pero no son actividades en sí mismas.
ryvianstyron
Se trata solo de una referencia estática de su objeto de actividad. Puedes crearlo donde quieras :). No importa.
Waqas
Esto es por cierto equivalente a su respuesta anterior. Applicationsolo se crea una vez y nunca se recolecta basura exactamente como una variable estática.
zapl
1
Habrá problemas con las actividades jerárquicas. Cuando regresa de una actividad infantil a la principal: (1) se llama onPause del niño; (2) el currículum vitae de los padres; (3) child onDestroy ==> la actividad actual será nula. Debería hacer alguna comprobación como @gezdy en su ejemplo en el método clearReferences.
Artes
44
@ waqas716 me gustaría sugerir a simplificar la condición en la clearReferences()que (this.equals(currActivity)).
naXa
51

@lockwobr Gracias por la actualización

Esto no funciona el 100% del tiempo en la versión 16 de la API, si lees el código en github, la función "currentActivityThread" se modificó en Kitkat, por lo que quiero decir que la versión 19ish, un poco difícil de igualar a la versión de la API para lanzamientos en github .

Tener acceso a la corriente Activityes muy útil. ¿No sería bueno tener un getActivitymétodo estático que devuelva la Actividad actual sin preguntas innecesarias?

La Activityclase es muy útil. Da acceso al hilo de la interfaz de usuario de la aplicación, vistas, recursos y muchos más. Numerosos métodos requieren un Context, pero ¿cómo obtener el puntero? Aquí hay algunas maneras:

  • Seguimiento del estado de la aplicación utilizando métodos de ciclo de vida anulados. Debe almacenar la Actividad actual en una variable estática y necesita acceder al código de todas las Actividades.
  • Seguimiento del estado de la aplicación utilizando Instrumentación. Declare la instrumentación en el manifiesto, impleméntela y use sus métodos para rastrear los cambios de actividad. Pasar un puntero de actividad a los métodos y clases utilizados en sus actividades. Inyectar el puntero utilizando una de las bibliotecas de inyección de código. Todos estos enfoques son bastante inconvenientes ; Afortunadamente, hay una manera mucho más fácil de obtener la Actividad actual.
  • Parece que el sistema necesita acceso a todas las actividades sin los problemas mencionados anteriormente. Por lo tanto, lo más probable es que haya una manera de obtener Actividades usando solo llamadas estáticas. Pasé mucho tiempo buscando en las fuentes de Android en grepcode.com, y encontré lo que estaba buscando. Hay una clase llamada ActivityThread. Esta clase tiene acceso a todas las actividades y, lo que es aún mejor, tiene un método estático para obtener la corriente ActivityThread. Solo hay un pequeño problema: la lista de actividades tiene acceso a paquetes.

Fácil de resolver usando la reflexión:

public static Activity getActivity() {
    Class activityThreadClass = Class.forName("android.app.ActivityThread");
    Object activityThread = activityThreadClass.getMethod("currentActivityThread").invoke(null);
    Field activitiesField = activityThreadClass.getDeclaredField("mActivities");
    activitiesField.setAccessible(true);

    Map<Object, Object> activities = (Map<Object, Object>) activitiesField.get(activityThread);
    if (activities == null)
        return null;

    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);
            Activity activity = (Activity) activityField.get(activityRecord);
            return activity;
        }
    }

    return null;
}

Tal método se puede usar en cualquier lugar de la aplicación y es mucho más conveniente que todos los enfoques mencionados. Además, parece que no es tan inseguro como parece. No introduce nuevas fugas potenciales o punteros nulos.

El fragmento de código anterior carece de manejo de excepciones y asume ingenuamente que la primera Actividad en ejecución es la que estamos buscando. Es posible que desee agregar algunas comprobaciones adicionales.

Entrada en el blog

ARIZONA_
fuente
2
en Kitkat y superior, mActivities no es HashMap, sino ArrayMap, por lo que debe cambiar esta línea: HashMap activities = (HashMap) activitiesField.get (activityThread); para parecerse a esto: ArrayMap activities = (ArrayMap) activitiesField.get (activityThread);
Palejandro
77
@Palejandro para admitir ambos niveles de la API (por encima de 18 y por debajo) debería usar la Mapinterfaz en su lugar HashMapo ArrayMap. He editado @AZ_ answer.
Yuriy Kolbasinskiy
2
Esto no funciona el 100% del tiempo en la versión 16 de la API , si lees el código en github, la función "currentActivityThread" se modificó en Kitkat, por lo que quiero decir que la versión 19ish , un poco difícil de igualar a la versión de la API para lanzamientos en github .
lockwobr
@lockwobr gracias, solución actualizada con tu comentario
:)
2
No se admite el acceso a API internas a través de la reflexión y es posible que no funcione en todos los dispositivos o en el futuro.
Pei
9

Hice lo siguiente en Kotlin

  1. Crear clase de aplicación
  2. Edite la clase de aplicación como sigue

    class FTApplication: MultiDexApplication() {
    override fun attachBaseContext(base: Context?) {
        super.attachBaseContext(base)
        MultiDex.install(this)
    }
    
    init {
        instance = this
    }
    
    val mFTActivityLifecycleCallbacks = FTActivityLifecycleCallbacks()
    
    override fun onCreate() {
        super.onCreate()
    
        registerActivityLifecycleCallbacks(mFTActivityLifecycleCallbacks)
    }
    
    companion object {
        private var instance: FTApplication? = null
    
        fun currentActivity(): Activity? {
    
            return instance!!.mFTActivityLifecycleCallbacks.currentActivity
        }
    }
    
     }
  3. Crear la clase ActivityLifecycleCallbacks

    class FTActivityLifecycleCallbacks: Application.ActivityLifecycleCallbacks {
    
    var currentActivity: Activity? = null
    
    override fun onActivityPaused(activity: Activity?) {
        currentActivity = activity
    }
    
    override fun onActivityResumed(activity: Activity?) {
        currentActivity = activity
    }
    
    override fun onActivityStarted(activity: Activity?) {
        currentActivity = activity
    }
    
    override fun onActivityDestroyed(activity: Activity?) {
    }
    
    override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {
    }
    
    override fun onActivityStopped(activity: Activity?) {
    }
    
    override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {
        currentActivity = activity
    }
    
    }
  4. ahora puede usarlo en cualquier clase llamando a lo siguiente: FTApplication.currentActivity()

Rashad.Z
fuente
5

getCurrentActivity () también está en ReactContextBaseJavaModule.
(Dado que esta pregunta se hizo inicialmente, muchas aplicaciones de Android también tienen el componente ReactNative: aplicación híbrida).

La clase ReactContext en ReactNative tiene todo el conjunto de lógica para mantener mCurrentActivity que se devuelve en getCurrentActivity ().

Nota: Deseo que getCurrentActivity () se implemente en la clase de aplicación de Android.

朱梅寧
fuente
en algunos casos este contexto de ReactContextBaseJavaModule es nulo, ¿sabes por qué?
Moxor
4

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. Más detalles aquí: https://stackoverflow.com/a/38650587/10793

Muxa
fuente
2

Para compatibilidad con versiones anteriores:

ComponentName cn;
ActivityManager am = (ActivityManager) getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
    cn = am.getAppTasks().get(0).getTaskInfo().topActivity;
} else {
    //noinspection deprecation
    cn = am.getRunningTasks(1).get(0).topActivity;
}
Martin Zeitler
fuente
44
A menos que haya una manera de pasar de ComponentName a la instancia actual de la Actividad, esto no responde la pregunta IMO.
nasch
@nasch se puede mantener y obtener un WeakReferenceidentificador de una Applicationclase, mientras que ComponentNamese requiere para determinar si el deseado Activityestá en la parte superior de la lista de tareas en ejecución. Y si esto no responde completamente la pregunta, la respuesta aceptada tampoco.
Martin Zeitler
Estoy de acuerdo, la respuesta aceptada tampoco responde completamente la pregunta.
nasch
1
topActivityestá disponible solo desde Android Q
Eugen Martynov
1

Personalmente hice lo que dijo "Cheok Yan Cheng", pero usé una "Lista" para tener un "Backstack" de todas mis actividades.

Si desea verificar cuál es la actividad actual, solo necesita obtener la última clase de actividad en la lista.

Cree una aplicación que extienda "Aplicación" y haga esto:

public class MyApplication extends Application implements Application.ActivityLifecycleCallbacks,
EndSyncReceiver.IEndSyncCallback {

private List<Class> mActivitiesBackStack;
private EndSyncReceiver mReceiver;
    private Merlin mMerlin;
    private boolean isMerlinBound;
    private boolean isReceiverRegistered;

@Override
    public void onCreate() {
        super.onCreate();
        [....]
RealmHelper.initInstance();
        initMyMerlin();
        bindMerlin();
        initEndSyncReceiver();
        mActivitiesBackStack = new ArrayList<>();
    }

/* START Override ActivityLifecycleCallbacks Methods */
    @Override
    public void onActivityCreated(Activity activity, Bundle bundle) {
        mActivitiesBackStack.add(activity.getClass());
    }

    @Override
    public void onActivityStarted(Activity activity) {
        if(!isMerlinBound){
            bindMerlin();
        }
        if(!isReceiverRegistered){
            registerEndSyncReceiver();
        }
    }

    @Override
    public void onActivityResumed(Activity activity) {

    }

    @Override
    public void onActivityPaused(Activity activity) {

    }

    @Override
    public void onActivityStopped(Activity activity) {
        if(!AppUtils.isAppOnForeground(this)){
            if(isMerlinBound) {
                unbindMerlin();
            }
            if(isReceiverRegistered){
                unregisterReceiver(mReceiver);
            }
            if(RealmHelper.getInstance() != null){
                RealmHelper.getInstance().close();
                RealmHelper.getInstance().logRealmInstanceCount("AppInBackground");
                RealmHelper.setMyInstance(null);
            }
        }
    }

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

    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        if(mActivitiesBackStack.contains(activity.getClass())){
            mActivitiesBackStack.remove(activity.getClass());
        }
    }
    /* END Override ActivityLifecycleCallbacks Methods */

/* START Override IEndSyncCallback Methods */
    @Override
    public void onEndSync(Intent intent) {
        Constants.SyncType syncType = null;
        if(intent.hasExtra(Constants.INTENT_DATA_SYNC_TYPE)){
            syncType = (Constants.SyncType) intent.getSerializableExtra(Constants.INTENT_DATA_SYNC_TYPE);
        }
        if(syncType != null){
            checkSyncType(syncType);
        }
    }
    /* END IEndSyncCallback Methods */

private void checkSyncType(Constants.SyncType){
    [...]
    if( mActivitiesBackStack.contains(ActivityClass.class) ){
         doOperation()     }
}

}

En mi caso usé "Application.ActivityLifecycleCallbacks" para:

  • Enlace / Desvincular instancia de Merlin (se usa para obtener eventos cuando la aplicación pierde u obtiene conexión, por ejemplo, cuando cierra datos móviles o cuando los abre). Es útil después de que se deshabilitó la acción de intención "OnConnectivityChanged". Para más información sobre MERLIN ver: MERLIN INFO LINK

  • Cerrar mi última instancia de reino cuando la aplicación está cerrada; Lo iniciaré dentro de una BaseActivity que se extiende desde todas las demás actividades y que tiene una instancia privada RealmHelper. Para obtener más información sobre REALM, consulte: REALM INFO LINK. Por ejemplo, tengo una instancia estática "RealmHelper" dentro de mi clase "RealmHelper", que se instancia dentro de mi aplicación "onCreate". Tengo un servicio de sincronización en el que creo un nuevo "RealmHelper" porque Realm está "enlazado a hilos" y una instancia de reino no puede funcionar dentro de un hilo diferente. Entonces, para seguir la documentación del reino "Debe cerrar todas las instancias de reino abiertas para evitar fugas de recursos del sistema", para lograr esto utilicé "Application.ActivityLifecycleCallbacks" como puede ver.

  • Finalmente, tengo un receptor que se dispara cuando termino de sincronizar mi aplicación, luego, cuando finaliza la sincronización, llamará al método "onEndSync" "IEndSyncCallback" en el que busco si tengo una Clase de Actividad específica dentro de mi Lista de Actividades BackStack porque necesito para actualizar los datos en la vista si la sincronización los actualizó y podría necesitar hacer otras operaciones después de la sincronización de la aplicación.

Eso es todo, espero que esto sea útil. Nos vemos :)

Z3R0
fuente
-1

La respuesta de waqas716 es buena. Creé una solución para un caso específico que exige menos código y mantenimiento.

Encontré una solución específica al hacer que un método estático obtenga una vista de la actividad que sospecho que está en primer plano. Puede recorrer todas las actividades y verificar si lo desea u obtener el nombre de la actividad de la respuesta de Martin

ActivityManager am = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
ComponentName cn = am.getRunningTasks(1).get(0).topActivity; 

Luego verifico si la vista no es nula y obtengo el contexto a través de getContext ().

View v = SuspectedActivity.get_view();

if(v != null)
{
    // an example for using this context for something not 
    // permissible in global application context. 
    v.getContext().startActivity(new Intent("rubberduck.com.activities.SomeOtherActivity"));
}
Pato de goma
fuente
Estoy buscando un problema similar aquí stackoverflow.com/questions/22788289/... ¿cómo obtenemos "SuspectedActivity"? ¿Es esta API nativa?
Stella
2
PERO de documentos para getRunningTasks: "Note: this method is only intended for debugging and presenting task management user interfaces. This should never be used for core logic in an application, ..." en developer.android.com/reference/android/app/…
ToolmakerSteve
3
La documentación de ActivityManager.getRunningTasks () ahora dice "Este método fue desaprobado en el nivel 21 de API".
markshep
-2

No me gusta ninguna de las otras respuestas. El ActivityManager no está destinado a usarse para obtener la actividad actual. Super clasificación y dependiendo de onDestroy también es frágil y no es el mejor diseño.

Honestamente, lo mejor que se me ocurrió hasta ahora es mantener una enumeración en mi aplicación, que se establece cuando se crea una actividad.

Otra recomendación podría ser evitar usar múltiples actividades si es posible. Esto se puede hacer con el uso de fragmentos o en mis vistas personalizadas de preferencia.

stevebot
fuente
1
una enumeración? ¿Cómo ayuda eso a localizar la instancia actual de actividad en primer plano?
ToolmakerSteve
"Super clasificación y dependiendo de onDestroy también es frágil" ¿Cómo es eso frágil?
ToolmakerSteve
-3

Una solución bastante simple es crear una clase de administrador singleton, en la que pueda almacenar una referencia a una o más Actividades, o cualquier otra cosa a la que desee acceder en toda la aplicación.

Llama UberManager.getInstance().setMainActivity( activity );a onCreate de la actividad principal.

Llame a UberManager.getInstance().getMainActivity();cualquier parte de su aplicación para recuperarla. (Estoy usando esto para poder usar Toast desde un hilo no UI).

Asegúrate de agregar una llamada UberManager.getInstance().cleanup();cuando se destruya tu aplicación.

import android.app.Activity;

public class UberManager
{
    private static UberManager instance = new UberManager();

    private Activity mainActivity = null;

    private UberManager()
    {

    }

    public static UberManager getInstance()
    {
        return instance;
    }

    public void setMainActivity( Activity mainActivity )
    {
        this.mainActivity = mainActivity;
    }

    public Activity getMainActivity()
    {
        return mainActivity;
    }

    public void cleanup()
    {
        mainActivity = null;
    }
}
MukRaker
fuente
Esto es intrusivo y requiere cambios en todas las actividades. La respuesta de AZ_ es mucho mejor ya que está totalmente localizada y es independiente sin requerir otros cambios en la base de código.
markshep
-7

Llego como 3 años tarde pero lo responderé de todos modos en caso de que alguien encuentre esto como yo.

Resolví esto simplemente usando esto:

    if (getIntent().toString().contains("MainActivity")) {
        // Do stuff if the current activity is MainActivity
    }

Tenga en cuenta que "getIntent (). ToString ()" incluye muchos otros textos, como el nombre de su paquete y cualquier filtro de intención para su actividad. Técnicamente estamos verificando la intención actual, no la actividad, pero el resultado es el mismo. Simplemente use, por ejemplo, Log.d ("prueba", getIntent (). ToString ()); si quieres ver todo el texto Esta solución es un poco hacky pero es mucho más limpia en su código y la funcionalidad es la misma.

Simon Hyll
fuente