Xojo Plugin

Firebase Receive Server-Sent Events (text/event-stream)

See more Firebase Examples

Demonstrates how to start receiving server-sent events and update your JSON database with each event. Xojo Plugin

Dim success As Boolean
success = False

// Demonstrates how to begin receiving server-sent events, and to update
// your JSON database for each event.

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

// This example assumes a JWT authentication token, if required, has been previously obtained.
// See Get Firebase Access Token from JSON Service Account Private Key for sample code.

// Load the previously obtained Firebase access token into a string.
Dim fac As New Chilkat.FileAccess
Dim accessToken As String
accessToken = fac.ReadEntireTextFile("qa_data/tokens/firebaseToken.txt","utf-8")
If (fac.LastMethodSuccess = False) Then
    System.DebugLog(fac.LastErrorText)
    Return
End If

Dim rest As New Chilkat.Rest

// Make the initial connection (without sending a request yet).
// Once connected, any number of requests may be sent.  It is not necessary to explicitly
// call Connect before each request.  
success = rest.Connect("chilkat.firebaseio.com",443,True,True)
If (success = False) Then
    System.DebugLog(rest.LastErrorText)
    Return
End If

Dim authGoogle As New Chilkat.AuthGoogle
authGoogle.AccessToken = accessToken
success = rest.SetAuthGoogle(authGoogle)

success = rest.AddHeader("Accept","text/event-stream")
success = rest.AddHeader("Cache-Control","no-cache")

Dim responseBody As String
responseBody = rest.FullRequestNoBody("GET","/.json")

// A 307 redirect response is expected.
If (rest.ResponseStatusCode <> 307) Then
    System.DebugLog("Unexpected response code: " + Str(rest.ResponseStatusCode))
    System.DebugLog(responseBody)
    System.DebugLog("Failed.")
    Return
End If

// Get the redirect URL
Dim urlStr As String
urlStr = rest.LastRedirectUrl
Dim url As New Chilkat.Url
success = url.ParseUrl(urlStr)

System.DebugLog("redirect URL domain: " + url.Host)
System.DebugLog("redirect URL path: " + url.Path)
System.DebugLog("redirect URL query params: " + url.Query)
System.DebugLog("redirect URL path with query params: " + url.PathWithQueryParams)

// Our text/event-stream will be obtained from the redirect URL...
Dim rest2 As New Chilkat.Rest

success = rest2.Connect(url.Host,443,True,True)
If (success <> True) Then
    System.DebugLog(rest2.LastErrorText)
    Return
End If

success = rest2.AddHeader("Accept","text/event-stream")
success = rest2.AddHeader("Cache-Control","no-cache")

// Add the redirect query params to the request
success = rest2.AddQueryParams(url.Query)

// In our case, we don't actually need the auth query param,
// so remove it.
success = rest2.RemoveQueryParam("auth")

// Send the request.  (We are only sending the request here.
// We are not yet getting the response because the response
// will be a text/event-stream.)
success = rest2.SendReqNoBody("GET",url.Path)
If (success <> True) Then
    System.DebugLog(rest2.LastErrorText)
    Return
End If

// Read the response header.  
// We want to first get the response header to see if it's a successful
// response status code.  If not, then the response will not be a text/event-stream
// and we should read the response body normally.
Dim responseStatusCode As Int32
responseStatusCode = rest2.ReadResponseHeader()
If (responseStatusCode < 0) Then
    System.DebugLog(rest2.LastErrorText)
    Return
End If

// If successful, a 200 response code is expected.
// If the reponse code is not 200, then read the response body and fail..
If (responseStatusCode <> 200) Then
    System.DebugLog("Response Code: " + Str(responseStatusCode))
    System.DebugLog("Response Status Text: " + rest2.ResponseStatusText)
    System.DebugLog("Response Header: " + rest2.ResponseHeader)
    responseBody = rest2.ReadRespBodyString()
    If (rest2.LastMethodSuccess = True) Then
        System.DebugLog("Error Response Body: " + responseBody)
    End If

    System.DebugLog("Failed.")
    Return
End If

// For this example, our JSON database will be empty at the beginning.
// The incoming events (put and patch) will be applied to this database.
Dim jsonDb As New Chilkat.JsonObject

// Make sure to set the JSON path delimiter to "/".  The default is "." and this
// is not compatible with Firebase paths.
jsonDb.DelimiterChar = "/"

// At this point, we've received the response header.  Now it's time to begin
// receiving the event stream.  We'll start a background thread to read the 
// stream.  (Our main application (foreground) thread can cancel it at any time.)  
// While receiving in the background thread, our foreground thread can read the stream
// as it desires..
Dim eventStream As New Chilkat.Stream

// This sse object will be used as a helper to parse the server-sent event stream.
Dim sse As New Chilkat.ServerSentEvent

Dim task As Chilkat.Task
task = rest2.ReadRespBodyStreamAsync(eventStream,True)
success = task.Run()

// For this example, we'll just read a few events, and then cancel the
// async task.
Dim count As Int32
count = 0
While (count < 3) And (task.Finished = False)

    // Get the next event, which is a series of text lines ending with
    // a blank line. 
    // Note: This method blocks the calling thread until a message arrives.
    // a program might instead periodically check the availability of
    // data via the stream's DataAvailable property, and then do the read.

    // An alternative to writing a while loop to read the event stream
    // would be to setup some sort of timer event in your program (using whatever timer functionality
    // is provided in a programming language/environment), to periodically check the eventStream's
    // DataAvailable property and consume the incoming event.
    Dim eventStr As String
    eventStr = eventStream.ReadUntilMatch(EndOfLine.Windows + EndOfLine.Windows)
    If (eventStream.LastMethodSuccess <> True) Then
        System.DebugLog(eventStream.LastErrorText)
        // Force the loop to exit by setting the count to a high number.
        count = 99999
    Else
        System.DebugLog("Event: [" + eventStr + "]")

        // We have an event. Let's update our local copy of the JSON database.
        success = sse.LoadEvent(eventStr)
        If (success <> True) Then
            System.DebugLog("Failed to load sse event: " + eventStr)
        Else
            // Now we can easily access the event name and data, and apply it to our JSON database:
            success = jsonDb.FirebaseApplyEvent(sse.EventName,sse.Data)
            If (success <> True) Then
                System.DebugLog("Failed to apply event: " + sse.EventName + ": " + sse.Data)
            Else
                System.DebugLog("Successfully applied event: " + sse.EventName + ": " + sse.Data)
            End If

        End If

    End If

    count = count + 1
Wend

// Make sure the background task is cancelled if still running.
success = task.Cancel()

// Examine the JSON database after applying events..
jsonDb.EmitCompact = False
System.DebugLog("----")
System.DebugLog(jsonDb.Emit())