/// <summary>
/// ダイアログを表示するトリガーメソッド
/// </summary>
public void OnDialog()
{
input.rock = true;
int cost = gamesetup.RemainPoint();
//表示するメッセージ
string msg;
if (cost > 0)
{
msg = "設置可能な駒があります ゲームを開始しますか?";
}
else
{
msg = "ゲームを開始しますか?";
}
//ダイアログの種類 (Choice or Close)
string kind = "Choice";
GameObject instance = message_manager.DispDialog(kind, msg);
if (kind == "Choice")
{
choice_message = instance.transform.GetComponent <ChoiceMessage>();
choice_message.FixDialog = result => Action(result.ToString());
}
else if (kind == "Close")
{
close_message = instance.transform.GetComponent <CloseMessage>();
close_message.FixDialog = result => Action(result.ToString());
}
}
private void CloseExecute(CloseMessage obj)
{
if (obj.T.GetType() == typeof(AllCustomersViewModel))
{
this.Close();
}
}
private void CloseExecute(CloseMessage obj)
{
if (obj.T.GetType() == typeof(AuftragViewModel))
{
this.Close();
}
}
private static void OnClose(object sender, CloseMessage args)
{
//This is called when our client has closed. The client can no longer send or receive events after this message.
// Connection will automatically try to re-establish and another OnReady will be called (unless it was disposed).
//Console.WriteLine("Lost Connection with client because of '{0}'", args.Reason);
//MessageBox.Show("Lost Connection with client because of '" + args.Reason + "'");
}
public async Task <string> Apk(string ApkPath)
{
Flows = new Flows(EndPoint);
await Flows.ConnectFlow <WriteMessage>(Systems.Host);
FileInfo Info = new FileInfo(ApkPath);
OkayMessage OpenOkay = await Flows.OpenFlow <OkayMessage>(LocalID, $"exec:cmd package 'install' -S {Info.Length}\0");
RemoteID = OpenOkay.Argument1;
byte[] Data = File.ReadAllBytes(Info.FullName);
decimal FileLength = Info.Length;
decimal MaxData = Constants.MaxData;
decimal Rounds = Math.Ceiling(FileLength / MaxData);
for (int i = 0; i < Rounds + 1; i++)
{
OkayMessage WriteOkay = await Flows.WriteFlow <OkayMessage>(LocalID, RemoteID, Data.Skip((int)(Constants.MaxData * i)).Take((int)Constants.MaxData).ToArray());
}
WriteMessage InstallResult = await Flows.RecievePayloadFlow <WriteMessage>(LocalID, RemoteID);
CloseMessage CloseResult = await Flows.SendCloseFlow <CloseMessage>(LocalID, RemoteID);
return(Encoding.UTF8.GetString(InstallResult.Payload));
}
private void _RpcClientOnCloseHandler(object sender, CloseMessage args)
{
// log this shitty event
_log.Warn($"DISCORD CONNECTION_LOST | {args.Code} {args.Reason}");
// restart
Stop();
Start();
}
public async Task SendCloseMessage(int streamId, DomainEnum domain = DomainEnum.MarketPrice)
{
var closeMsg = new CloseMessage {
ID = streamId, Domain = domain, MsgType = MessageTypeEnum.Close
};
Console.WriteLine(closeMsg.ToJson());
await ClientWebSocketUtils.SendTextMessage(_websocket.WebSocket, closeMsg.ToJson());
}
private void WriteCloseMessage(CloseMessage closeMessage, IBufferWriter <byte> output)
{
var protobufCloseMessage = new CloseMessageProtobuf
{
Error = closeMessage.Error ?? ""
};
var packedMessage = MessageDescriptor.PackMessage(HubProtocolConstants.CloseMessageType, protobufCloseMessage.ToByteArray());
output.Write(packedMessage);
}
private static void WriteCloseMessage(CloseMessage message, Utf8JsonWriter writer)
{
if (message.Error != null)
{
writer.WriteString(ErrorPropertyNameBytes, message.Error);
}
if (message.AllowReconnect)
{
writer.WriteBoolean(AllowReconnectPropertyNameBytes, true);
}
}
private void WriteCloseMessage(CloseMessage message, ref MessagePackWriter writer)
{
writer.WriteArrayHeader(2);
writer.Write(HubProtocolConstants.CloseMessageType);
if (string.IsNullOrEmpty(message.Error))
{
writer.WriteNil();
}
else
{
writer.Write(message.Error);
}
}
private static void WriteCloseMessage(CloseMessage message, JsonTextWriter writer)
{
if (message.Error != null)
{
writer.WritePropertyName(ErrorPropertyName);
writer.WriteValue(message.Error);
}
if (message.AllowReconnect)
{
writer.WritePropertyName(AllowReconnectPropertyName);
writer.WriteValue(true);
}
}
public async Task Pull(string FilePath)
{
WriteMessage Connect_WriteMessage = await Connect();
OkayMessage Open_OkayMessage = await Open();
OkayMessage SendStat_OkayMessage = await SendStat(FilePath);
StatSyncMessage RecieveStat_StatSyncMessage = await RecieveStat();
OkayMessage SendRecv_OkayMessage = await SendRecv(FilePath);
FileStream FileStream = File.OpenWrite(FilePath.Split('/').Last());
DataSyncMessage DataSyncMessage = await RecieveData();
//Files Smaller Than 64K Fits inside the first DataSyncMessage Packet.
if (DataSyncMessage.EndOfFile == false)
{
WriteMessage WriteMessage;
string EOF;
while (true)
{
WriteMessage = await Flows.RecieveStreamingPayloadFlow <WriteMessage>(LocalID, RemoteID);
await FileStream.WriteAsync(WriteMessage.Payload, 0, WriteMessage.Payload.Length);
EOF = Encoding.UTF8.GetString(WriteMessage.Payload.Skip(WriteMessage.Payload.Length - 8).Take(4).ToArray());
if (EOF == "DONE")
{
break;
}
}
}
else
{
await FileStream.WriteAsync(DataSyncMessage.Payload, 0, DataSyncMessage.Payload.Length);
}
await FileStream.FlushAsync();
FileStream.Close();
OkayMessage QuiteOkay = await Flows.WriteFlow <OkayMessage>(LocalID, RemoteID, "QUIT\0\0\0\0");
CloseMessage Close = await Flows.RecieveCloseFlow <CloseMessage>(LocalID, RemoteID);
}
private void CloseReceived(CloseMessage close)
{
string database = null;
this.connections.TryGetValue(close.Id, out database);
if (database == null)
{
return;
}
this.databases.Add(database);
this.connections.Remove(close.Id);
this.NotifyPropertyChanged("Connections");
}
private async Task SendCloseAsync(HubConnectionContext connection, Exception exception)
{
CloseMessage closeMessage = exception == null
? CloseMessage.Empty
: new CloseMessage($"Connection closed with an error. {exception.GetType().Name}: {exception.Message}");
try
{
await connection.WriteAsync(closeMessage);
}
catch (Exception ex)
{
Log.ErrorSendingClose(_logger, ex);
}
}
public void Protocol_Should_Handle_CancelInvocationMessage_Without_Header(string error)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var closeMessage = new CloseMessage(error);
protobufHubProtocol.WriteMessage(closeMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultCloseMessage);
Assert.True(result);
Assert.NotNull(resultCloseMessage);
Assert.IsType <CloseMessage>(resultCloseMessage);
Assert.Equal(error, ((CloseMessage)resultCloseMessage).Error);
}
private async Task SendCloseAsync(HubConnectionContext connection, Exception exception)
{
var closeMessage = CloseMessage.Empty;
if (exception != null)
{
var errorMessage = ErrorMessageHelper.BuildErrorMessage("Connection closed with an error.", exception, _enableDetailedErrors);
closeMessage = new CloseMessage(errorMessage);
}
try
{
await connection.WriteAsync(closeMessage);
}
catch (Exception ex)
{
Log.ErrorSendingClose(_logger, ex);
}
}
/// <summary>
/// ダイアログを表示するトリガーメソッド
/// </summary>
public void OnDialog()
{
//表示するメッセージ
string msg = "タイトルへ戻りますか？";
//ダイアログの種類 (Choice or Close)
string kind = "Choice";
GameObject instance = message_manager.DispDialog(kind, msg);
if (kind == "Choice")
{
choice_message = instance.transform.GetComponent <ChoiceMessage>();
choice_message.FixDialog = result => Action(result.ToString());
}
else if (kind == "Close")
{
close_message = instance.transform.GetComponent <CloseMessage>();
close_message.FixDialog = result => Action(result.ToString());
}
}
private async Task SendCloseAsync(HubConnectionContext connection, Exception?exception, bool allowReconnect)
{
var closeMessage = CloseMessage.Empty;
if (exception != null)
{
var errorMessage = ErrorMessageHelper.BuildErrorMessage("Connection closed with an error.", exception, _enableDetailedErrors);
closeMessage = new CloseMessage(errorMessage, allowReconnect);
}
else if (allowReconnect)
{
closeMessage = new CloseMessage(error: null, allowReconnect);
}
try
{
await connection.WriteAsync(closeMessage, ignoreAbort : true);
}
catch (Exception ex)
{
Log.ErrorSendingClose(_logger, ex);
}
}
public async Task <string> Enable()
{
if (IsRoot)
{
return("adbd is already running as root");
}
Flows = new Flows(EndPoint);
await Flows.ConnectFlow <WriteMessage>(Systems.Host);
OkayMessage OpenOkay = await Flows.OpenFlow <OkayMessage>(LocalID, $"root:\0");
RemoteID = OpenOkay.Argument1;
WriteMessage Result = await Flows.RecievePayloadFlow <WriteMessage>(LocalID, RemoteID, false);
CloseMessage CloseRequest = await Flows.RecieveCloseFlow <CloseMessage>(LocalID, RemoteID);
IsRoot = true;
return(Encoding.UTF8.GetString(Result.Payload));
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = Array.Empty <Type>();
_hubProtocol = new ProtobufHubProtocol(types, logger);
switch (InputArgument)
{
case "small":
_closeMessage = new CloseMessage(new string('#', 128));
break;
case "medium":
_closeMessage = new CloseMessage(new string('#', 512));
break;
case "large":
_closeMessage = new CloseMessage(new string('#', 2048));
break;
}
;
_serializedMessageRef = _hubProtocol.GetMessageBytes(_closeMessage);
}
private void OnClose(object sender, CloseMessage args)
{
_controlPanel.ChangeStatus = "RPC Closed";
windowMessages.ChangeLabel = "SDR# RPC | Closed";
Close();
}
private void HandleCloseMessage(CloseMessage obj)
{
Messenger.Default.Send <CleanUpMessage>(new CleanUpMessage());
}
public void Handle(CloseMessage message)
{
LeveranciersorBestelbonsVisible = false;
}
public async Task <IActionResult> Close([FromBody] CloseMessage message)
{
await close.Handle(message);
return(Ok());
}
private void OnClose(object sender, CloseMessage args)
{
_controlPanel.ChangeStatus = "RPC Closed";
Close();
}
private void OnMessageReceived(CloseMessage obj)
{
dialogService.CloseDetailDialog();
Overzicht();
}
public static WsjtxMessage Parse(byte[] datagram)
{
if (!CheckMagicNumber(datagram))
{
return(null);
}
int cur = MAGIC_NUMBER_LENGTH;
int schemaVersion = DecodeQInt32(datagram, ref cur);
var messageType = (MessageType)DecodeQInt32(datagram, ref cur);
try
{
if (schemaVersion == 2 || schemaVersion == 3)
{
WsjtxMessage result;
if (messageType == MessageType.HEARTBEAT_MESSAGE_TYPE)
{
result = HeartbeatMessage.Parse(datagram);
}
else if (messageType == MessageType.STATUS_MESSAGE_TYPE)
{
result = StatusMessage.Parse(datagram);
}
else if (messageType == MessageType.DECODE_MESSAGE_TYPE)
{
result = DecodeMessage.Parse(datagram);
}
else if (messageType == MessageType.ENQUEUE_DECODE_MESSAGE_TYPE)
{
result = EnqueueDecodeMessage.Parse(datagram);
}
else if (messageType == MessageType.CLEAR_MESSAGE_TYPE)
{
result = ClearMessage.Parse(datagram);
}
else if (messageType == MessageType.QSO_LOGGED_MESSAGE_TYPE)
{
result = QsoLoggedMessage.Parse(datagram);
}
else if (messageType == MessageType.CLOSE_MESSAGE_TYPE)
{
result = CloseMessage.Parse(datagram);
}
else if (messageType == MessageType.WSPR_DECODE_MESSAGE_TYPE)
{
result = WsprDecodeMessage.Parse(datagram);
}
else if (messageType == MessageType.LOGGED_ADIF_MESSAGE_TYPE)
{
result = LoggedAdifMessage.Parse(datagram);
}
else
{
result = new UnknownMessage();
}
return(result);
}
}
catch (Exception ex)
{
throw new ParseFailureException(messageType, datagram, ex);
}
throw new NotImplementedException($"Schema version {schemaVersion}, message type {messageType}");
}
private static void OnClose(object sender, CloseMessage args)
{
Console.WriteLine($"[Close] Lost Connection: {args.Reason}");
}
private void PasswordReceovery_FormClosing(object sender, FormClosingEventArgs e)
{
CloseMessage.ApplicationClose(sender, e);
}
private void LoginUi_FormClosing(object sender, FormClosingEventArgs e)
{
CloseMessage.ApplicationClose(sender, e);
}
