上下文或活动之外的 getString

Question

我发现 R.string 非常适合将硬编码字符串保留在我的代码之外，并且我希望继续在实用程序类中使用它，该实用程序类与我的应用程序中的模型配合使用以生成输出。例如，在本例中，我从活动之外的模型生成一封电子邮件。

是否可以在 Context 或 Activity 之外使用 getString？我想我可以通过当前的活动，但这似乎没有必要。如果我错了请纠正我！

编辑：我们可以在不使用Context的情况下访问资源吗？

Answer 1

是的，我们可以在不使用“Context”的情况下访问资源

使用：

Resources.getSystem().getString(android.R.string.somecommonstuff)

。您可以在应用程序中的任何地方 ...，甚至在静态常量声明中。
不幸的是，它仅支持系统资源。

对于本地资源，请使用此解决方案。这不是微不足道的，但它确实有效。

Answer 2

不幸的是，访问任何字符串资源的唯一方法是使用Context（即Activity或Service）。在这种情况下，我通常所做的就是简单地要求调用者传递上下文。

Answer 3

在 MyApplication 中，它扩展了 Application：

public static Resources resources;

在 MyApplication 的 onCreate 中：

resources = getResources();

现在您可以在任何位置使用此字段您的申请。

Answer 4

##独特的方法

##App.getRes().getString(R.string.some_id)

这将在应用程序中的任何地方都有效。 （实用程序类、对话框、片段或
应用程序中的任何类）

(1) 创建或编辑（如果已存在）您的 Application 类。

import android.app.Application;
import android.content.res.Resources;

public class App extends Application {
    private static App mInstance;
    private static Resources res;


    @Override
    public void onCreate() {
        super.onCreate();
        mInstance = this;
        res = getResources();
    }

    public static App getInstance() {
        return mInstance;
    }

    public static Resources getRes() {
        return res;
    }

}

(2) 将名称字段添加到 manifest.xml 标记中。

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

现在你可以走了。在应用程序中的任何位置使用 App.getRes().getString(R.string.some_id) 。

Answer 5

顺便说一句，符号未找到错误的原因之一可能是您的IDE导入了android.R；类而不是你的类。只需将 import android.R; 更改为 import your.namespace.R;

因此，要使字符串在不同的类中可见，需要做两件事：

//make sure you are importing the right R class
import your.namespace.R;

//don't forget about the context
public void some_method(Context context) {
   context.getString(R.string.YOUR_STRING);
}

Answer 6

Khemraj 响应中的最佳方法：

应用程序类

class App : Application() {

    companion object {
        lateinit var instance: Application
        lateinit var resourses: Resources
    }


    // MARK: - Lifecycle

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

}

清单中的声明

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

常量类

class Localizations {

    companion object {
        val info = App.resourses.getString(R.string.info)
    }

}

使用

textView.text = Localizations.info

Answer 7

内部活动 :

Text(text = getString(android.R.string.yes))

内部非活动 :

Text(text = Resources.getSystem().getString(android.R.string.yes))

                          OR

Text(text = stringResource(android.R.string.yes))

Answer 8

如果您有一个在活动中使用的类，并且希望访问该类中的资源，我建议您将上下文定义为类中的私有变量，并在构造函数中对其进行初始化：

public class MyClass (){
    private Context context;

    public MyClass(Context context){
       this.context=context;
    }

    public testResource(){
       String s=context.getString(R.string.testString).toString();
    }
}

在活动中创建类的实例：

MyClass m=new MyClass(this);

Answer 9

您可以在 Kotlin 中执行此操作，方法是创建一个扩展 Application 的类，然后使用其上下文调用代码中任意位置的资源

您的 App 类将如下所示

 class App : Application() {
    override fun onCreate() {
        super.onCreate()
        context = this
    }

    companion object {
        var context: Context? = null
            private set
    }
}

在 AndroidManifest.xml 中声明您的 Application 类（非常重要）

<application
        android:allowBackup="true"
        android:name=".App" //<--Your declaration Here
        ...>
        <activity
            android:name=".SplashActivity"  android:theme="@style/SplashTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".MainActivity"/>
    </application>

要访问例如字符串文件，请使用以下代码

App.context?.resources?.getText(R.string.mystring)

Answer 10

遵循并基于 Khemraj Sharma 的答案，这是 Kotlin 版本，带有额外的扩展作为奖励：

class App: Application() {

    override fun onCreate() {
        super.onCreate()
        mInstance = this
        res = resources
    }
    companion object{

        private var mInstance: App? = null
        private var res: Resources? = null

        fun getInstance(): App? {
            return mInstance
        }

        fun getRes(): Resources? {
            return res
        }
    }
}

然后我们可以创建一个扩展：

fun Int.resourceToString(): String {
    return App.getRes()?.getString(this) ?: "Not Found"
}

并直接在任何资源 id 上使用扩展：

var asString = R.string.my_string.resourceToString()

Answer 11

这应该让您可以从任何地方访问 applicationContext ，从而让您可以在任何可以使用它的地方获取 applicationContext ； Toast、getString()、sharedPreferences 等。

Singleton：

package com.domain.packagename;

import android.content.Context;

/**
 * Created by Versa on 10.09.15.
 */
public class ApplicationContextSingleton {
    private static PrefsContextSingleton mInstance;
    private Context context;

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

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

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

    public Context getApplicationContext() {
        return context;
    }

}

在您的 Application 子类中初始化 Singleton：

package com.domain.packagename;

import android.app.Application;

/**
 * Created by Versa on 25.08.15.
 */
public class mApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        ApplicationContextSingleton.getInstance().initialize(this);
    }
}

如果我没有错，这给了你一个到 applicationContext 的钩子，用 ApplicationContextSingleton.getInstance.getApplicationContext(); 调用它
您不需要在任何时候清除它，因为当应用程序关闭时，它会随之消失。

请记住更新 AndroidManifest.xml 以使用此 Application 子类：

<?xml version="1.0" encoding="utf-8"?>

<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.domain.packagename"
    >

<application
    android:allowBackup="true"
    android:name=".mApplication" <!-- This is the important line -->
    android:label="@string/app_name"
    android:theme="@style/AppTheme"
    android:icon="@drawable/app_icon"
    >

如果您发现这里有任何问题，请告诉我，谢谢。 :)

Answer 12

如果您使用 Hilt，您实际上可以注入上下文：

@Module
@InstallIn(SingletonComponent::class)
interface ResourceProvider {

    companion object {
    
    @Provides
    @Singleton
    @MyQualifier
    fun providesBaseUrl(@ApplicationContext context: Context): String = with(context) {
      getString(R.string.my_value)
    }
  }
}

Answer 13

不知何故，我不喜欢存储静态值的黑客解决方案，因此想出了一个更长但也可以测试的干净版本。

找到了两种可能的方法 - 将

1. context.resources 作为参数传递给您想要字符串资源的类。相当简单。如果无法作为参数传递，请使用 setter。

例如

data class MyModel(val resources: Resources) {
    fun getNameString(): String {
        resources.getString(R.string.someString)
    }
}

2. 使用数据绑定（尽管需要片段/活动）

在阅读之前：此版本使用数据绑定

XML-

<?xml version="1.0" encoding="utf-8"?>

<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools">

<data>
    <variable
        name="someStringFetchedFromRes"
        type="String" />
</data>

<TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{someStringFetchedFromRes}" />
</layout>

活动/片段-

val binding = NameOfYourBinding.inflate(inflater)
binding.someStringFetchedFromRes = resources.getString(R.string.someStringFetchedFromRes)

有时，您需要根据模型中的字段更改文本。因此，您也可以对该模型进行数据绑定，并且由于您的活动/片段了解该模型，因此您可以很好地获取该值，然后基于该值对字符串进行数据绑定。

Answer 14

如果您想在上下文或活动之外使用 getString，您应该在构造函数或方法参数中具有上下文，以便您可以访问 getstring() 方法。
特别是在 Fragment 中，您应该确保 getActivity() 或 getContext() 不提供 null 值。
要避免 Fragment 中的 getActivity() 或 getContext() 为 null，请尝试以下操作：
声明一个变量：

Context mContext;

现在覆盖 Fragment 的 onAttach 和 onDetach 方法：

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    mContext = context;
}

@Override
public void onDetach() {
    super.onDetach();
    mContext = null;
}

现在无论您在哪里使用 getString() 方法，都使用 mContext 。
前任：

        Toast.makeText(mContext,  mContext.getString(R.string.sample_toast_from_string_file), Toast.LENGTH_SHORT).show();

Answer 15

要在没有上下文的情况下访问字符串资源，您可以创建一个单独的实用程序类并将应用程序上下文传递给它。下面是一个示例：

创建一个名为 ResourceUtils 的类：

   object ResourceUtils {
        private var applicationContext: Context? = null
    
        fun initialize(context: Context) {
            applicationContext = context.applicationContext
        }
    
        fun getString(resId: Int): String {
            applicationContext?.let {
                return it.resources.getString(resId)
            }
            throw IllegalStateException("ResourceUtils not initialized with application context")
        }
    }

在您的 Application 类中，使用应用程序上下文初始化 ResourceUtils：

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        ResourceUtils.initialize(this)
    }
}

现在，您可以使用 ResourceUtils.getString() 来访问没有上下文的字符串资源：

val appName = ResourceUtils.getString(R.string.app_name)

Answer 16

我用这段代码解决了这个问题

holder.btnAddFriend.setOnClickListener(v -> {
        // Obtener el nombre del usuario del elemento actual

        String username = user.getUsername();
        String id = v.getContext().getResources().getString(R.string.idusd);
 }

Answer 17

• AppCompatActivity
• 伴随对象

---

活动代码：

class MainActivity : AppCompatActivity() {

    companion object {
        lateinit var instance: AppCompatActivity
            private set
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        instance = this
    }
}

---

从 AnyWhere 获取资源：

val text = MainActivity.instance.getString(R.string.task_1)

Answer 18

我用过
getContext().getApplicationContext().getString(R.string.nameOfString);
这对我有用。