Dagger 2 Activity 停止时保存和恢复状态

Question

我陷入了僵局。我正在使用 Dagger 2 进行依赖注入，但是当应用程序进入后台时我会丢失状态。这是场景：应用程序启动并创建依赖项。只要应用程序保持在前台，一切都会完美运行。但是，有一种情况是应用程序必须进入后台。当它回来时，存储在我注入的一个类中的值会丢失。

对于我自己没有依赖项的注入类，一切似乎都可以正确恢复。但是，有一个注入类具有注入依赖项，这是一个无法恢复的类。这是我的设置方式：

AppComponent.java

@Singleton
@Component(
    modules = {
        AppModule.class
    }
)

public interface AppComponent {

    SessionKeyExchangerService provideSessionKeyExchangerService();
    AESCipherService provideCipherService();

    void inject(LoginActivity loginActivity);
}

AppModule.java

@Module
public class AppModule {

    @Provides @Singleton
    AESCipherService provideCipherService() {
        return new AESCipherService();
    }

    @Provides @Singleton
    SessionKeyExchangerService provideSessionKeyExchangerService(AESCipherService service) {
        return new SessionKeyExchangerService(service);
    }
}

然后当我去注入这些依赖项时，我会这样做：

LoginActivity.java

@Inject 
SessionKeyExchangerService sessionKeyExchangerService;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_login);

    Injector.INSTANCE.getAppComponent().inject(this);

    if (savedInstanceState != null) {
        sessionKeyExchangerService = savedInstanceState.getParcelable(SESSION_KEY_PARCEL);
        Log.d(Constants.TAG, "session key retrieved in on create: " + sessionKeyExchangerService.getCipherService().getBase64EncodedSessionKey());
    }
}

所以，我的基本问题是如何维护 Dagger 2 注入类的状态。我很乐意分享更多代码，但这是基本理念。

感谢您的帮助。

编辑 假设我上面所做的一切正常，让我继续讨论如何保存和检索存储在这些注入对象中的值。这将表明某处存在问题。

当我进入后台，然后返回时，我可以看到我得到了一个新的 PID。我还可以看到我能够在 LoginActivity 类中正确地存储和检索注入的值。然而，其他也引用了注入值的类现在有不同的值，这意味着它们的引用指向不同的内存位置，对吧？

我对哪里出错的最佳猜测是在 LoginActivity onCreate 中，我正在从保存的包裹中恢复 sessionKeyExchangerService 值。我认为我正在创建在应用程序中未被识别为注入依赖项的新值，但我不知道为什么这是错误的或如何修复它。

这段代码也在LoginActivity.java中：

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putParcelable(SESSION_KEY_PARCEL, sessionKeyExchangerService);
    Log.d(Constants.TAG, "session key saved: " + sessionKeyExchangerService.getCipherService().getBase64EncodedSessionKey());
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    sessionKeyExchangerService = savedInstanceState.getParcelable(SESSION_KEY_PARCEL);
    Log.d(Constants.TAG, "session key retrieved in on restore state: " + sessionKeyExchangerService.getCipherService().getBase64EncodedSessionKey());
}

这是说明问题的控制台输出。注意 1）在调用onStop() 之后 PID 如何变化，以及 2）Authenticator 类（引用了AESCipherService）如何具有不同的会话键值：

1398-1398/com.mysite.myapp D/MYTAG：保存实例状态
1398-1398/com.mysite.myapp D/MYTAG：保存会话密钥： 93Zuy8B3eos+eCfBQk9ErA==
1398-1398/com.mysite.myapp D/MYTAG：开 停止
3562-3562/com.mysite.myapp D/MYTAG：检索到的会话密钥 创建时：93Zuy8B3eos+eCfBQk9ErA==
3562-3562/com.mysite.myapp D/MYTAG：开始
3562-3562/com.mysite.myapp D/MYTAG：会话密钥 在恢复状态中检索到：93Zuy8B3eos+eCfBQk9ErA==
3562-3562/com.mysite.myapp D/MYTAG：验证器类说 会话密钥是：28HwdRCjBqH3uFweEAGCdg==

SessionKeyExchangerService.java

protected SessionKeyExchangerService(Parcel in) {
        notifyOn = in.readString();
        sessionKeyExchangeAttempts = in.readInt();
        MAX_SESSION_KEY_EXCHANGE_ATTEMPTS = in.readInt();
        sessionKeyExchangeHasFailed = (in.readByte() == 1);
        cipherService = in.readParcelable(AESCipherService.class.getClassLoader());
    }

    public static final Creator<SessionKeyExchangerService> CREATOR = new Creator<SessionKeyExchangerService>() {
        @Override
        public SessionKeyExchangerService createFromParcel(Parcel in) {
            return new SessionKeyExchangerService(in);
        }

        @Override
        public SessionKeyExchangerService[] newArray(int size) {
            return new SessionKeyExchangerService[size];
        }
    };

@Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(notifyOn);
        dest.writeInt(sessionKeyExchangeAttempts);
        dest.writeInt(MAX_SESSION_KEY_EXCHANGE_ATTEMPTS);
        dest.writeByte((byte) (hasSessionKeyExchangeFailed() ? 1 : 0));
        dest.writeParcelable(cipherService, flags);
    }

AESCipherService.java

protected AESCipherService(Parcel in) {
    sessionKeyBytes = in.createByteArray();
    ivBytes = in.createByteArray();
    sessionId = in.readLong();
    mIsSessionKeyEstablished = (in.readByte() == 1);
    verbose = (in.readByte() == 1);
}

public static final Creator<AESCipherService> CREATOR = new Creator<AESCipherService>() {
    @Override
    public AESCipherService createFromParcel(Parcel in) {
        return new AESCipherService(in);
    }

    @Override
    public AESCipherService[] newArray(int size) {
        return new AESCipherService[size];
    }
};

@Override
public void writeToParcel(Parcel dest, int flags) {
    dest.writeByteArray(sessionKeyBytes);
    dest.writeByteArray(ivBytes);
    dest.writeLong(sessionId);
    dest.writeByte((byte) (isSessionKeyEstablished() ? 1 : 0));
    dest.writeByte((byte) (verbose ? 1 : 0 ));
}

Answer 1

注入值意味着您不会自己分配值。这就是说，

@Inject 
SessionKeyExchangerService sessionKeyExchangerService;

// then in onCreate() after the injection
sessionKeyExchangerService = savedInstanceState.getParcelable(SESSION_KEY_PARCEL);

不是你想做的。

如果您的 SessionKeyExchangerService 依赖于某些已保存的状态，则必须将其传递到您的模块中。

AppModule 似乎是提供SessionKeyExchangerService 的错误位置。你可能应该外包给一些SessionModule，然后你可以交换，我认为是well explained here。在此示例中，UserModule 生命周期由应用程序管理，而不是 dagger。

通过为模块提供构造函数，您可以从savedInstanceState 传入Parcelable 状态。

在不了解整个项目的情况下，我认为您可以大大降低复杂性，并且可能不应该在活动中保存状态，而是使用SharedPreferences 或普通文件。这也将消除使用您的活动状态维护模块生命周期的需要。