public PutBytesMessageV3(PutBytesState State)
: base(Endpoint.PutBytes)
{
Data = new List <byte>();
this.State = State;
AddSize = true;
}
public PutBytesMessageV3(PutBytesState State, List <byte> Id, List <byte> Data)
: base(Endpoint.PutBytes)
{
this.Data = Data;
this.State = State;
AddSize = true;
}
public PutBytesMessage(PutBytesTransferType transferType, byte[] buffer, InstallProgressHandler progressHandler, uint index = 0)
: base(Endpoint.PutBytes)
{
this._transferType = transferType;
this._buffer = new List <byte>(buffer);
this._progressHandler = progressHandler;
this._index = index;
this._state = PutBytesState.NotStarted;
}
public PutBytesClient(Pebble pebble, uint index, PutBytesType transferType, byte[] buffer)
{
pebble_ = pebble;
index_ = index;
transferType_ = transferType;
buffer_ = buffer;
state_ = PutBytesState.NotStarted;
token_ = 0;
left_ = 0;
}
public PutBytesClient(Pebble pebble, uint index, PutBytesType transferType, byte[] buffer)
{
pebble_ = pebble;
index_ = index;
transferType_ = transferType;
buffer_ = buffer;
state_ = PutBytesState.NotStarted;
token_ = 0;
left_ = 0;
}
public void init()
{
if (state_ != PutBytesState.NotStarted)
{
HasError = true;
throw new Exception("Already init()ed");
}
byte[] data = Util.Pack("!bIbb", 1, buffer_.Length, transferType_, index_);
pebble_.RegisterEndpointCallback(Endpoints.PUT_BYTES, PutBytesReceived);
pebble_.sendMessage(Endpoints.PUT_BYTES, data);
var wait = new EndpointSync <AppbankInstallMessageEventArgs>(pebble_, Endpoints.PUT_BYTES);
state_ = PutBytesState.WaitForToken;
}
protected override void AddContentToMessage(List<byte> payload)
{
ServiceLocator.Logger.WriteLine("PutBytes <<< outgoing message for " + this._state.ToString());
switch (this._state)
{
case PutBytesState.NotStarted:
{
// another magic number!...
payload.Add((byte)PutBytesState.WaitForToken);
byte[] length = BitConverter.GetBytes(this._buffer.Count);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(length);
}
payload.AddRange(length);
payload.Add((byte)this._transferType);
payload.Add((byte)this._index);
// Move to next state...
this._state = PutBytesState.WaitForToken;
}
break;
case PutBytesState.InProgress:
{
// equivalent of python PutBytesClient.send()
this._lastChunkSize = Math.Min(this._leftToSend, 2000);
int offset = this._buffer.Count - this._leftToSend;
// another magic number!...
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
byte[] dataToSendBytes = BitConverter.GetBytes(this._lastChunkSize);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
Array.Reverse(dataToSendBytes);
}
payload.AddRange(tokenBytes);
payload.AddRange(dataToSendBytes);
byte[] data = new byte[this._lastChunkSize];
this._buffer.CopyTo(offset, data, 0, this._lastChunkSize);
payload.AddRange(data);
this._leftToSend -= this._lastChunkSize;
ServiceLocator.Logger.WriteLine("PutBytes - sending " + this._lastChunkSize.ToString() + " byte(s), " + this._leftToSend.ToString() + " byte(s) remain");
}
break;
case PutBytesState.Abort:
{
// equivalent of python PutBytesClient.abort()
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
}
payload.AddRange(tokenBytes);
}
break;
case PutBytesState.Commit:
{
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
uint crc = this._buffer.Crc32();
byte[] crcBytes = BitConverter.GetBytes(crc);
ServiceLocator.Logger.WriteLine(string.Format("Sending CRC of {0:X}", crc));
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
Array.Reverse(crcBytes);
}
payload.AddRange(tokenBytes);
payload.AddRange(crcBytes);
}
break;
case PutBytesState.Complete:
{
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
}
payload.AddRange(tokenBytes);
}
break;
}
}
/// <summary>
/// Handles the state message.
/// </summary>
/// <param name="message">The message response.</param>
/// <returns>True when the PutBytes process has completed (either successfully or not), false if further processing is required</returns>
internal bool HandleStateMessage(PutBytesMessage message)
{
if (message.Result[0] != 1)
{
this.Errored = true;
}
ServiceLocator.Logger.WriteLine("PutBytes >>> incoming message for " + this._state.ToString());
switch (this._state)
{
case PutBytesState.WaitForToken:
if (this.Errored)
{
return true;
}
byte[] tokenArray = new byte[message.Result.Count - 1];
message.Result.CopyTo(1, tokenArray, 0, tokenArray.Length);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenArray);
}
this._token = BitConverter.ToUInt32(tokenArray, 0);
this._leftToSend = this._buffer.Count;
// next step is we start sending data - like PutBytesClient.send()
// the continuation is in AddContentToMessage
this._state = PutBytesState.InProgress;
break;
case PutBytesState.InProgress:
if (this.Errored)
{
this._state = PutBytesState.Abort;
}
else
{
if (this._leftToSend > 0)
{
// Still more to send, so we return false and the next chunk will go
ServiceLocator.Logger.WriteLine(string.Format("Sent {0} of {1} bytes", this._buffer.Count - this._leftToSend, this._buffer.Count));
if (this._progressHandler != null)
{
// From PutBytes, we send the number of bytes we just sent rather than a percentage...
this._progressHandler(this._lastChunkSize);
}
return false;
}
else
{
// next step is we send the commit message like PutBytesClient.commit()
// the continuation is in AddContentToMessage
this._state = PutBytesState.Commit;
}
}
break;
case PutBytesState.Commit:
if (this.Errored)
{
this._state = PutBytesState.Abort;
}
else
{
// next step is we send the commit message like PutBytesClient.commit()
// the continuation is in AddContentToMessage
this._state = PutBytesState.Complete;
}
break;
case PutBytesState.Complete:
if (this.Errored)
{
this._state = PutBytesState.Abort;
}
else
{
this.Completed = true;
return true;
}
break;
}
return false;
}
public PutBytesMessage(PutBytesTransferType transferType, byte[] buffer, InstallProgressHandler progressHandler, uint index = 0)
: base(Endpoint.PutBytes)
{
this._transferType = transferType;
this._buffer = new List<byte>(buffer);
this._progressHandler = progressHandler;
this._index = index;
this._state = PutBytesState.NotStarted;
}
public void init()
{
if (state_ != PutBytesState.NotStarted)
{
HasError = true;
throw new Exception("Already init()ed");
}
byte[] data = Util.Pack("!bIbb", 1, buffer_.Length, transferType_, index_);
pebble_.RegisterEndpointCallback(Endpoints.PUT_BYTES, PutBytesReceived);
pebble_.sendMessage(Endpoints.PUT_BYTES, data);
var wait = new EndpointSync<AppbankInstallMessageEventArgs>(pebble_, Endpoints.PUT_BYTES);
state_ = PutBytesState.WaitForToken;
}
void PutBytesReceived(object sender, MessageReceivedEventArgs e)
{
switch (state_)
{
case PutBytesState.WaitForToken:
{
var unpacked = Util.Unpack("!bI", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
//throw new Exception("failed to wait");
HasError = true;
}
token_ = (uint)unpacked[1];
left_ = buffer_.Length;
state_ = PutBytesState.InProgress;
send();
}
break;
case PutBytesState.InProgress:
{
var unpacked = Util.Unpack("!b", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
abort();
return;
}
if (left_ > 0)
send();
else
{
state_ = PutBytesState.Commit;
commit();
}
}
break;
case PutBytesState.Commit:
{
var unpacked = Util.Unpack("!b", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
abort();
return;
}
state_ = PutBytesState.Complete;
complete();
}
break;
case PutBytesState.Complete:
{
var unpacked = Util.Unpack("!b", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
abort();
return;
}
IsDone = true;
}
break;
}
}
protected override void AddContentToMessage(List <byte> payload)
{
ServiceLocator.Logger.WriteLine("PutBytes <<< outgoing message for " + this._state.ToString());
switch (this._state)
{
case PutBytesState.NotStarted:
{
// another magic number!...
payload.Add((byte)PutBytesState.WaitForToken);
byte[] length = BitConverter.GetBytes(this._buffer.Count);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(length);
}
payload.AddRange(length);
payload.Add((byte)this._transferType);
payload.Add((byte)this._index);
// Move to next state...
this._state = PutBytesState.WaitForToken;
}
break;
case PutBytesState.InProgress:
{
// equivalent of python PutBytesClient.send()
this._lastChunkSize = Math.Min(this._leftToSend, 2000);
int offset = this._buffer.Count - this._leftToSend;
// another magic number!...
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
byte[] dataToSendBytes = BitConverter.GetBytes(this._lastChunkSize);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
Array.Reverse(dataToSendBytes);
}
payload.AddRange(tokenBytes);
payload.AddRange(dataToSendBytes);
byte[] data = new byte[this._lastChunkSize];
this._buffer.CopyTo(offset, data, 0, this._lastChunkSize);
payload.AddRange(data);
this._leftToSend -= this._lastChunkSize;
ServiceLocator.Logger.WriteLine("PutBytes - sending " + this._lastChunkSize.ToString() + " byte(s), " + this._leftToSend.ToString() + " byte(s) remain");
}
break;
case PutBytesState.Abort:
{
// equivalent of python PutBytesClient.abort()
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
}
payload.AddRange(tokenBytes);
}
break;
case PutBytesState.Commit:
{
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
uint crc = this._buffer.Crc32();
byte[] crcBytes = BitConverter.GetBytes(crc);
ServiceLocator.Logger.WriteLine(string.Format("Sending CRC of {0:X}", crc));
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
Array.Reverse(crcBytes);
}
payload.AddRange(tokenBytes);
payload.AddRange(crcBytes);
}
break;
case PutBytesState.Complete:
{
payload.Add((byte)this._state);
byte[] tokenBytes = BitConverter.GetBytes(this._token & 0xFFFFFFFF);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenBytes);
}
payload.AddRange(tokenBytes);
}
break;
}
}
/// <summary>
/// Handles the state message.
/// </summary>
/// <param name="message">The message response.</param>
/// <returns>True when the PutBytes process has completed (either successfully or not), false if further processing is required</returns>
internal bool HandleStateMessage(PutBytesMessage message)
{
if (message.Result[0] != 1)
{
this.Errored = true;
}
ServiceLocator.Logger.WriteLine("PutBytes >>> incoming message for " + this._state.ToString());
switch (this._state)
{
case PutBytesState.WaitForToken:
if (this.Errored)
{
return(true);
}
byte[] tokenArray = new byte[message.Result.Count - 1];
message.Result.CopyTo(1, tokenArray, 0, tokenArray.Length);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(tokenArray);
}
this._token = BitConverter.ToUInt32(tokenArray, 0);
this._leftToSend = this._buffer.Count;
// next step is we start sending data - like PutBytesClient.send()
// the continuation is in AddContentToMessage
this._state = PutBytesState.InProgress;
break;
case PutBytesState.InProgress:
if (this.Errored)
{
this._state = PutBytesState.Abort;
}
else
{
if (this._leftToSend > 0)
{
// Still more to send, so we return false and the next chunk will go
ServiceLocator.Logger.WriteLine(string.Format("Sent {0} of {1} bytes", this._buffer.Count - this._leftToSend, this._buffer.Count));
if (this._progressHandler != null)
{
// From PutBytes, we send the number of bytes we just sent rather than a percentage...
this._progressHandler(this._lastChunkSize);
}
return(false);
}
else
{
// next step is we send the commit message like PutBytesClient.commit()
// the continuation is in AddContentToMessage
this._state = PutBytesState.Commit;
}
}
break;
case PutBytesState.Commit:
if (this.Errored)
{
this._state = PutBytesState.Abort;
}
else
{
// next step is we send the commit message like PutBytesClient.commit()
// the continuation is in AddContentToMessage
this._state = PutBytesState.Complete;
}
break;
case PutBytesState.Complete:
if (this.Errored)
{
this._state = PutBytesState.Abort;
}
else
{
this.Completed = true;
return(true);
}
break;
}
return(false);
}
void PutBytesReceived(object sender, MessageReceivedEventArgs e)
{
switch (state_)
{
case PutBytesState.WaitForToken:
{
var unpacked = Util.Unpack("!bI", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
//throw new Exception("failed to wait");
HasError = true;
}
token_ = (uint)unpacked[1];
left_ = buffer_.Length;
state_ = PutBytesState.InProgress;
send();
}
break;
case PutBytesState.InProgress:
{
var unpacked = Util.Unpack("!b", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
abort();
return;
}
if (left_ > 0)
{
send();
}
else
{
state_ = PutBytesState.Commit;
commit();
}
}
break;
case PutBytesState.Commit:
{
var unpacked = Util.Unpack("!b", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
abort();
return;
}
state_ = PutBytesState.Complete;
complete();
}
break;
case PutBytesState.Complete:
{
var unpacked = Util.Unpack("!b", e.Payload);
byte res = Convert.ToByte(unpacked[0]);
if (res != 1)
{
abort();
return;
}
IsDone = true;
}
break;
}
}