toasts | Get desktop notifications from programming websites | Notification library

You are updating keys infinitely, I just added a condition to show you where the loop is

Issue resolved When I changed firebase code

from:-

EDIT 2022/2/28:
I have found a more elegant solution to this problem involving WTSQueryToken() and GetTokenInformation() thanks to this SO answer.

WTSQueryToken() returns a filtered user token, and without any extra steps, this token can be placed into a CreateProcessAsUserW() call to spawn my notification app.

I opt to call GetTokenInformation() to obtain the unfiltered (read: elevated) token for the user, which allows me to keep all my application's logs centralized in the Program Files directory. I am unclear if a process launched with an unfiltered token of a user without admin privileges will still be able to log to the Program Files directory, but this is non-essential to the process's ability to run.

SOLUTION:
The error message given for the thrown exception is Access is denied. This may or may not be the result of a bug related to the PROC_THREAD_ATTRIBUTE_PARENT_PROCESS flag. The workaround for this is simply to spawn the process again from the child process, using the exact same function call minus the problematic flag.

In my case, I pass a parameter that acts as a flag to tell the child process that it needs to relaunch itself.

EXPLANATION:
Thanks to the guidance of @IInspectable, I was able to resolve my issue.

Firstly, IInspectable informed me that the exception's data type was likely that of a winrt::hresult_error, which ended up being correct. From this, I was able to see that the exception message was Access is denied.

After updating my question to reflect this, IInspectable returned to point me towards the bottom of the comments of the Raymond Chen blog post that I linked in my question.

In short, the comment suggests that there is an underlying bug in the API that causes processes spawned in the way demonstrated by Chen to load with incorrect parameters, and offers a simple workaround by using Chen's function from within the child process to launch another child process. The comment also suggests that removing the PROC_THREAD_ATTRIBUTE_PARENT_PROCESS flag from the second function call is necessary, but this is not something I needed to do for the workaround to succeed.

For posterity, the comment from the blog post comments is as follows:

There are issues using the PROC_THREAD_ATTRIBUTE_PARENT_PROCESS flag… Environment variables for the new process are copied from the High-IL process not the Medium-IL process which cause issues with shell functions and some directory paths (%temp%, %userprofile% etc…) The token security descriptor for the process is also created without an ACE for the current user blocking access to most resources and the token security descriptor will also have a High-IL even though the process itself has a Medium-IL… This blocks the new process from accessing any system objects (events/pipes/sections/IPC etc…) while also blocking the process from opening its own process token with TOKEN_QUERY access. This seems to be a severe bug with the API but not sure if it’ll be fixed. As a workaround you can call CreateProcess a second time but from the new child process (without the PARENT_PROCESS flag) and it’ll be created with the correct token DAC security and environment variables (this is also why the above above sample doesn’t have issues with cmd.exe since it launches child processes).

A very simple and generally used method is to make the submit button be disabled until you get a response back from your API. So, for example:

Create a state:

You can create a wrapper service and override the default values.

Like @gpunto says, you're adding a new Observer every click, so they're stacking up and each one fires when the LiveData updates.

But really, the observer doesn't have anything to do with the actual click anyway, it just receives updates to signInResponse and displays a thing. The click just calls getAuthToken with the current query. If doing that happens to cause a signInResponse update, then you have everything wired up to react to that event. But the Activity doesn't need to know how all that stuff works, or be written so one thing follows another.

That's a reactive pattern, where your UI is really just sending events (like getAuthToken when there's a click) and then reacting to other events so it can display them. By separating these things, you get a simple system that Just Works, and can react to updates no matter what caused them (e.g. a click, or restoring state) without having to write code to handle each case.

That said, this is a slightly tricky case because you have an event you want to consume. If you just set up that observer on signInResponse, it will fire every time you get a value for that LiveData. And that includes when the Activity is recreated (e.g. on rotation), observes the LiveData, and gets the current (last-set) value. Basically, if you show a Toast, the same Toast will appear every time the Activity is recreated. That would be fine for setting the current value on a TextView, but it's bad for a popup that should only appear once.

This is the current official recommendation for handling this situation. They're creating a UI state, which basically holds everything that needs to be displayed, including any popup messages (which acts like a queue, which is useful!). When the UI displays a message, it basically tells the ViewModel it's done so, and that handles removing the message from the state.

You could just implement this your own way, even if it's something simple like a clearResponse() function in your VM that clears the current value when you've seen it. It really depends on your app and what state you need to maintain. Here's some other examples from the Android devs - but like it says at the top, this advice is deprecated following the recommendations I linked earlier

Honestly I'm a bit confused, I think I understand what you are trying to do but it doesn't have to be this complicated.

You should wrap your entire app with a ToastContainer or ToastContext (whatever you want to call it) and import your toast whenever needed then call Toat.show("Error: ..."). Checkout the library react-toastify for more details, maybe this library could help you. You wrap your project at the app entry level and never have to worry about it again.

As far as error handling, when creating a function to fetch data you should expect one error at a time and handle it appropriately. I personally think it's best to return the error to the original component that called the fetch function and handle it there. It's easier to keep track of things this way in my opinion, but what you're doing is not wrong.

Error handling takes time and thinking ahead, I'm not gonna deny it, but it makes a big different between a badly constructed app and a well thought out app.

I'm also not completely sure why you are using const isFetching = useRef(false); when you could just use const [isFetching, setIsFecthing] = useState(false), this is what useState is for. Same for useMemo. I think things could be leaner here, as you app grows and becomes more complex it'd easier to maintain.

I tried your code with bootstrap v4 and it works perfectly. I think you are using boostrap v5 but it's not compatible with vue-bootstrap version 2.21.2. So try to downgrade bootstrap version of your project.

Please see this codesandbox.

It seems it is either a string or a number: