Как получить текущий контекст активности переднего плана в Android?


171

Всякий раз, когда моя трансляция выполняется, я хочу показывать предупреждение переднего плана деятельности.


откуда вы хотите получить контекст Activity. Будет ли это ваше приложение деятельности или другого приложения.
AAnkit

это приложение активности. Я выполнил кодирование предупреждений в функции onreceive () вещательного приемника.
Дипали

активность приложения! это ваше приложение ?? и зачем тебе это, по любой причине, может есть альтернатива тому же
AAnkit

Я хочу показать оповещение о своей активности на переднем плане. Это любой другой способ показать оповещение об активности на переднем плане без контекста.
Дипали

1
только при получении COntext в качестве параметра вы можете сказать context.getApplicationContext ()
AAnkit

Ответы:


39

Зная, что ActivityManager управляет Activity , мы можем получать информацию из ActivityManager . Мы получаем текущий передний план, запускающий Activity by

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

ОБНОВЛЕНИЕ 2018/10/03
getRunningTasks () УСТАРЕЛО. увидеть решения ниже.

Этот метод устарел на уровне API 21. Начиная с версии Build.VERSION_CODES.LOLLIPOP, этот метод больше не доступен для сторонних приложений: введение центрированных на документе рецентов означает, что он может передавать информацию о человеке вызывающей стороне. Для обратной совместимости он по-прежнему будет возвращать небольшое подмножество своих данных: по крайней мере, собственные задачи вызывающего абонента и, возможно, некоторые другие задачи, например домашние, которые, как известно, не являются чувствительными.


16
Не думайте, Мартин, из справки SDR getRunningTasks: «Примечание: этот метод предназначен только для отладки и представления пользовательских интерфейсов управления задачами.
Его

3
По-видимому, это поддерживает только ограниченный набор запущенных задач в Android 5 / Lollipop.
Сэм

7
В документации для ActivityManager.getRunningTasks () говорится: «Этот метод устарел на уровне API 21».
markhep

210

( Примечание: официальный API был добавлен в API 14: см. Этот ответ https://stackoverflow.com/a/29786451/119733 )

НЕ ИСПОЛЬЗУЙТЕ ПРЕДЫДУЩИЙ (waqas716) ответ.

У вас будет проблема утечки памяти из-за статической ссылки на действие. Для получения дополнительной информации см. Следующую ссылку http://android-developers.blogspot.fr/2009/01/avoiding-memory-leaks.html.

Чтобы избежать этого, вы должны управлять ссылками на действия. Добавьте название приложения в файл манифеста:

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

Ваш класс приложения:

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

Создать новую активность:

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

Итак, теперь вместо расширения класса Activity для ваших действий просто расширьте MyBaseActivity. Теперь вы можете получить текущую активность из приложения или из контекста активности следующим образом:

Activity currentActivity = ((MyApp)context.getApplicationContext()).getCurrentActivity();

9
Вы можете просто использовать WeakReference и достичь того же результата с меньшим количеством кода.
Начо Колома

5
@Nacho Я бы никогда не рекомендовал использовать WeakReferencesв Android GC, собирая их быстрее, чем вы думаете.
rekire

4
@MaximKorobov Да, это возможно, если вы вызываете finish () из onCreate (), если вы используете свое действие только для запуска другого действия и прекращаете его. В этом случае он пропускает onPause () и onStoo (). См. Примечание внизу: developer.android.com/training/basics/activity-lifecycle/…
Родриго Лейтау,

2
@rekire @NachoColoma Использование WeakReferenceне рекомендуется для кэширования, это не кэширование, то mCurrentActivityесть ссылка будет только на него, когда он жив, поэтому WeakReferenceон никогда не будет собираться, пока он Activityнаходится сверху. Однако то, что предлагает @NachoColoma, неверно, поскольку оно WeakReferenceможет ссылаться на невозобновленную (не активную / не активную ) активность, если переменная не очищена!
TWiStErRob

14
Начиная с уровня API Android 14, можно использовать его Application .ActivityLifecycleCallbacks, который будет более центральным, и вам не придется добавлять какой-либо код управления во все ваши действия. Также см developer.android.com/reference/android/app/...
Filou

68

Я раскрываю верхнюю часть ответа @ gezdy.

В каждой деятельности вместо того, чтобы «регистрироваться» с Applicationпомощью ручного кодирования, мы можем использовать следующий API начиная с уровня 14, чтобы помочь нам достичь аналогичной цели с меньшим количеством ручного кодирования.

public void registerActivityLifecycleCallbacks (Application.ActivityLifecycleCallbacks callback)

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

В Application.ActivityLifecycleCallbacks, вы можете получить , который Activity«привязанный» или «удаленный» на это Application.

Однако этот метод доступен только с уровня API 14.


1
Что случилось со всеми другими ответами? Понятно, что это разработанный API для этой цели. Спасибо, Чок Ян Ченг
Майкл Буш

2
@MichaelBushe - в 2012 году, когда были написаны другие ответы, в зависимости от уровня API 14 нельзя было полагаться на каждое устройство, учитывая, что API был выпущен только недавно (октябрь 2011 года).
ToolmakerSteve

4
Нашел ответ, показывающий, как использовать этот подход: stackoverflow.com/a/11082332/199364 Преимущество состоит в том, что ничего не нужно делать для самих действий ; код все в вашем пользовательском классе обратного вызова. Вы просто создаете класс implements Application.ActivityLifecycleCallbacksи добавляете методы для его реализации. Затем в конструкторе этого класса (или onCreate, или init, или другом методе, который запускается, когда экземпляр становится активным / готовым), поместите getApplication().registerActivityLifecycleCallbacks(this);в качестве последней строки.
ToolmakerSteve

Я думаю, что ваш ответ лучше всего
Burulangtu

2
отличный ответ. Единственным недостатком является то, что вам все равно нужно сохранять активность в каком-то месте, если вам нужно запросить у вашего класса текущую активность. так что вам все равно нужно избегать утечки памяти и обнулять ссылку.
Рафаэль C

56

Обновление 2 : для этого добавлен официальный API, пожалуйста, используйте взамен ActivityLifecycleCallbacks .

ОБНОВИТЬ:

Как указано @gezdy, и я благодарен за это. установите ссылку на null тоже для текущей активности, вместо обновления только для каждого onResume, установите для нее значение null в onDestroy каждого действия, чтобы избежать проблемы утечки памяти.

Некоторое время назад мне нужна была та же функциональность, и вот метод, как я этого добился. В каждой вашей деятельности переопределите эти методы жизненного цикла.

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

Теперь в вашем классе вещания вы можете получить доступ к текущей активности, чтобы показать предупреждение о ней.


3
Этот ответ должен действительно получить больше голосов, простое решение, но мощное, когда у вас есть классы, которым нужно манипулировать действиями, но не самими действиями.
ryvianstyron

Это просто статическая ссылка на ваш объект деятельности. Вы можете создать его где угодно :). Это не важно
Вакас

Это, кстати, эквивалентно вашему предыдущему ответу. Applicationсоздается только один раз и никогда не собирается как мусор, как статическая переменная.
Запл

1
Будут проблемы с иерархической деятельностью. Когда вы возвращаетесь из дочернего действия в родительское, оно: (1) называется дочерним onPause; (2) родительский onResume; (3) onDestroy ребенка ==> текущая активность будет нулевой. Вы должны сделать некоторую проверку как @gezdy в его примере в методе clearReferences.
Arts

4
@ waqas716 Я бы предложил упростить условие clearReferences()до (this.equals(currActivity)).
naXa

51

@lockwobr Спасибо за обновление

Это не работает 100% времени в API-версии 16, если вы читаете код на github, функция "currentActivityThread" была изменена в Kitkat, поэтому я хочу сказать, что версия 19ish, довольно сложно сопоставить версию API с выпусками в github ,

Доступ к току Activityочень удобен. Разве не было бы неплохо иметь статический getActivityметод, возвращающий текущую активность без лишних вопросов?

ActivityКласс очень полезен. Он предоставляет доступ к потоку пользовательского интерфейса приложения, представлениям, ресурсам и многому другому. Многочисленные методы требуют Context, но как получить указатель? Вот несколько способов:

  • Отслеживание состояния приложения с использованием переопределенных методов жизненного цикла. Вы должны сохранить текущую активность в статической переменной, и вам нужен доступ к коду всех действий.
  • Отслеживание состояния приложения с помощью Инструментов. Объявите Инструментарий в манифесте, внедрите его и используйте его методы для отслеживания изменений в Деятельности. Передача указателя Activity на методы и классы, используемые в вашей Activity. Внедрение указателя с использованием одной из библиотек внедрения кода. Все эти подходы довольно неудобны ; К счастью, есть гораздо более простой способ получить текущую активность.
  • Похоже, системе нужен доступ ко всем действиям без проблем, упомянутых выше. Так что, скорее всего, есть способ получить Activity, используя только статические вызовы. Я провел много времени, копаясь в источниках Android на grepcode.com, и нашел то, что искал. Есть класс под названием ActivityThread. Этот класс имеет доступ ко всем действиям и, что еще лучше, имеет статический метод для получения текущего ActivityThread. Есть только одна маленькая проблема - список действий имеет доступ к пакету.

Легко решить с помощью отражения:

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

Такой метод можно использовать в любом месте приложения, и он намного удобнее, чем все упомянутые подходы. Более того, кажется, что это не так опасно, как кажется. Он не вводит никаких новых потенциальных утечек или нулевых указателей.

В приведенном выше фрагменте кода отсутствует обработка исключений, и он наивно предполагает, что первое запущенное действие - это то, что мы ищем. Возможно, вы захотите добавить некоторые дополнительные проверки.

Сообщение блога


2
в Kitkat и выше mActivities - это не HashMap, а ArrayMap, поэтому вам нужно изменить эту строку: HashMap activity = (HashMap) activityField.get (activityThread); выглядеть следующим образом: ArrayMap activity = (ArrayMap) activityField.get (activityThread);
Палехандро

7
@Palejandro для поддержки обоих уровней API (выше 18 и ниже) он должен использовать Mapинтерфейс HashMapили ArrayMap. Я отредактировал @AZ_ ответ.
Юрий Колбасинский

2
Это не работает 100% времени в API- версии 16 , если вы читаете код на github, функция «currentActivityThread» была изменена в Kitkat, поэтому я хочу сказать, что версия 19ish , довольно сложно сопоставить версию API с выпусками в github ,
lockwobr

@lockwobr спасибо, решение обновлено с вашим комментарием
:)

2
Доступ к внутренним API через рефлексию не поддерживается и может работать не на всех устройствах или в будущем.
Пей

9

Я сделал следующее в Котлине

  1. Создать класс приложения
  2. Отредактируйте класс приложения следующим образом

    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. Создайте класс 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. Теперь вы можете использовать его в любом классе, вызвав следующее: FTApplication.currentActivity()


5

getCurrentActivity () также находится в ReactContextBaseJavaModule.
(Поскольку этот вопрос был задан изначально, многие приложения для Android также имеют компонент ReactNative - гибридное приложение.)

Класс ReactContext в ReactNative имеет полный набор логики для поддержки mCurrentActivity, который возвращается в getCurrentActivity ().

Примечание. Мне бы хотелось, чтобы функция getCurrentActivity () была реализована в классе приложений Android.


в некоторых случаях этот контекст из ReactContextBaseJavaModule имеет значение null, знаете почему?
Моксор

4

Я не мог найти решение, которым наша команда была бы довольна, поэтому мы сделали свое дело. Мы используем, ActivityLifecycleCallbacksчтобы отслеживать текущую активность, а затем выставлять ее через сервис. Более подробная информация здесь: https://stackoverflow.com/a/38650587/10793


2

Для обратной совместимости:

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

4
Если нет способа перейти от ComponentName к текущему экземпляру Activity, это не ответит на вопрос IMO.
nasch

@nasch можно сохранить и получить WeakReferenceдескриптор из Applicationкласса - в то время ComponentNameкак требуется определить, находится ли желаемое Activityв верхней части списка запущенных задач. И если это не полностью отвечает на вопрос, принятый ответ также не дает.
Мартин

Я согласен, принятый ответ также не полностью отвечает на вопрос.
nasch

1
topActivityдоступен только с Android Q
Евгений Мартынов

1

Лично я сделал, как сказал «Чок Ян Ченг», но использовал «Список», чтобы получить «Backstack» во всех моих действиях.

Если вы хотите проверить, что является текущей активностью, вам просто нужно получить последний класс активности в списке.

Создайте приложение, которое расширяет «Приложение», и сделайте это:

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

}

