public async Task <RegistrationResult> Register(string username, string password)
{
var result = await Post.To("/_matrix/client/r0/register")
.Using(RestClient)
.AddBody(new RegistrationRequest
{
Username = username,
Password = password,
AuthenticationData = new AuthenticationData
{
Type = "m.login.dummy"
},
InhibitLogin = true,
DeviceId = null,
InitialDeviceDisplayName = null
})
.On(400, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(401, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(403, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(429, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.WhenSucceeded(new Action <RegistrationResult>(r =>
{
AccountRegistered?.Invoke(this, new RegistrationEventArgs(MxId.Parse(r.UserId)));
}))
.Execute <RegistrationResult>();
return(result);
}
private void StartParsingInBackground(CancellationToken cancelToken)
{
Task.Run(() => {
while (!cancelToken.IsCancellationRequested)
{
var b = ReadByteFromSerialBuffer();
_protocol.Parse(b);
if (CheckForProtocolError(out var error))
{
ProtocolError?.Invoke(this, error);
}
if (CheckForEvent(out var eventPdu))
{
OnEventReceived(eventPdu);
}
}
}, cancelToken);
}
public async Task <LoginResult> Login(string username, string password, string deviceId = null,
string initialDisplayName = "TensorMatrix")
{
var methodQueryResult = await QueryLoginMethods();
if (!methodQueryResult.SupportedMethods.Any(x => x.Type == "m.login.password"))
{
throw new UnsupportedLoginMethodException("Homeserver does not support password-based login.");
}
var result = await Post.To("/_matrix/client/r0/login")
.Using(RestClient)
.AddBody(new PasswordLoginRequest <MxidIdentifier>
{
Identifier = new MxidIdentifier {
User = username
},
DeviceId = deviceId,
InitialDeviceDisplayName = initialDisplayName,
Password = password
})
.On(400, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(403, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(429, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.WhenSucceeded(new Action <LoginResult>(r =>
{
MxId = MxId.Parse(r.UserId);
JwtAuthenticator = new JwtAuthenticator(r.AccessToken);
RestClient.Authenticator = JwtAuthenticator;
DeviceId = r.DeviceId;
if (r.WellKnown != null)
{
RestClient.BaseUrl = new Uri(r.WellKnown.HomeServer.BaseUrl);
}
LoggedIn?.Invoke(this, new LoginEventArgs(MxId, r.AccessToken, r.DeviceId));
}))
.Execute <LoginResult>();
return(result);
}
public void Parse(byte ch)
{
if (_pduBufPos >= PDU_BUF_SIZE)
{
_pduBufPos = 0;
}
//-----------------
// Parse PDU_TYPE
//-----------------
// check packet position
if (_pduBufPos == 0)
{
// beginning of packet, check for correct framing/expected byte(s)
// Packet must be either Command/Response (0x00) or Event (0x80)
if ((ch & 0x7F) == 0x00)
{
// store new character in RX buffer
_rxPduBuf[_pduBufPos++] = ch;
}
}
else
{
_rxPduBuf[_pduBufPos++] = ch;
if (_pduBufPos == (PDU_HDR_POS_CLS_ID + 1))
{
//------------
// Parse CLSID
//------------
if (_rxPduBuf[PDU_HDR_POS_CLS_ID] != (byte)ClassId.BlueCats)
{
if ((_rxPduBuf[PDU_HDR_POS_CLS_ID] & 0x7F) == 0x00)
{
_rxPduBuf[0] = _rxPduBuf[PDU_HDR_POS_CLS_ID];
_pduBufPos = 1;
}
else
{
_pduBufPos = 0; // bad sync, reset pdu buffer
}
}
}
//-----------------
// Parse PAY_LEN
//-----------------
else if (_pduBufPos == (PDU_HDR_POS_PAY_LEN + 1))
{
_pduPayLen = ch;
}
else if (_pduBufPos >= PDU_HDR_LEN)
{
//-----------------------------
// Parse header CRC8 and verify
//-----------------------------
if (_pduBufPos == PDU_HDR_LEN)
{
// check pdu header crc8
byte hdrCrc8 = Crc8(_rxPduBuf, 0, PDU_HDR_LEN - 1);
if (hdrCrc8 != _rxPduBuf[PDU_HDR_POS_CRC8])
{
_pduBufPos = 0; // crc failed, reset pdu buffer
var errMsg = $"Header CRC8 does not match (calculated: 0x{hdrCrc8:2X}, given: 0x{_rxPduBuf[ PDU_HDR_POS_CRC8 ]:2X}";
ProtocolError?.Invoke(this, errMsg);
}
}
//---------------------
// Full packet received
//---------------------
if (_pduBufPos == (_pduPayLen + PDU_HDR_LEN))
{
// just received last expected byte, reset pdu buffer
_pduBufPos = 0;
//------------------------------
// Parse payload CRC8 and verify
//------------------------------
if (_pduPayLen > 0)
{
// check pdu payload crc8
byte payCrc8 = Crc8(_rxPduBuf, PDU_PAY_POS, _pduPayLen);
if (payCrc8 != _rxPduBuf[PDU_HDR_POS_PAY_CRC8])
{
var errMsg = $"Header CRC8 does not match (calculated: 0x{payCrc8:X2}, given: 0x{_rxPduBuf[ PDU_HDR_POS_CRC8 ]:X2})";
ProtocolError?.Invoke(this, errMsg);
return;
}
}
//-----------
// Handle RSP
//-----------
if (_rxPduBuf[PDU_HDR_POS_PDU_TYPE] == (byte)PduType.Command)
{
if (_pduPayLen <= 0)
{
_pduBufPos = 0; // reset pdu buffer
ProtocolError?.Invoke(this, "Missing response code for response");
}
var payloadBytes = _rxPduBuf.Take(_pduPayLen + PDU_HDR_LEN).ToArray();
var pdu = CommandResponsePdu.FromByteArray(payloadBytes);
CommandResponseReceived?.Invoke(this, pdu);
}
//-----------
// Handle EVT
//-----------
else if (_rxPduBuf[PDU_HDR_POS_PDU_TYPE] == (byte)PduType.Event)
{
var payloadBytes = _rxPduBuf.Take(_pduPayLen + PDU_HDR_LEN).ToArray();
var pdu = EventPdu.FromByteArray(payloadBytes);
EventReceived?.Invoke(this, pdu);
}
}
}
}
}
protected override void OnEventAnalyzed(byte id, byte[] eventValue)
{
switch (id)
{
case 0x00:
{
var major = BitConverter.ToUInt16(eventValue, 0);
var minor = BitConverter.ToUInt16(eventValue, 2);
var patch = BitConverter.ToUInt16(eventValue, 4);
var build = BitConverter.ToUInt16(eventValue, 6);
var llVersion = BitConverter.ToUInt16(eventValue, 8);
var protocolVersion = eventValue[10];
var hw = eventValue[11];
var eventArgs = new BootEventArgs(major, minor, patch, build, llVersion, protocolVersion, hw);
Boot?.Invoke(this, eventArgs);
break;
}
case 0x02:
{
var endpoint = (Endpoint)eventValue[0];
var data = eventValue[1];
var eventArgs = new EndpointWatermarkRXEventArgs(endpoint, data);
EndpointWatermarkRX?.Invoke(this, eventArgs);
break;
}
case 0x03:
{
var endpoint = (Endpoint)eventValue[0];
var data = eventValue[1];
var eventArgs = new EndpointWatermarkTXEventArgs(endpoint, data);
EndpointWatermarkTX?.Invoke(this, eventArgs);
break;
}
case 0x04:
{
var address = BitConverter.ToUInt16(eventValue, 0);
var errorCode = BitConverter.ToUInt16(eventValue, 2);
var eventArgs = new ScriptFailureEventArgs(address, errorCode);
ScriptFailure?.Invoke(this, eventArgs);
break;
}
case 0x05:
{
NoLicenseKey?.Invoke(this, EventArgs.Empty);
break;
}
case 0x06:
{
var errorCode = BitConverter.ToUInt16(eventValue, 0);
var eventArgs = new ProtocolErrorEventArgs(errorCode);
ProtocolError?.Invoke(this, eventArgs);
break;
}
case 0x07:
{
var state = eventValue[0];
var eventArgs = new UsbEnumeratedEventArgs(state);
UsbEnumerated?.Invoke(this, eventArgs);
break;
}
default:
{
break;
}
}
}
