networkio | Modern C Networking Library | Networking library

Fixed getting raw bytes with following Code:

Your problem seems to be with the android:onClick the system is not finding the method and it's throwing an error because of it.

My hypothesis is that this is happening because you are running the app with proguard enabled, proguard may be changing the method name, and this will cause this exception.

I would advise using a click listener since it's considered to be bad practice to use the android:onClick

Cloud Run doesn't impose any limitations on what you can do with code in your docker container, as long as you don't exceed the limits of the virtual server instance. Your only obligation is to send a response to the client over the HTTP connection that's being managed. If you want to start threads, that's fine. Your chosen HTTP server is likely also doing that. Just bear in mind that the server instance running your container could be deallocated at any time when it's not serving a request, and your threads will be terminated immediately without notice.

App Engine is very different from Cloud Run in that it strictly manages the runtime behavior of the code you deploy. Cloud Run doesn't do that at all - you get to decide which JVM to use, which HTTP server to use, and how they operate in the container that you deploy.

In one word, yes. You need to Notify your Adapter that your Data has changed, which in this situation is Changing after you are querying your Database.

Also, as a suggestion, try looking into invalidate and notifyDataSetChanged of the Adapter Class.

Also, you can check out this Answer to know more about notifying the Adapter for Dataset Changes. But again, even if we are using Threads(), the code for notifying is executed in the UIThread, which is nothing but the Main thread.

Hope this solves your question.

Well, it's a bit strange idea to inject something that is a private implementation detail from outside using DI.

Also the solution in Dagger2 is a trick which actually works around the dependency injection.

So you need to do the decision: do I want it to be a private implemietation detail? If yes I would suggest to use a default parameter value and use injection only when you need to override this implementation e.g. for testing.

That's just structuring and assigning the right executor for the right jobs they might execute:

1. It's nicely put in a single class for easy reuse.
2. Three types of executors are employed, each for a specific type of task it could run. Remember that executors have threads to execute jobs or Runnables and each thread the executor creates can run one job at a time:
   • diskIO is (from the constrcutor) a Executors.newSingleThreadExecutor() since the tasks are best queued and executed one at a time to reduce write and read locks or race conditions for example. Hence a SingleThreadExecutor would run only one task at a time no matter how many are queued to ensure that design. Being a single thread could also mean that it's being used for writing app logs to a file for example which allows for the logs to be written in the proper order as being submitted to the executor. Hence single thread is best at maintaining output as in the order of jobs queued.
   • networkIO is a Executors.newFixedThreadPool(3) since the tasks are usually network related like connecting to a server on the internet and performing requests or getting data. These tasks usually make the user wait (could be between seconds to minutes) and need to be executed in parallel and fast to make the wait shorter in case many requests need be performed together. Hence the reason there are 3 threads employed with this executor is to assign the tasks among them and execute together. Order of jobs is not a concern here since jobs take different amount of time to execute but what matters the most is that they're running in parallel.
   • mainThread is a MainThreadExecutor() which in an Android app handles the UI and drawing it. The UI should function smoothly and not lag and hence the reason to use the above two executors is to let any heavy task (like writing a file or performing requests) to run in the background or separately from the mainThread of the app. This executor keeps performing tasks even if the app didn't submit any to it. The tasks it keeps performing is drawing the UI continuously on the screen which constantly repeats. Tasks executed by the mainThread need to lightweight and fast (time they take are in the order of milliseconds), and so any task that slows it down will be noticed as the UI will lag or glitch with it because the mainThread is busy finishing that task instead of drawing and updating the UI. The mainThread here simply uses a Handler which is part of the Android SDK/architecture, is of a single thread type and behaves like an executor (with some differences) that queues tasks to create/update the UI. Only a Handler can perform UI tasks, none of the other executors can.

Could you check this function in your code:

@TypeConverter public static Number toNumber(Integer integer){ return integer == null ? null : toNumber(integer); }

You have an infinite recursion going on here and maybe that's why you are getting the StackOverflowError.

It looks like you meant to type resource.data.author_id instead of resource.data.author_d in the rule.

It seems you have a few misconceptions.

Generally it is never OK to call network from the Main (UI) thread but unless you have a lot of data it might be OK to fetch data from DB in the Main thread. And this is what Google example does.

1.

The demo uses executors framework, and defines a fixed pool with 3 threads for networkIO, however in the demo only a worker task is defined for one call, i.e. the FetchNextSearchPageTask.

First of all, since Java 8 you can create simple implementation of some interfaces (so called "functional interfaces") using lambda syntax. This is what happens in the NetworkBoundResource: