Статический способ получить «Контекст» в Android?

Нет, не думаю. К сожалению, вы застряли при вызове getApplicationContext() из Activity или одного из других подклассов Context. Кроме того, этот вопрос несколько связан.

Вот недокументированный способ получить приложение (который является контекстом) из любого места в потоке пользовательского интерфейса. Он полагается на скрытый статический метод ActivityThread.currentApplication(). Он должен работать как минимум на Android 4.x.

try {
    final Class<?> activityThreadClass =
            Class.forName("android.app.ActivityThread");
    final Method method = activityThreadClass.getMethod("currentApplication");
    return (Application) method.invoke(null, (Object[]) null);
} catch (final ClassNotFoundException e) {
    // handle exception
} catch (final NoSuchMethodException e) {
    // handle exception
} catch (final IllegalArgumentException e) {
    // handle exception
} catch (final IllegalAccessException e) {
    // handle exception
} catch (final InvocationTargetException e) {
    // handle exception
}

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

По-прежнему лучше использовать решение @RohitGhatol, если вы можете изменить код приложения.

Это зависит от того, для чего вы используете контекст. Я могу вспомнить хотя бы один недостаток этого метода:

Если вы пытаетесь создать AlertDialog с AlertDialog.Builder, Application контекст не будет работать. Я считаю, что вам нужен контекст для текущего _4 _...

Котлинский способ:

Манифест:

<application android:name="MyApplication">

</application>

MyApplication.kt

class MyApplication: Application() {

    override fun onCreate() {
        super.onCreate()
        instance = this
    }

    companion object {
        lateinit var instance: MyApplication
            private set
    }
}

Затем вы можете получить доступ к собственности через MyApplication.instance

Если вы готовы использовать RoboGuice, вы можете внедрить контекст в любой класс, который хотите . Вот небольшой пример того, как это сделать с помощью RoboGuice 2.0 (бета 4 на момент написания)

import android.content.Context;
import android.os.Build;
import roboguice.inject.ContextSingleton;

import javax.inject.Inject;

@ContextSingleton
public class DataManager {
    @Inject
    public DataManager(Context context) {
            Properties properties = new Properties();
            properties.load(context.getResources().getAssets().open("data.properties"));
        } catch (IOException e) {
        }
    }
}

Котлин

open class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        mInstance = this
    }

    companion object {
        lateinit var mInstance: MyApp
        fun getContext(): Context? {
            return mInstance.applicationContext
        }
    }
}

и получить Context как

MyApp.mInstance

or

MyApp.getContext()

Я когда-то использовал это:

ActivityThread at = ActivityThread.systemMain();
Context context = at.getSystemContext();

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

Но я использовал его только в модификациях фреймворка / базы и не пробовал в приложениях Android.

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

java.lang.SecurityException: данный пакет вызывающего абонента не работает в процессе ProcessRecord.

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

public class App {
    private static Context context;

    public static void setContext(Context cntxt) {
        context = cntxt;
    }

    public static Context getContext() {
        return context;
    }
}

И просто установите контекст, когда ваша деятельность (или действия) начинается:

// MainActivity

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Set Context
    App.setContext(getApplicationContext());

    // Other stuff
}

Примечание. Как и все другие ответы, это потенциальная утечка памяти.

в Kotlin при помещении контекста / контекста приложения в сопутствующий объект по-прежнему появляется предупреждение Do not place Android context classes in static fields; this is a memory leak (and also breaks Instant Run)

или если вы используете что-то вроде этого:

    companion object {
        lateinit var instance: MyApp
    }

Это просто обман, чтобы не обнаружить утечку памяти, экземпляр приложения по-прежнему может вызывать утечку памяти, поскольку класс приложения и его потомок являются контекстом.

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

Просто создайте класс объекта:

object CoreHelper {
    lateinit var contextGetter: () -> Context
}

или вы можете использовать его более безопасно, используя тип, допускающий значение NULL:

object CoreHelper {
    var contextGetter: (() -> Context)? = null
}

и в своем классе приложения добавьте эту строку:

class MyApp: Application() {

    override fun onCreate() {
        super.onCreate()
        CoreHelper.contextGetter = {
            this
        }
    }
}

и в своем манифесте объявите имя приложения . MyApp

    <application
            android:name=".MyApp"

Если вы хотите получить контекст, просто позвоните:

CoreHelper.contextGetter()

// or if you use the nullable version
CoreHelper.contextGetter?.invoke()

Надеюсь, это поможет.

Вы можете использовать следующее:

MainActivity.this.getApplicationContext();

MainActivity.java:

...
public class MainActivity ... {
    static MainActivity ma;
...
    public void onCreate(Bundle b) {
         super...
         ma=this;
         ...

Любой другой класс:

public ...
    public ANY_METHOD... {
         Context c = MainActivity.ma.getApplicationContext();

Согласно этот источник, вы можете получить свой собственный контекст, расширив ContextWrapper

public class SomeClass extends ContextWrapper {

    public SomeClass(Context base) {
      super(base);
    }

    public void someMethod() {
        // notice how I can use "this" for Context
        // this works because this class has it's own Context just like an Activity or Service
        startActivity(this, SomeRealActivity.class);

        //would require context too
        File cacheDir = getCacheDir();
    }
}

JavaDoc для ContextWrapper

Проксирующая реализация контекста, которая просто делегирует все свои вызовы другому контексту. Может быть разделен на подклассы для изменения поведения без изменения исходного контекста.

Думаю нужно тело для метода getAppContext():

public static Context getAppContext()
   return MyApplication.context; 

Я только что выпустил основанный на jQuery фреймворк для Android под названием Vapor API, который призван упростить разработку приложений.

Центральный $ класс фасада поддерживает _ 2_ (ссылка на потрясающее сообщение в блоге Java об этом, написанное Итаном Николасом) в текущий Activity контекст, который вы можете получить, позвонив :

$.act()

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

Обратной стороной, конечно же, является то, что вы рискуете, что $.act() может вернуть null. Я еще не сталкивался с этим сценарием, так что, возможно, это минимальный риск, о котором стоит упомянуть.

Вы также можете установить контекст вручную, если вы не используете VaporActivity в качестве своего Activity класса:

$.act(Activity);

Кроме того, большая часть инфраструктуры Vapor API изначально использует этот сохраненный контекст, что может означать, что вам вообще не нужно хранить его самостоятельно. если вы решите использовать фреймворк. Посетите сайт для получения дополнительной информации и примеров.

Надеюсь, это поможет :)

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

public class GlobalAppContextSingleton {
    private static GlobalAppContextSingleton mInstance;
    private Context context;

    public static GlobalAppContextSingleton getInstance() {
        if (mInstance == null) mInstance = getSync();
        return mInstance;
    }

    private static synchronized GlobalAppContextSingleton getSync() {
        if (mInstance == null) mInstance = 
                new GlobalAppContextSingleton();
        return mInstance;
    }

    public void initialize(Context context) {
        this.context = context;
    }

    public Context getApplicationContext() {
        return context;
    }
}

затем инициализируйте его в классе приложения onCreate с помощью

GlobalAppContextSingleton.getInstance().initialize(this);

используйте его где угодно, позвонив

GlobalAppContextSingleton.getInstance().getApplicationContext()

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

Я использую вариант шаблона проектирования Singleton, чтобы помочь мне в этом.

import android.app.Activity;
import android.content.Context;

public class ApplicationContextSingleton {
    private static Activity gContext;

    public static void setContext( Activity activity) {
        gContext = activity;
    }

    public static Activity getActivity() {
        return gContext;
    }

    public static Context getContext() {
        return gContext;
    }
}

Затем я вызываю ApplicationContextSingleton.setContext( this ); в своем activity.onCreate () и ApplicationContextSingleton.setContext( null ); в onDestroy ();

Ответ Рохита кажется правильным. Однако имейте в виду, что, насколько мне известно, «Мгновенный запуск» AndroidStudio зависит от отсутствия атрибутов static Context в вашем коде.

Сегодня правильный способ получить context - это использовать внедрение зависимостей. Например, можно использовать Hilt для внедрения контекста в любом месте, где это необходимо. Допустим, нужно context в каком-то менеджере баз данных, тогда это можно решить следующим образом:

Добавьте рукоять в Gradle:

implementation "com.google.dagger:hilt-android:2.35"
kapt "com.google.dagger:hilt-android-compiler:2.35"

Определите класс Application с аннотацией @HiltAndroidApp (пусть он, например, внедрит менеджер баз данных):

@HiltAndroidApp
class MyApplication : Application() {

    @Inject
    lateinit var dbManager: DBManager

    override fun onCreate() {
        super.onCreate()
        dbManager.initDB()
    }
}

Определите диспетчер баз данных (пусть это тоже будет @Singleton):

@Singleton
class DBManager @Inject constructor(
    @ApplicationContext private val context: Context
) {

    fun initDB() {
        // context is avaiable
        databaseInit(context)
    }
}

Вот и все. DBManager может получить доступ к контексту правильным образом без утечек памяти.