observer | Golang event emitter and listener with builtin file watcher | Pub Sub library

I found out that the problem was the rewire lib. For some reason, it was messing with the window's events. I remove it and change my code to be able to mock data variable without rewire

Your question is similar to this question, so the answers there apply here too.

A static nested class has a flag that can be checked:

Try to use PublishSubject, seems like it was created for cases like yours.

Unfortunately, this is not the answer to your problems:

I need a solution to ...

Avoid calling onViewCreated codes again.

Avoid triggering LiveData observer again.

I'm trying to explain about navigation and its behaviors or correct some misunderstandings. These issues have different reasons and Avoid calling onViewCreated codes again. is a devious way.

I know onViewCreated will call again because Navigation Component replaces the fragments instead of adding them.

As you know, replacing fragments when they were added in back-stack, just detaching old fragment from fragmentManager. It means the old fragment's view will destroy.

And will create its view when you pop UnitFragment from the back-stack.

So don't call any API call in onViewCreated because it may call multiple times (in configuration changes, destroying fragment, etc...)

It's better to use onCreate for initializing non-view-related components (ViewModel + API calls). It reduces Lazy(!?) Initialization check.

When you attach to a C++ program with a debugger and halt execution, one thing that is relatively easy to do (with some compile-time instrumentation) is work out the call stack of the code at a given point.

In general, the implementation of C++ is that the call stack is a linked list (possibly stored in a non-trivial way), where when you return from a function you jump to the spot the caller injected when it called you.

Those addresses can be decoded by the debugger, then the instruction locations can be mapped back to C++ source locations, and a pretty-print of how you got to this line of code can be generated. Depending on the optimization settings this information can sometimes be inaccurate, missing some frames, or complete nonsense; but it is very useful.

Even without the compile-time instrumentation, the chain of instruction pointers can be saved, and then someone with the compile-time instrumentation can decode it pretty well.

There are libraries that let C++ programs do this internally, without an external debugger. These include boost stacktrace's library.

This is adding that capability to the std library.

A stack trace is a chain of frames, and the frames can be mapped to source file, function name and line number information by this new piece of the standard library.

A typical use case might be to catch situations where the program is behaving in invalid ways in the C++ source code and generate a log to report it happening before you attempt to recover, or just do an exit. Then programmers can look at this stack trace and get information about how to fix that bug.

I found the culprit of the strange delay. I was passing a boolean as the second argument in the slideTo function instead of an integer, which is the correct type for it.

You must change the line:

swiper.slideTo( slideno + 1, false, false );

to:

swiper.slideTo( slideno + 1, 0, false );

To answer your question "So how do I subscribe to things now": https://rxjs-dev.firebaseapp.com/guide/observer This is it. It is easy to use and pretty similar to what has been done before with the small change that it actually now accepts an object (observer) with 3 keys: next, error, complete.

We had the same discussion like 2 days ago at work and altough you can/should use the observer the deprecation seems to be a false alarm. (We thought we had to change ~900 subscribes):

This is an issue created on the rxjs github page regarding this issue: https://github.com/ReactiveX/rxjs/issues/6060

And in it the devs say it is due to a typescript bug: https://github.com/microsoft/TypeScript/issues/43053

This bug already has been fixed 3 days ago, i am not sure though if it is already in the newest release:

https://github.com/microsoft/TypeScript/pull/43165

You have 1000 GridItem components which are all getting the same callback ref setRefs. They all receive the same value of inView even though we know that at any given time some are in view and others are not. What ends up happening is that each items overwrites the previously set ref such that all 1000 items receive a boolean inView that represents whether the last item in the list is in view -- not whether it is itself in view.

In order to know whether each individual component is in view or not, we need to use the useInView hook separately for each element in the list. We can move the code for each item into its own component. We need to pass this component its number ix and the options for the useInView hook (we could also just pass down the root ref and create the options object here).

I finally resolved my problem. Indeed I'm using Koin for dependency injection. I simply replaced single: