• conexión al servidor,
• enviando un mensaje,
• desconexión.

Código para conectarse al servidor y para enviar mensajes

Código de retorno Callback Procedure

1. Crear un proyecto WINDEV.
2. Cree una ventana en blanco
3. Crear un Procedure local (pServerSocketListen por ejemplo) para escuchar los mensajes enviados por el cliente desde su sitio web. El código de este Procedure local es el siguiente:
   
   // Code of local procedure: Listen to the messages sent by the socket client.
    
   PROCEDURE pServerSocketListen()
    
   HEADER_WEBSOCKET_CLIENT is string = "Sec-WebSocket-Key: "
   HEADER_WEBSOCKET_PROTOCOL is string = "Sec-WebSocket-Protocol: "
    
   // Create the socket server to listen to the incoming messages
   IF SocketCreate("Server", 5001) = False THEN
   Error("Creation error " + ErrorInfo(errMessage))
   ELSE
   // Process (or thread) for listening to messages
   // This process is run in background task
   // Listen permanently because we don't know when a message arrives
   ThreadExecute("Thread1", threadNormal, WaitProcedure)
   END
    
   //-----------------------------------------------------------
   // Procedure called in the listening thread
   INTERNAL PROCEDURE WaitProcedure()
    
   // Endless loop in order to wait for a client connection.
   // As soon as a client connects to send a message,
   // a thread is started to manage the incoming messages.
   // The ProcedureManagement procedure manages the incoming messages.
   LOOP
   Multitask(0)
   IF SocketWaitForConnection("Server") THEN
   Channel is string
   Channel = SocketAccept("Server")
   SocketChangeTransmissionMode(Channel, SocketNoEndTag)
   ThreadExecute(Channel, threadNormal, ProcedureManagement, Channel)
   END
   END
    
   //--------------------------------------------------------------
   // Code of procedure for managing the incoming messages
   INTERNAL PROCEDURE ManageProcedure(Channel)
    
   sRequest is ANSI string
   arrProtocol is array of strings
   sRes is string
   sProtocol is string = "JSON"
    
   // Read the socket until we reach the ending sequence of message
   // In our case, 2 CR characters in a row
   WHILE StringCount(sRequest, CR + CR) = 0
   sRequest += SocketRead(Channel)
   END
    
   // Process the incoming request
   // The sRequest variable contains the message to process
   // Study the string
   sKey is ANSI string
   FOR EACH STRING sLine OF sRequest SEPARATED BY CR
   Trace(sLine)
   IF sLine [=  HEADER_WEBSOCKET_CLIENT THEN
   sKey = sLine[[Length(HEADER_WEBSOCKET_CLIENT)+1 À]]
   ELSE IF sLine [= HEADER_WEBSOCKET_PROTOCOL
   // Retrieve the protocols
   StringToArray(ExtractString(sLine, 2, ":"), arrProtocol, ",")
   END
   END
    
    
   // Prepare the response that will be sent to the client
   sRes = [
   HTTP/1.1 101 Web Socket Protocol Handshake
   Upgrade: websocket
   Connection: Upgrade
   WebSocket-Origin: <ServerIPAddress>
   WebSocket-Location: ws://<ServerIPAddress>:5001
   Sec-WebSocket-Accept: %1
   ]
   IF arrProtocol..Occurrence <> 0 THEN
   sRes += [CR] + "Sec-WebSocket-Protocol: %2"
   sProtocol = Upper(NoSpace(arrProtocol[1]))
   sRes = StringBuild(sRes, Crypt(HashString(HA_SHA_160,
   sKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"), "",
   compressNone, encodeBASE64), sProtocol + CR + CR)
    
   ELSE
   sRes = StringBuild(sRes, Crypt(HashString(HA_SHA_160,
   sKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"), "",
   compressNone, encodeBASE64) + CR + CR)
   END
    
   // Sends the response to the client
   SocketWrite(Channel, sRes)
    
   LOOP
   bufFrame is Buffer = SocketRead(Channel)
   IF 0 = Length(bufFrame) THEN
   Trace("Break")
   SORTIR
   END
    
   nFrameLength is int = Asc(bufFrame[[2]]) & 127
   bufMask is Buffer
   bufData is Buffer
   IF 126 = nFrameLength THEN
   nFrameLength = HexaToInt(
   BufferToHexa(bufFrame[[3 ON 2]])) //BufferToInt(bufFrame, 3, 2)
   bufMask = bufFrame[[5 TO 8]]
   bufData = bufFrame[[9 TO]]
   ELSE IF 127 = nFrameLength THEN
   nFrameLength = HexaToInt(BufferToHexa(bufFrame[[3 ON 8]]))
   bufMask = bufFrame[[11 TO 14]]
   bufData = bufFrame[[15 TO]]
   ELSE
   bufMask = bufFrame[[3 TO 6]]
   bufData = bufFrame[[7 TO]]
   END
   sText is ANSI string
   FOR i = 1 _TO_ Length(bufData)
   sText += Charact(BinaryXOR(
   Asc(bufData[[i]]), Asc(bufMask[[(i - 1) modulo 4 + 1]])))
   END
   Trace(UTF8ToAnsi(sText))
    
   // Format the response
   SWITCH sProtocol
   CASE "XML"
   sRes = [
   <XML status="ok">
   %1
   </XML>
   ]
   CASE "JSON"
   sRes = [
   {"status": "ok",
   "response": "%1" }
   ]
   OTHER CASE
   sRes = StringToUTF8("Format not supported!")
   END
   sRes = StringBuild(sRes, sText)
    
   nResponseLenght is int = Length(sRes)
   bufResponse is Buffer
   bufResponse[[1]] = Charact(BinaryOR(0x80, BinaryAND(0x1, 0xF)))
   IF nResponseLength <= 125 THEN
   bufResponse[[2]] = Charact(nResponseLength)
   ELSE IF nResponseLength <= 65536 THEN
   bufResponse[[2]] = Charact(126)
   // The writing of the length is missing
   bufResponse += HexaToBuffer(Right(IntToHexa(nResponseLength), 4))
   ELSE
   bufResponse[[2]] = Charact(127)
   // The writing of the length is missing
   bufResponse += HexaToBuffer(IntToHexa(nResponseLength))
   END
   SocketWrite(Channel, bufResponse + sRes)
   END
    
   END
   END