processRpc()

fl::json fl::Remote::processRpc

(

const fl::json &

request

)

Process JSON-RPC request (with optional "timestamp" field for scheduling) Returns JSON-RPC response: {"result": ...} or {"error": {...}}.

Definition at line 154 of file remote.cpp.hpp.

                                                            {
#if FL_PLATFORM_HAS_LARGE_MEMORY
    // Extract optional timestamp field (0 = immediate, >0 = scheduled).
    // Low-memory builds drop the scheduling path entirely (see #3224 Tier 1B):
    // the LPC8xx integer-only RPC contract is invoked immediate-only.
    u32 timestamp = 0;
    if (request.contains("timestamp") && request["timestamp"].is_int()) {
        timestamp = static_cast<u32>(request["timestamp"].as_int().value());
    }
#endif
 
    u32 receivedAt = fl::millis();
 
#if FL_PLATFORM_HAS_LARGE_MEMORY
    // Execute or schedule
    if (timestamp != 0) {
        // Scheduled execution - result will be pushed to ResponseSink after execution
        scheduleFunction(timestamp, receivedAt, request);
        FL_DBG("RPC: Scheduled function - result will be pushed after execution");
 
        // Return acknowledgment with null result and "scheduled" marker
        fl::json response = fl::json::object();
        if (request.contains("id")) {
            response.set("id", request["id"]);
        }
        response.set("result", fl::json(nullptr));
        response.set("scheduled", true);  // Marker to not queue this response
        return response;
    }
#endif
 
    // Immediate execution path (always reached on Low-memory).
 
#if FL_PLATFORM_HAS_LARGE_MEMORY
    // Store request ID BEFORE invoking function (needed for async functions).
    // This allows sendAsyncResponse() to find the request ID while function is
    // running. Low-memory drops the async-tracking machinery (no production
    // LowMemory sketch uses bindAsync / sendAsyncResponse today) -- see
    // #3224 Tier 1B.
    if (request.contains("id") && request.contains("method")) {
        fl::string methodName = request["method"].as_string().value_or("");
        int requestId = request["id"].as_int().value_or(0);
        mAsyncRequests[methodName] = {requestId, receivedAt};
        FL_DBG("Stored request ID for " << methodName.c_str() << " (id=" << requestId << ")");
    }
#endif
 
    // Immediate execution - pass directly to Rpc
    fl::json response = mRpc.handle(request);
 
#if FL_PLATFORM_HAS_LARGE_MEMORY
    // For async functions, response already sent via sendAsyncResponse().
    // Envelope marker names renamed in #3228 -- accept legacy `__async` for
    // one release of back-compat in case external Server forks set it.
    bool ackAlready = (response.contains("ackOnly") && response["ackOnly"].as_bool().value_or(false))
                  || (response.contains("__async") && response["__async"].as_bool().value_or(false));
    if (ackAlready) {
        // Don't return response (ACK already sent by Rpc).
        // Return a skip-envelope to prevent Server from queueing it.
        fl::json nullResponse = fl::json::object();
        nullResponse.set("noEnqueue", true);
        return nullResponse;
    }
 
    // For sync functions, remove request ID (not needed)
    if (request.contains("method")) {
        fl::string methodName = request["method"].as_string().value_or("");
        mAsyncRequests.erase(methodName);
    }
#endif
 
#if FL_PLATFORM_HAS_LARGE_MEMORY
    // Record result for the post-call results vector. LowMemory targets drop
    // mResults entirely (see #3224 Tier 1B) -- RPC callers there receive
    // results directly via the response sink, not through Remote::mResults.
    if (response.contains("result") && request.contains("method")) {
        fl::string funcName = request["method"].as_string().value_or("");
        recordResult(funcName, response["result"], 0, receivedAt, receivedAt, false);
    }
#else
    (void)receivedAt;
#endif
 
    return response;
}

References fl::basic_string::c_str(), fl::basic_string::erase(), FL_DBG, fl::FL_NO_EXCEPT, fl::millis(), mRpc, fl::json::object(), requestId, fl::json::set(), and fl::type_rank< T >::value.

Referenced by Remote().

Here is the call graph for this function:

Here is the caller graph for this function: