Multipath Stream

[sudilacf]

I have set a stream in my setup:
Database.get(aClient, "/", asyncCB, true);

and I have this in my loop:

if(app.ready()) {
    
    if(getFormattedTime().equals(feedOn) && !getFormattedTime().equals(getLastFeedTime())) {

      if(Database.set<String>(aClient, "/feed/on", getFormattedTime(feedOffset))) {

        String push_key = addToHistory();
        if(!push_key.isEmpty()) {

          if(Database.set<String>(aClient, "/settings/push_key", push_key)) {
            
            feed();
            Serial.printf("time: %s\ntime2: %s\n", getFormattedTime().c_str(), feedOn.c_str());

          }

        }

      }

    }

  }

and this is in my callback which updates the value of feedOn from rtdb.

if(RTDB.dataPath().equals("/feed/on")) {
        
      feedOn = RTDB.to<String>();

 }

EXPLANATION:
If the time matched in my rtdb time data and the time is not added in history then it will set the feedOn to current time plus 1 hour and the time will add to history then feed() will be called. My problem is its looping because the feedOn value does not change which I expect that it will change in the callback after updating its value in the rtdb.

[mobizt]

Which device you are using?

Did you understand your device memory architecture?

Have you check your device free memory and estimate the size of your detabase data under the root (by export or download) and is it proper for your device to handle?

If you use ESP8266, do you understand how WiFiClientSecure library work?

And did you see this, and do you understand it?

FirebaseClient/examples/RealtimeDatabase/Async/Get/Get.ino

Lines 98 to 101 in edcb444

	#if defined(ESP32) || defined(ESP8266) || defined(PICO_RP2040)
	ssl_client.setInsecure();
	#if defined(ESP8266)
	ssl_client.setBufferSizes(4096, 1024);

[sudilacf]

Im using ESP32

[mobizt]

Nobody streams or listen to the data at the root even in web or the Firebase SDK client app that runs in mobile device that has unlimited memory.

You have to redesign your code and think of small data and speed.

I don't want to teach you but you have to learn by yourself.

You are actually new to Firebase.

Please keep in mine that Firebase does not design for embedded device.

Your device memory is limited and you have to manage.

[sudilacf]

Thanks I will optimize my code, sorry of many questions, Im new to embedded systems ><.

[mobizt]

Your device may have available memory nearly 200k that is large enough for your whole database data.

If you notice that, once the stream connected, all data under the streaming path will be received on the payload because it is actually the response from HTTP GET request.

After it was connected, the small data based on the database data changes called event-data will be received.

If the buffer (String object) that needed to store this response payload fail to allocate memory, the stream data to be processed will be invalid and stream operation will fail and run into unknown situation with no error.

You can check the maximum heap size that can be allocated in case heap fragmentation from dynamic memory allocation in the code or in library.

ESP.getMaxAllocHeap()

We cannot do this all the time to estimate how big of data to be streamed, then keep your stream data as small as possible and data that being stream should not grow up.

[sudilacf]

Okay sir.

[mobizt]

If you start the stream at the path "a/b/c" and the RTDB.dataPath() returns "d/e/f".

It means your data at the path "a/b/c/d/e/f" has changed.

[sudilacf]

Oh yeah I get it.

[sudilacf]

I figure it out now sir

I used the the same AsyncClientClass in my stream and Database.set<>() thats why my callback doesnt response. I changed my AClientClass in my stream and its working now

[mobizt]

From Readme

When user uses a async client for multiple tasks which included Realtime database get in SSE mode (HTTP Streaming), sync and async operations, the SSE mode (HTTP Streaming) will be interrupted (breaking the connection) because of the async client is only able to connect to the server via one TCP socket at a time.