java.lang.RuntimeException:无法启动接收器xx.xx.imediatesssreceiver:java.lang.IllegalArgumentException:上下文不能为null

在这篇文章之前，我先环顾四周寻找这个问题，我想我没有得到一个适用于我的答案。所以我要说：

我正在开发一个Android应用程序，它应该可以接收短信，并使用短信服务器做各种事情。该应用程序总体上运行良好，但每次用户关闭应用程序或重新启动手机并在打开应用程序之前收到相关短信时，它都会崩溃，并发出消息“不幸的是，Appname已停止”。请帮助-下面是我的接收者类、Logcat和清单文件的一部分

高级班

public class Prefs {

    static Prefs singleton = null;

    static SharedPreferences preferences;

    static SharedPreferences.Editor editor;

    Prefs(Context context) {
        preferences = PreferenceManager.getDefaultSharedPreferences(context);
        editor = preferences.edit();
    }

    Prefs(Context context, String name, int mode) {
        preferences = context.getSharedPreferences(name, mode);
        editor = preferences.edit();
    }

    public static Prefs with(Context context) {
        if (singleton == null) {
            singleton = new Builder(context, null, -1).build();
        }
        return singleton;
    }

    public static Prefs with(Context context, String name, int mode) {
        if (singleton == null) {
            singleton = new Builder(context, name, mode).build();
        }
        return singleton;
    }

    public void save(String key, boolean value) {
        editor.putBoolean(key, value).apply();
    }

    public void save(String key, String value) {
        editor.putString(key, value).apply();
    }

    public void save(String key, int value) {
        editor.putInt(key, value).apply();
    }

    public void save(String key, float value) {
        editor.putFloat(key, value).apply();
    }

    public void save(String key, long value) {
        editor.putLong(key, value).apply();
    }

    public void save(String key, Set<String> value) {
        editor.putStringSet(key, value).apply();
    }

    public boolean getBoolean(String key, boolean defValue) {
        return preferences.getBoolean(key, defValue);
    }

    public String getString(String key, String defValue) {
        return preferences.getString(key, defValue);
    }

    public int getInt(String key, int defValue) {
        return preferences.getInt(key, defValue);
    }

    public float getFloat(String key, float defValue) {
        return preferences.getFloat(key, defValue);
    }

    public long getLong(String key, long defValue) {
        return preferences.getLong(key, defValue);
    }

    public Set<String> getStringSet(String key, Set<String> defValue) {
        return preferences.getStringSet(key, defValue);
    }

    public Map<String, ?> getAll() {
        return preferences.getAll();
    }

    public void remove(String key) {
        editor.remove(key).apply();
    }

    public void removeAll(){
        editor.clear().apply();
    }

    public void contains(String key){
        preferences.contains(key);
    }

    private static class Builder {

        private final Context context;
        private final int mode;
        private final String name;

        public Builder(Context context, String name, int mode) {
            if (context == null) {
                throw new IllegalArgumentException("Context must not be null.");
            }
            this.context = context.getApplicationContext();
            this.name = name;
            this.mode = mode;
        }

        /**
        * Method that creates an instance of Prefs
        *
        * @return an instance of Prefs
        */
        public Prefs build() {
            if (mode == -1 || name == null) {
                return new Prefs(context);
            }
            return new Prefs(context, name, mode);
        }
    }
}

公共类Prefs{
静态Prefs singleton=null；
静态共享参考偏好；
静态SharedReferences.Editor；
Prefs（上下文）{
preferences=PreferenceManager.GetDefaultSharedReferences（上下文）；
editor=preferences.edit（）；
}
Prefs（上下文、字符串名称、int模式）{
首选项=context.getSharedReferences（名称、模式）；
editor=preferences.edit（）；
}
具有（上下文）的公共静态首选项{
if（singleton==null）{
singleton=newbuilder（上下文，null，-1）.build（）；
}
返回单身；
}
具有（上下文上下文、字符串名称、int模式）的公共静态前缀{
if（singleton==null）{
singleton=新构建器（上下文、名称、模式）.build（）；
}
返回单身；
}
公共void保存（字符串键，布尔值）{
putBoolean（键，值）.apply（）；
}
公共void保存（字符串键、字符串值）{
putString（键，值）.apply（）；
}
公共void保存（字符串键，int值）{
editor.putInt（键，值）.apply（）；
}
公共void保存（字符串键、浮点值）{
putFloat（键，值）.apply（）；
}
公共作废保存（字符串键，长值）{
editor.putLong（键，值）.apply（）；
}
公共作废保存（字符串键，设置值）{
putStringSet（键，值）.apply（）；
}
公共布尔getBoolean（字符串键，布尔值）{
返回preferences.getBoolean（key，defValue）；
}
公共字符串getString（字符串键、字符串值）{
返回preferences.getString（key，defValue）；
}
公共int-getInt（字符串键，int-defValue）{
返回preferences.getInt（key，defValue）；
}
公共浮点getFloat（字符串键，浮点值）{
返回preferences.getFloat（key，defValue）；
}
公共long getLong（字符串键，long defValue）{
返回preferences.getLong（key，defValue）；
}
公共集合getStringSet（字符串键，集合定义值）{
返回preferences.getStringSet（key，defValue）；
}
公共地图getAll（）{
返回preferences.getAll（）；
}
公共无效删除（字符串键）{
editor.remove（key.apply（）；
}
公共无效删除所有（）{
editor.clear（）.apply（）；
}
公共void包含（字符串键）{
包含（键）；
}
私有静态类生成器{
私人最终语境；
私有最终int模式；
私有最终字符串名；
公共生成器（上下文、字符串名称、int模式）{
if（上下文==null）{
抛出新的IllegalArgumentException（“上下文不能为null”）；
}
this.context=context.getApplicationContext（）；
this.name=名称；
这个模式=模式；
}
/**
*方法，该方法创建Prefs的实例
*
*@return一个Prefs实例
*/
公共Prefs build（）{
如果（模式==-1 | |名称==null）{
返回新的Prefs（上下文）；
}
返回新的Prefs（上下文、名称、模式）；
}
}
}

短信接收类

public class ImediateSMSReceiver extends BroadcastReceiver {
    private static final String TAG = ImediateSMSReceiver.class.getSimpleName();

    String amount = "";
    String merch = "";
    String ref = "";
    String date = "";
    String time = "";
    String account = "";
    String balance = "";

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.e(TAG, "Running onReceive from " + TAG);

        if (intent.hasExtra("pdus")) {
            Bundle bundle = intent.getExtras();
            Object messages[] = (Object[]) bundle.get("pdus");
            if (messages != null && !messages.equals("")) {
                SmsMessage smsMessage[] = new SmsMessage[messages.length];
                for (int n = 0; n < messages.length; n++) {
                    smsMessage[n] = SmsMessage.createFromPdu((byte[]) messages[n]);
                }

                Log.e(TAG, "Current Number of Messages Length " + messages.length);

                TemplateReader reader = new TemplateReader(context);
                String message = smsMessage[0].getMessageBody();

                long id = reader.read(message, new Date());
                if (id != 0) {
                    NotificationManager notificationManager = new NotificationManager();
                    notificationManager.SendTransactionNotification(context, (int) id,
                            TransactionFragment.class.getName(), message);
                }
                Log.e(TAG, "Message is " + messages);

            } else {
                Log.e(TAG, "Message is NULL");
            }
        }
    }
}

公共类ImediateSMSReceiver扩展了BroadcastReceiver{
私有静态最终字符串标记=ImediateSMSReceiver.class.getSimpleName（）；
字符串金额=”；
字符串merch=“”；
字符串ref=“”；
字符串日期=”；
字符串时间=”；
字符串帐户=”；
字符串余额=”；
@凌驾
公共void onReceive（上下文、意图）{
Log.e（标签，“从“+标签”接收运行）；
如果（意图额外（“PDU”））{
Bundle=intent.getExtras（）；
对象消息[]=（对象[]）bundle.get（“PDU”）；
if（messages！=null&&！messages.equals（“”）{
SmsMessage SmsMessage[]=新SmsMessage[messages.length]；
对于（int n=0；n

LOGCAT

10-29 12:11:24.747: D/AssetManager(25433): addAssetPath path =/data/app/xx.xx.appname-1/base.apkmapset is 0
10-29 12:11:24.747: D/AssetManager(25433): addAssetPath path =/data/app/xx.xx.appname-1/base.apk, mapOffset =0
10-29 12:11:24.747: D/AssetManager(25433): addAssetPath path =/data/app/xx.xx.appname-1/base.apk,elasticAppCookieOffset ={3=0}
10-29 12:11:24.837: D/InjectionManager(25433): fillFeatureStoreMap xx.xx.appname
10-29 12:11:24.837: I/InjectionManager(25433): Constructor xx.xx.appname, Feature store :{}
10-29 12:11:24.837: I/LoadedApk(25433): getClassLoader :dalvik.system.PathClassLoader[DexPathList[[zip file "/data/app/xx.xx.appname/base.apk"],nativeLibraryDirectories=[/vendor/lib64, /system/lib64]]]
10-29 12:11:24.887: E/AndroidRuntime(25433): Process: xx.xx.appname, PID: 25433
10-29 12:11:24.887: E/AndroidRuntime(25433): java.lang.RuntimeException: Unable to start receiver xx.xx.appname.util.ImediateSMSReceiver: java.lang.IllegalArgumentException: Context must not be null.
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.xtras.Prefs$Builder.<init>(Prefs.java:115)
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.xtras.Prefs.with(Prefs.java:31)
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.util.TemplateReader.createAccountInDB(TemplateReader.java:676)
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.util.TemplateReader.createTransactionInDB(TemplateReader.java:522)
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.util.TemplateReader.createTransaction(TemplateReader.java:500)
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.util.TemplateReader.read(TemplateReader.java:441)
10-29 12:11:24.887: E/AndroidRuntime(25433):    at xx.xx.appname.util.ImediateSMSReceiver.onReceive(ImediateSMSReceiver.java:56)

10-29 12:11:24.747:D/AssetManager（25433）：addAssetPath路径=/data/app/xx.xx.appname-1/base.apkmapset为0
10-29 12:11:24.747:D/AssetManager（25433）：addAssetPath路径=/data/app/xx.xx.appname-1/base.apk，mapOffset=0
10-29 12:11:24.747:D/AssetManager（25433）：addAssetPath路径=/data/app/xx.xx.appname-1/base.apk，elasticAppCookieOffset={3=0}
10-29 12:11:24.837:D/注射经理(
<receiver
android:name=".util.ImediateSMSReceiver"
android:enabled="true" >
<intent-filter>
<action android:name="android.provider.Telephony.SMS_RECEIVED" />
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="android.intent.action.USER_PRESENT" />
</intent-filter>
</receiver>