В моем случае я использовал «Application.ActivityLifecycleCallbacks», чтобы:

  • Bind / Unbind Merlin Instance (используется для получения события, когда приложение теряет или получает соединение, например, когда вы закрываете мобильные данные или когда вы открываете его). Это полезно после того, как намеренное действие «OnConnectivityChanged» было отключено. Для получения дополнительной информации о MERLIN см .: MERLIN INFO LINK

  • Закрыть мой последний экземпляр области, когда приложение закрыто; Я начну его внутри BaseActivity, которое расширено от всех других действий и имеет частный экземпляр RealmHelper. Для получения дополнительной информации о REALM см .: REALM INFO LINK. Например, у меня есть статический экземпляр «RealmHelper» внутри моего класса «RealmHelper», который создается внутри моего приложения «onCreate». У меня есть служба синхронизации, в которой я создаю новый «RealmHelper», потому что Realm «связан с потоками», а экземпляр Realm не может работать в другом потоке. Поэтому для того, чтобы следовать Документации области «Вам необходимо закрыть все открытые экземпляры области, чтобы избежать утечки системных ресурсов», для достижения этой цели я использовал «Application.ActivityLifecycleCallbacks», как вы можете видеть вверх.

  • Наконец, у меня есть получатель, который запускается, когда я заканчиваю синхронизацию своего приложения, затем, когда заканчивается синхронизация, он вызывает метод «IEndSyncCallback» «onEndSync», в котором я проверяю, есть ли у меня определенный класс Activity в моем списке ActivityBackStack, потому что мне нужно обновить данные в представлении, если синхронизация обновила их, и мне может потребоваться выполнить другие операции после синхронизации приложения.

Это все, надеюсь, это полезно. Увидимся :)


-1

Ответ от waqas716 хорош. Я создал обходной путь для конкретного случая, требующего меньше кода и обслуживания.

Я нашел конкретную работу, применив статический метод, извлекающий представление из действия, которое, как я подозреваю, находится на переднем плане. Вы можете перебирать все действия и проверять, хотите ли вы или получаете название действия из ответа Мартина

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

Затем я проверяю, не является ли представление нулевым, и получаю контекст через 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"));
}

Я ищу похожую проблему здесь stackoverflow.com/questions/22788289/… как мы получаем "SuspectedActivity"? Это родной API?
Стелла

2
НО из Документов 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, ..." в developer.android.com/reference/android/app/...
ToolmakerSteve

3
В документации для ActivityManager.getRunningTasks () теперь говорится «Этот метод устарел на уровне API 21».
markhep

-2

Мне не нравятся другие ответы. ActivityManager не предназначен для получения текущей активности. Суперклассификация и в зависимости от onDestroy также хрупкая и не лучший дизайн.

Честно говоря, лучшее, что я придумал до сих пор, это просто поддержание перечисления в моем приложении, которое устанавливается при создании действия.

Другая рекомендация может заключаться в том, чтобы просто избегать использования нескольких видов деятельности, если это возможно. Это может быть сделано либо с использованием фрагментов, либо в моих предпочтениях пользовательских представлений.


1
перечисление? Как это помогает найти текущий экземпляр активности переднего плана?
ToolmakerSteve

«Супер-классификация и зависимость от onDestroy также хрупкая» Как это хрупко?
ToolmakerSteve

-3

Довольно простое решение - создать класс синглтон-менеджера, в котором вы можете хранить ссылку на одно или несколько действий или что-то еще, к чему вы хотите получить доступ во всем приложении.

Позвоните UberManager.getInstance().setMainActivity( activity );в основной деятельности по созданию.

Звоните в UberManager.getInstance().getMainActivity();любое место вашего приложения, чтобы получить его. (Я использую это, чтобы иметь возможность использовать тост из потока, не являющегося пользовательским интерфейсом.)

Убедитесь, что вы добавляете вызов, UberManager.getInstance().cleanup();когда ваше приложение уничтожается.

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

Это навязчиво и требует изменений во всех видах деятельности. Ответ на AZ_ намного лучше , так как он полностью локализован и автономный , не требуя дополнительных изменений в коде.
markhep

-7

Я опоздал на 3 года, но я все равно отвечу, если кто-то найдет это, как я.

Я решил это, просто используя это:

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

Обратите внимание, что «getIntent (). ToString ()» включает в себя множество других текстов, таких как имя вашего пакета и любые фильтры намерений для вашей деятельности. Технически мы проверяем текущее намерение, а не деятельность, но результат тот же. Просто используйте, например, Log.d ("test", getIntent (). ToString ()); если вы хотите увидеть весь текст. Это решение немного хакерское, но оно намного чище в вашем коде и функциональность та же.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.