logd | log & stats

%u is the wrong format specifier to use, since it corresponds to unsigned int, which on all relevant platforms is a 32-bit type. The value 1618460301601 requires at lest 64 bits, so you need to use %llu or %lld.

If you built your code for a 32-bit ABI (e.g. armeabi-v7a or x86) then using that incorrect %u specifier for the first argument will also mess up the printing of the other arguments, due to how printf-like function process their integer arguments.

Ideally, once you connect you should wait for the connection status, before you start asking for the list of profiles.

These are some code snippets you could use:

Device discovery

The actual cause, after discussions (in the comments of the question), is not because the memory allocation is too slow, but lie somewhere else - the calculations which will be heavy if the allocation is big.

For details, please refer to the comments and discussions of the question ;)

You are never initialising countersDatabase in CounterHolder, hence the NullPointerException.

This answer is the synthesis of the discussion we had in the comment section which eventually led to a solution.

Before we do anything in such a situation, it is vital to double-check whether there was some change after all that we did not see for some reason. It is important not to omit this double-check, because this does not take much time, while the systematic approach that leads to the solution involves a lot of effort. So, with this double-check we have a lot of potential gain with virtually no risk/cost. I personally use git as a version control system, but any system that is reliably showing such differences will do the job.

Seeing many not working image buttons looks overwhelming, we need to focus our research to a manageable and understandable problem-space. So, we need to choose one of the not working image buttons and find out why that does not work. If we are lucky, then solving that problem will either automatically solve the others, or give us some strong hints for the others. Naturally, we could have multiple very different problems, which off course means that we need to repeat the process outlined in this answer.

A very important hint is that not all the image buttons show this behavior, so we know that the problem is unlikely to be related to image buttons and it's more likely related to actions triggered by events on the image buttons.

Some debugging and logging is always helpful. Debugging shows us what happens, so if we do debug, we might find some bad behavior at some point which might well be the issue itself. If we do some logging, then we can see what happens while the program is running. We can do either or both.

In some cases there is no solution. For example a remotely working API might stop working, which is an unsolvable issue. In this case detecting this situation is vital. If there is no solution, then at least we need to find this out as quickly as possible, so we do not sweat on it too much.

Some steps towards the solution:

1. Reduce the problem space to a small, manageable size (and possibly provide more information into your question)
2. Define your problem well (Currently you link your problem to image buttons, but you are wrong to do so, since the fact that some image buttons work disproves the hypothesis that image buttons would work wrongly)
3. Look into the undivideable units of work, in your case the actions, choose one of them as a current focus and redefine the problem into an even smaller size)
4. Log and debug to collect information
5. From the list of the information you have collected plan a few experiments
6. Sequentially try all your hypotheses
7. If the solution is not yet found, then you might start all over from point 1. or you might decide to remove the action (temporarily) and gradually implement it back, until you either find what the problem is or accidentally solved it

I strongly suspect that this is because you haven't initialised sampleLengths so the values you're reading are actually just random pieces of memory which get changed during program execution.

C++ supports initialization of an int array to all zeros by doing:

By default, a livedata will emit to its current state (the value that exist on it) for any new observer that subscribes to it.

Answering your question, you might try the operator distincUntilChanged transformation, which, according to the documentation:

Creates a new LiveData object that does not emit a value until the source LiveData value has been changed. The value is considered changed if equals() yields false.

But, this showcases a problem with your snippet, and a bad practice that is common when using livedata, you shouldn't expose mutable live data to your observers. Instead, you should expose a non-mutable version of them.

In your case, in my opinion, your view model should look like the following:

To get this working you should avoid having underscores in the network name, use the fully qualified name for the config server and name the containers to get DNS working.

Create the network on a manager swarm host:

Unfortunately, the way you wrote your code won't always work. This is the classic case of an asynchronous task being run as a synchronous one.

The value of hasil is changed inside onFailure and onResponse which may not have a chance to finish before you return from the method authorize.

You need to change the way you're propagating the value of hasil to the calling code in order to be able to get this to work. There are several ways of doing so, one easy way without introducing too many changes to your code is to have a callback: