Example #1
0
        private void HandleMessage(PublishArrivedArgs e)
        {
            string messageAction = e.Topic.Split('/')[2];
            string topicPrefix   = "mqttmessenger/";

            switch (messageAction)
            {
            case "userconnected":
            {
                string gmail = e.Payload.ToString();
                //userconnected action - save this somewhere?
                break;
            }

            case "getmessages":
            {
                string             gmail    = e.Payload.ToString();
                List <MQTTMessage> messages = MessageController.GetUnreadMessagesByGmail(gmail);

                PublishMqtt(JsonConvert.SerializeObject(messages), topicPrefix + gmail + "/messagedump");
                break;
            }

            case "newmessage":
            {
                MQTTMessengerDevApp.DataSchema.Message message = new MQTTMessengerDevApp.DataSchema.Message();
                JsonConvert.DeserializeAnonymousType <MQTTMessengerDevApp.DataSchema.Message>(e.Payload.ToString(), message);
                MessageController.NewMessage(message);
                //Send To The other Guy
                break;
            }
            }
        }
Example #2
0
 protected bool client_PublishArrived(object sender, PublishArrivedArgs e)
 {
     Debug.Log("Received Message");
     Debug.Log("Topic: " + e.Topic);
     Debug.Log("Payload: " + e.Payload);
     return(true);
 }
Example #3
0
        private bool OnReceived(object sender, PublishArrivedArgs ea)
        {
            Log.Info("Received Message");
            Log.Info("Topic: " + ea.Topic);
            Log.Info("MqttAdaptor.OnReceived, topic={0}", ea.Topic);

            var topic   = ea.Topic.Split('/');
            var sid     = topic[1];
            var mode    = MetaData.GetMode(topic[2]);
            var toQuery = mode == Mode.Return ? delegates : implements;
            IMessageConsumer msgConsumer;

            if (toQuery.TryGetValue(sid, out msgConsumer))
            {
                var job = new DefferedJob()
                {
                    Buffer          = (byte[])ea.Payload.TrimmedBuffer.Clone(),
                    Mode            = mode,
                    MessageConsumer = msgConsumer,
                };

                lock (defferedJobs)
                {
                    defferedJobs.Enqueue(job);
                }
            }

            return(true);
        }
Example #4
0
        bool client_PublishArrived(object sender, PublishArrivedArgs e)
        {
            ColetorTopicoLog ctlm = new ColetorTopicoLog();

            //
            if (e.Topic.Equals("temperatura"))
            {
                ctlm.Id_ColetorTopico = 1;
                ctlm.DataHora         = getData();
                ctlm.Valor            = e.Payload;
                //
                db.ColetorTopicoLog.Add(ctlm);
                db.SaveChanges();
            }
            else if (e.Topic.Equals("pressao"))
            {
                ctlm.Id_ColetorTopico = 2;
                ctlm.DataHora         = getData();
                ctlm.Valor            = e.Payload;
                //
                db.ColetorTopicoLog.Add(ctlm);
                db.SaveChanges();
            }
            //Console.WriteLine("Received Message");
            //Console.WriteLine("Topic: " + e.Topic);
            //Console.WriteLine("Payload: " + e.Payload);
            ////
            //Console.WriteLine();
            return(true);
        }
Example #5
0
        bool Client_PublishArrived(object sender, PublishArrivedArgs e)
        {
            if (e.Topic == "/test/client2")
            {
                str = e.Payload;
                if (str == "I`m connected")
                {
                    Action act1 = () =>
                    {
                        l3.Text      = "Controller connected";
                        l3.ForeColor = Color.Green;
                        Publish("/test/led1", Form1.r1.Checked == true ? "1" : "0");
                        Publish("/test/led2", Form1.r2.Checked == true ? "1" : "0");
                        Publish("/test/led3", Form1.r3.Checked == true ? "1" : "0");
                        Publish("/test/led4", Form1.r4.Checked == true ? "1" : "0");
                    };
                    Invoke(act1);
                }

                else if (str.Length == 4)
                {
                    Action act0 = () =>
                    {
                        l3.Text      = "Controller connected";
                        l3.ForeColor = Color.Green;
                        r1.Checked   = str[0] == '1' ? true : false;
                        r2.Checked   = str[1] == '1' ? true : false;
                        r3.Checked   = str[2] == '1' ? true : false;
                        r4.Checked   = str[3] == '1' ? true : false;
                    };
                    Invoke(act0);
                }

                else if (str.Length == 3)
                {
                    if (check1 == Convert.ToInt32(str))
                    {
                        Action act3 = () =>
                        {
                            l3.Text      = "Controller is connected";
                            l3.ForeColor = Color.Green;
                        };
                        Invoke(act3);
                    }
                    else
                    {
                        Action act2 = () =>
                        {
                            l3.Text      = "Controller is disconnected";
                            l3.ForeColor = Color.Red;
                            MessageBox.Show("Connection lost");
                        };
                        Invoke(act2);
                    }
                }
                checke = true;
            }
            return(true);
        }
Example #6
0
 bool client_PublishArrived(object sender, PublishArrivedArgs e)
 {
     Console.WriteLine("Received Message");
     Console.WriteLine("Topic: " + e.Topic);
     Console.WriteLine("Payload: " + e.Payload);
     Console.WriteLine();
     return(true);
 }
Example #7
0
 public Message(PublishArrivedArgs e)
 {
     datetime = DateTime.Now;
     topic    = e.Topic;
     payload  = e.Payload.ToString();
     name     = StaticResources.QosToName(e.QualityOfService);
     retained = e.Retained ? "是" : "否";
 }
Example #8
0
        bool client_PublishArrived(object sender, PublishArrivedArgs e)
        {
            HandleMessage(e);

            messageArgs = e;
            this.bgw3.RunWorkerAsync();

            return(true);
        }
Example #9
0
        private bool Mqtt_PublishArrived(object sender, PublishArrivedArgs e)
        {
            Message message = new Message(e);

            StaticResources.messageQueue.Enqueue("时间:" + DateTime.Now.ToString() +
                                                 "收到推送信息:" + message);
            StaticResources.publiishQueue.Enqueue(message);
            return(true);
        }
Example #10
0
 //Message Recieved function is called whenever a publish is recieved, it sends the payload to any and all gameobjects subscribed to the published topic
 bool MessageRecieved(object sender, PublishArrivedArgs e)
 {
     if (m_subscribers.ContainsKey(e.Topic))
     {
         foreach (mqttClient g in m_subscribers[e.Topic])
         {
             g.TransferPayload(e.Topic, e.Payload);
         }
     }
     return(true);
 }
Example #11
0
    protected bool client_PublishArrived(object sender, PublishArrivedArgs e)
    {
        Debug.Log("Received Message");
        Debug.Log("Topic: " + e.Topic);
        Debug.Log("Payload: " + e.Payload);


        var message = e.Payload.ToString().Trim('\"');

        messageQueue.Enqueue(message);

        return(true);
    }
 bool client_PublishArrived(object sender, PublishArrivedArgs e)
 {
     //IncomMessage = "Topic: " + e.Topic + "Payload: " + e.Payload;
     if (e.Topic == "RXPicture")
     {
         InComPicture = e.Payload;
     }
     else
     {
         IncomMessage = e.Payload;
     }
     aTimer.Enabled = true; //disable timer
     return(true);
 }
Example #13
0
        bool client_PublishArrived(object sender, PublishArrivedArgs e)
        {
            var m = MQTTMessage.Parse(e.Payload.ToString(), e.Topic);

            if (m.ClientId == this._clientId)
            {
                // Ignore message sent by this instance
                return(false);
            }
            else
            {
                if (this.MessageArrived != null)
                {
                    this.MessageArrived(m);
                }
                return(true);
            }
        }
Example #14
0
        private bool ClientPublishArrived(object sender, PublishArrivedArgs e)
        {
            Device.BeginInvokeOnMainThread(() =>
            {
                switch (e.Topic)
                {
                case "car/STATE":
                    StatusText.Text = e.Payload.ToString();
                    return;

                case "car/RESPOND":
                    Toaster(e.Payload.ToString());
                    break;

                case "car/STATUS":
                    Toaster(e.Payload.ToString(), ToastPriority.High);
                    break;
                }
            });
            return(true);
        }
Example #15
0
 private bool client_PublishArrived(object sender, PublishArrivedArgs e)
 {
     label1.Text = e.Payload;
     return(true);
 }
        bool client_PublishArrived(object sender, PublishArrivedArgs e)
        {
            /*
             * Console.WriteLine("Received Message");
             * Console.WriteLine("Topic: " + e.Topic);
             * Console.WriteLine("Payload: " + e.Payload);
             * Console.WriteLine();*/



            string sAction = string.Empty;
            string sDst    = string.Empty;

            //{ "src":"BN83I6IIBX3QP1DS4Y8URO41P2VWOTY9","dst":"aaabbbccc_111222333","msg":"hello"}

            //{ "src":"K91NS8PPF1B7KLNI2VWGO0D49HOM524T","dst":"testid000001_testst000001","msg":"hello"}
            //{"src":"K91NS8PPF1B7KLNI2VWGO0D49HOM524T","dst":"testid000001_testst000001","msg":"start"}
            //{"src":"K91NS8PPF1B7KLNI2VWGO0D49HOM524T","dst":"testid000001_testst000001","msg":"prev"}
            //{"src":"K91NS8PPF1B7KLNI2VWGO0D49HOM524T","dst":"testid000001_testst000001","msg":"next"}

            message_recv = JsonHelper.DeserializeJsonToObject <MQTTMessage_Recv>(e.Payload.ToString());

            sAction = message_recv.msg.ToString().ToLower();
            sDst    = message_recv.dst.ToString();
            strSRC  = message_recv.src.ToString();

            bool isPPTRunning = CheckPPTISRunning(); //确保 sProceName 全局变量被赋值

            if (strDst == sDst)
            {
                if (sAction == "hello")
                {
                    if (!isPPTRunning)
                    {
                        SendState("0");
                    }
                    else
                    {
                        //btnClose.Visible = true;



                        if (ProcessHelper.ProcessIsFront(sProceName))
                        {
                            SendState("3");
                        }
                        else
                        {
                            SendState("1");
                        }
                    }
                }
                else if (sAction == "start")
                {
                    ProcessHelper.BringWindowToFrontNow(sProceName);
                    InputSMLTR.SimulateKeyPress(VirtualKeyCode.F5);
                }
                else if (sAction == "prev")
                {
                    ProcessHelper.BringWindowToFrontNow(sProceName);
                    InputSMLTR.SimulateKeyPress(VirtualKeyCode.UP);
                }
                else if (sAction == "next")
                {
                    ProcessHelper.BringWindowToFrontNow(sProceName);
                    InputSMLTR.SimulateKeyPress(VirtualKeyCode.DOWN);
                }
            }


            return(true);
        }
Example #17
0
        private bool MqttC_PublishArrived(object sender, PublishArrivedArgs e)
        {
            log.Debug("Mqtt Rx : " + e.Topic + " : " + e.Payload);
            string[]    topic   = e.Topic.Substring(mqttPreTopic.Length).Split('/');
            string      payload = e.Payload;
            ColoreColor c;

            try
            {
                c = HexToColore(payload);
            }
            catch
            {
                log.Error(payload + " is no valid color");
                return(false);
            }

            if (topic.Length >= 1)
            {
                switch (topic[0].ToLower())
                {
                case "set":
                    if (topic.Length >= 2)
                    {
                        switch (topic[1].ToLower())
                        {
                        case "all":
                            chroma.SetAllAsync(c);
                            break;

                        case "keyboard":
                            if (topic.Length >= 3)
                            {
                                switch (topic[2].ToLower())
                                {
                                case "all":
                                    chroma.Keyboard.SetAllAsync(c);
                                    break;

                                case "key":
                                    if (topic.Length < 4)
                                    {
                                        log.Error("Key is not specified ");
                                        return(false);
                                    }
                                    Key key;
                                    if (Enum.TryParse(topic[3], out key))
                                    {
                                        chroma.Keyboard[key] = c;
                                    }
                                    else
                                    {
                                        log.Error($"\"{topic[3]}\" is no valid key");
                                        return(false);
                                    }
                                    break;

                                case "grid":
                                    if (topic.Length < 5)
                                    {
                                        log.Error("Position is not specified ");
                                        return(false);
                                    }
                                    int row, column;
                                    if (!int.TryParse(topic[3], out row))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (!int.TryParse(topic[4], out column))
                                    {
                                        log.Error($"\"{topic[4]}\" NaN");
                                        return(false);
                                    }
                                    if (row < 0 || row >= KeyboardConstants.MaxRows)
                                    {
                                        log.Error($"\"{row}\" out of range. Max:" + (KeyboardConstants.MaxRows - 1));
                                        return(false);
                                    }
                                    if (column < 0 || column >= KeyboardConstants.MaxColumns)
                                    {
                                        log.Error($"\"{column}\" out of range. Max:" + (KeyboardConstants.MaxColumns - 1));
                                        return(false);
                                    }
                                    chroma.Keyboard[row, column] = c;
                                    break;

                                case "zone":
                                    if (topic.Length < 4)
                                    {
                                        log.Error("Zone is not specified ");
                                        return(false);
                                    }
                                    int zone;
                                    if (!int.TryParse(topic[3], out zone))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (zone < 0 || zone >= KeyboardConstants.MaxDeathstalkerZones)
                                    {
                                        log.Error($"\"{zone}\" out of range. Max:" + (KeyboardConstants.MaxDeathstalkerZones - 1));
                                        return(false);
                                    }
                                    chroma.Keyboard[zone] = c;
                                    break;

                                default:
                                    log.Error($"\"{topic[2]}\" unknown");
                                    return(false);
                                }
                            }
                            else
                            {
                                log.Error("no specification (\"all\", \"key\", \"grid\", \"zone\")");
                                return(false);
                            }
                            break;

                        case "keypad":
                            if (topic.Length >= 3)
                            {
                                switch (topic[2].ToLower())
                                {
                                case "all":
                                    chroma.Keypad.SetAllAsync(c);
                                    break;

                                case "grid":
                                    if (topic.Length < 5)
                                    {
                                        log.Error("Position is not specified ");
                                        return(false);
                                    }
                                    int row, column;
                                    if (!int.TryParse(topic[3], out row))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (!int.TryParse(topic[4], out column))
                                    {
                                        log.Error($"\"{topic[4]}\" NaN");
                                        return(false);
                                    }
                                    if (row < 0 || row >= Colore.Effects.Keypad.KeypadConstants.MaxRows)
                                    {
                                        log.Error($"\"{row}\" out of range. Max:" + (Colore.Effects.Keypad.KeypadConstants.MaxRows - 1));
                                        return(false);
                                    }
                                    if (column < 0 || column >= Colore.Effects.Keypad.KeypadConstants.MaxColumns)
                                    {
                                        log.Error($"\"{column}\" out of range. Max:" + (Colore.Effects.Keypad.KeypadConstants.MaxColumns - 1));
                                        return(false);
                                    }
                                    chroma.Keypad[row, column] = c;
                                    break;

                                default:
                                    log.Error($"\"{topic[2]}\" unknown");
                                    return(false);
                                }
                            }
                            else
                            {
                                log.Error("no specification (\"all\", \"grid\")");
                                return(false);
                            }
                            break;

                        case "mouse":
                            if (topic.Length >= 3)
                            {
                                switch (topic[2].ToLower())
                                {
                                case "all":
                                    chroma.Mouse.SetAllAsync(c);
                                    break;

                                case "gridled":
                                    if (topic.Length < 4)
                                    {
                                        log.Error("Key is not specified ");
                                        return(false);
                                    }
                                    Colore.Effects.Mouse.GridLed gridLed;
                                    if (Enum.TryParse(topic[3], out gridLed))
                                    {
                                        chroma.Mouse[gridLed] = c;
                                    }
                                    else
                                    {
                                        log.Error($"\"{topic[3]}\" is no valid GridLed");
                                        return(false);
                                    }
                                    break;

                                case "grid":
                                    if (topic.Length < 5)
                                    {
                                        log.Error("Position is not specified ");
                                        return(false);
                                    }
                                    int row, column;
                                    if (!int.TryParse(topic[3], out row))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (!int.TryParse(topic[4], out column))
                                    {
                                        log.Error($"\"{topic[4]}\" NaN");
                                        return(false);
                                    }
                                    if (row < 0 || row >= Colore.Effects.Mouse.MouseConstants.MaxRows)
                                    {
                                        log.Error($"\"{row}\" out of range. Max:" + (Colore.Effects.Mouse.MouseConstants.MaxRows - 1));
                                        return(false);
                                    }
                                    if (column < 0 || column >= Colore.Effects.Mouse.MouseConstants.MaxColumns)
                                    {
                                        log.Error($"\"{column}\" out of range. Max:" + (Colore.Effects.Mouse.MouseConstants.MaxColumns - 1));
                                        return(false);
                                    }
                                    chroma.Mouse[row, column] = c;
                                    break;

                                default:
                                    log.Error($"\"{topic[2]}\" unknown");
                                    return(false);
                                }
                            }
                            else
                            {
                                log.Error("no specification (\"all\", \"gridled\", \"grid\")");
                                return(false);
                            }
                            break;

                        case "mousepad":
                            if (topic.Length >= 3)
                            {
                                switch (topic[2].ToLower())
                                {
                                case "all":
                                    chroma.Mousepad.SetAllAsync(c);
                                    break;

                                case "index":
                                    if (topic.Length < 4)
                                    {
                                        log.Error("Index is not specified ");
                                        return(false);
                                    }
                                    int index;
                                    if (!int.TryParse(topic[3], out index))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (index < 0 || index >= Colore.Effects.Mousepad.MousepadConstants.MaxLeds)
                                    {
                                        log.Error($"\"{index}\" out of range. Max:" + (Colore.Effects.Mousepad.MousepadConstants.MaxLeds - 1));
                                        return(false);
                                    }
                                    chroma.Mousepad[index] = c;
                                    break;

                                default:
                                    log.Error($"\"{topic[2]}\" unknown");
                                    return(false);
                                }
                            }
                            else
                            {
                                log.Error("no specification (\"all\", \"index\")");
                                return(false);
                            }
                            break;

                        case "headset":
                            if (topic.Length >= 3)
                            {
                                switch (topic[2].ToLower())
                                {
                                case "all":
                                    chroma.Headset.SetAllAsync(c);
                                    break;

                                case "index":
                                    if (topic.Length < 4)
                                    {
                                        log.Error("Index is not specified ");
                                        return(false);
                                    }
                                    int index;
                                    if (!int.TryParse(topic[3], out index))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (index < 0 || index >= Colore.Effects.Headset.HeadsetConstants.MaxLeds)
                                    {
                                        log.Error($"\"{index}\" out of range. Max:" + (Colore.Effects.Headset.HeadsetConstants.MaxLeds - 1));
                                        return(false);
                                    }
                                    chroma.Headset[index] = c;
                                    break;

                                default:
                                    log.Error($"\"{topic[2]}\" unknown");
                                    return(false);
                                }
                            }
                            else
                            {
                                log.Error("no specification (\"all\", \"index\")");
                                return(false);
                            }
                            break;

                        case "link":
                            if (topic.Length >= 3)
                            {
                                switch (topic[2])
                                {
                                case "all":
                                    chroma.ChromaLink.SetAllAsync(c);
                                    break;

                                case "index":
                                    if (topic.Length < 4)
                                    {
                                        log.Error("Index is not specified ");
                                        return(false);
                                    }
                                    int index;
                                    if (!int.TryParse(topic[3], out index))
                                    {
                                        log.Error($"\"{topic[3]}\" NaN");
                                        return(false);
                                    }
                                    if (index < 0 || index >= Colore.Effects.ChromaLink.ChromaLinkConstants.MaxLeds)
                                    {
                                        log.Error($"\"{index}\" out of range. Max:" + (Colore.Effects.ChromaLink.ChromaLinkConstants.MaxLeds - 1));
                                        return(false);
                                    }
                                    chroma.ChromaLink[index] = c;
                                    break;

                                default:
                                    log.Error($"\"{topic[2]}\" unknown");
                                    return(false);
                                }
                            }
                            else
                            {
                                log.Error("no specification (\"all\", \"index\")");
                                return(false);
                            }
                            break;

                        default:
                            log.Error($"\"{topic[1]}\" unknown");
                            return(false);
                        }
                        string retTopic = "state";
                        for (int i = 1; i < topic.Length; i++)
                        {
                            retTopic += "/" + topic[i];
                        }
                        mqttClient.Publish(mqttPreTopic + retTopic, new MqttPayload(ColoreToHex(c)), QoS.BestEfforts, false);
                    }
                    break;

                default:
                    log.Error($"\"{topic[0]}\" unknown");
                    return(false);
                }
            }
            return(true);
        }
 private bool client_PublishArrived(object sender, PublishArrivedArgs e)
 {
     throw new NotImplementedException();
 }