applicationstate | Utility for maintaining stateful applications | Architecture library

I was able to figure it out. I needed to use the spread operator to get both actionCreators in my matchDispatchToProps

I changed this

I believe that I have solved your problem. This problem lies within your BlocConsumer widget.

The builder method of the BlocConsumer widget is called multiple times whenever the state of your AuthCubit changes. This results in myAuthBuildLoaded() pushing the page twice. That is what is causing the flickering effect. To avoid this, see the example below. The listener method of the BlocConsumer widget is only called once on every state change. That should revolve your problem.

You need to default state to your initialState.

navigationActions has to return List, but you are returning the result of Consumer which is a Widget. You can use other methods to get the ApplicationState. Here is example code which does what you want:

This did the trick, obviously..

In addition to the comments here a kind of answer:

Obviously we cannot know whether it's the case, but I'd say you are on the right track. From your description I assume here's what happens:

The scheduled task launches the app and no UI is build. iOS has not much to do, so it decides to let your app live in suspended mode instead of completely terminating it once the scheduled task is done. That's actually to be expected I'd say, as it would only terminate it if it's really starved for resources (I assume a suspended app takes next to nothing, memory is swapped to disk, no CPU cycles, so why completely terminate it?).

Then, at a later time, the user taps the app and it gets put into the foreground. Since it was suspended and not terminated didFinishLaunchingWithOptions is not called again (as it was already launched way earlier) and "oh noes" no UI is built.

So to concretely answer your Q1 (warning, opinionated!):

Well, the best practice to check the state is obviously okay in your implementation (the if check)... but: Building UI based on the state is not a good practice. As a matter of fact, "initiating" the UI build-up from code yourself is a bad idea in my opinion, in general. There's a reason why neither Swift(UI) apps nor UIKit & Storyboard-based apps do that. I know some people favor "doing the UI in code", but I disagree with that. The people who manage to do that well typically do not mean that too literal and there's a whole bunch of people out there who misinterpret that and have lines and lines of shoveling views into each other as a result. That turns inefficient, so solutions like yours pop up with the intent "Well, in background tasks we have to be fast, so let's just dupe that out", whereas the correct take-away should be "maybe we're doing something wrong with that tedious manual UI build up"...

So, how does that help you (as I guess you cannot completely redo all the UI stuff just to fix this bug)? Unfortunately, "it depends". The first thing I'd try is actually just omitting the state check for the UI, i.e. build it up regardless of whether the app is launched from background or not. Here's wishing that nothing in that process actually requires the app being visible on screen to successfully complete that. If that works, so what? The app then has a not-yet-shown UI while it executes the background task, but so what? It will be of use later, once the user gets it into the foreground anyway.

If that does not work, then try to move the UI building into didBecomeActive along with some check to ensure it's not "rebuild" in the case the app already has executed that code. It might be worthwhile to openly question this entire UI approach in your team.

About question 2:

This is a hard and flaky thing I guess...

As explained in the comments, the trick to debug this to prepare the debugger for an app start that is not initiated by Xcode, but the scheduled BG task. That means two things:

1. You must somehow schedule a task to a more or less known point in the future. This most likely requires you to add some debug code (unless you want to stay up late for the nightly scheduled real tasks... only to miss it). Just schedule one from within didFinishLaunchingWithOptions to be run in a minute or so. Now, I know you don't get a guarantee that it's executed then, but I don't see another way for now. I haven't tried this myself and if it doesn't work, erm... you're probably out of luck (or have to wait for quite a while for a task to be actually called).
2. Start the app so the task gets scheduled, then immediately terminate the app again before the targeted time passes.
3. Change the Xcode scheme. "Run - Info - Launch" to "Wait for the executable to be launched". Press the run button. The debugger now waits for the app to be launched by some other means. Unless you tap the icon yourself, that will hopefully be the scheduled task.

By the way, Apple has a specific how to to help you with debugging BG tasks, but that looks like it won't actually terminate your app in between scheduling it and launching the task handler (so didFinishLaunchingWithOptions wouldn't be called in the way you need). You may want to investigate this yourself, though (this answer is long enough as it is... sorry for that).

Update as I am an idiot:

While all the above may be useful, I kind of lost sight of what you actually want to test: Whether that UI setup based on the state is responsible for the problem. There's a way to confirm that by kind of "injecting" the state via launch parameters. You need to minimally change your didFinishLaunchingWithOptions implementation and mess around a bit with your app scheme, but it should do the trick:

1. Give your app scheme a custom launch argument, e.g. "fakeBGState". To do so, edit the scheme, go to "Run - Arguments" and add that string under "Arguments Passed On Launch".
2. In your didFinishLaunchingWithOptions, wrap your UI set up code into

If your selectors relate to only one slice then they don't need to know about the entire state. They just need to know about the type of their slice's state and know to extract that state from the entire app state.

Using the counter example from the docs, the key is that if we are adding all slices as top-level reducers (not nested) then we know the app state fulfills {counter: CounterState} and we don't care about any other slices or what their states are.

There are a few patterns that I have used to implement this. The one that I like the best at the moment is to define the selectors for a particular slice such that they just select from their own slice state. Obviously you cannot call useSelector with that selector, so I create a custom hook for each slice. That hook can actually live in the folder of that slice.

I think the simplest solution is to return the auth object from 'storeAuthToken' as it keeps the error handling and result in the same logical flow, and it fixes the asynchronous issue identified in the comments.

You can use the following code to extract both title and body from userInfo dictionary: