Beispiel #1
0
        // MAIN PROCESS PIPE EVENT LOOP
        private async Task _processServerMessages(Stream stream)
        {
            var message = await readObjectAsync(stream);

            if (message == null)
            {
                return;
            }

            if (message.command == NKRemotingMessage.Command.NKevaluateJavaScript)
            {
                var _ = context.NKevaluateJavaScript(message.args[0], message.args[1]);
            }
            else if (message.command == NKRemotingMessage.Command.NKEvent)
            {
                var     eventType   = message.args[0];
                NKEvent eventObject = new NKEvent((IDictionary <string, object>)(NKData.jsonDeserialize(message.args[1])));
                NKEventEmitter.global.emit <NKEvent>(eventType, eventObject, false);
            }

            if (!cancelToken.IsCancellationRequested)
            {
                await _processServerMessages(stream);
            }
            else
            {
                return;
            }
        }
Beispiel #2
0
        private void eventForwarderFromRenderer(string eventType, NKEvent nke)
        {
            var handshake = new NKRemotingMessage();

            handshake.command = NKRemotingMessage.Command.NKEvent;
            var eventSerialized = NKData.jsonSerialize(nke);

            handshake.args = new string[] { eventType, eventSerialized };
            writeObject(asyncPipe, handshake);
        }
Beispiel #3
0
        private static string serialize(object obj)
        {
            IFormatProvider invariant = System.Globalization.CultureInfo.InvariantCulture;
            Type            t         = obj.GetType();
            TypeInfo        ti        = t.GetTypeInfo();

            if (obj == null)
            {
                return("undefined");
            }

            if (obj != null && obj.GetType().GetTypeInfo().IsPrimitive)
            {
                // The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single.
                if (obj is Char)
                {
                    return("'" + Convert.ToString(((Char)obj), invariant) + "'");
                }

                if (obj is Boolean)
                {
                    return((Boolean)obj ? "true" : "false");
                }

                return(Convert.ToString(obj, System.Globalization.CultureInfo.InvariantCulture));
            }

            if (obj is string)
            {
                var str = NKData.jsonSerialize((string)obj);
                return(str); //  str.Substring(1, str.Length - 2);
            }

            if (obj is DateTime)
            {
                return("\"" + ((DateTime)obj).ToString("u") + "\"");
            }

            if (typeof(IDictionary).GetTypeInfo().IsAssignableFrom(ti))
            {
                var genericKey = ti.GenericTypeArguments[0];
                if (typeof(string).GetTypeInfo().IsAssignableFrom(genericKey.GetTypeInfo()))
                {
                    var dict = (IDictionary <string, object>)obj;
                    return("{" + string.Join(", ", dict.Keys.Select(k => "\"" + k + "\":" + serialize(dict[k]))) + "}");
                }
            }

            if (typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(ti))
            {
                return("[" + string.Join(", ", ((IEnumerable <dynamic>)obj).Select(o => serialize(o))) + "]");
            }

            return(Convert.ToString(obj, System.Globalization.CultureInfo.InvariantCulture));
        }
Beispiel #4
0
        // RENDERER PROCESS PIPE EVENT LOOP
        private async Task _processClientMessages()
        {
            var message = await readObjectAsync(syncPipeIn);

            if (message == null)
            {
                NKLogging.log("!Renderer Received Empty Message");
                cancelTokenSource.Cancel();
                return;
            }

            if (message.command == NKRemotingMessage.Command.NKScriptMessageSync)
            {
                var name = message.args[0];
                Dictionary <string, object> body = null;
                try
                {
                    body = context.NKdeserialize(message.args[1]) as Dictionary <string, object>;
                }
                catch (Exception ex)
                {
                    NKLogging.log("!Renderer Message Deserialization Error: " + ex.Message);
                }
                var nks = new NKScriptMessage(name, body);

                NKScriptMessageHandler handler = null;
                if (_localHandlers.ContainsKey(name))
                {
                    handler = _localHandlers[name];
                }
                else
                {
                    int target = Int32.Parse(body["$target"].ToString());
                    handler = NKScriptChannel.getNative(target);
                }
                if (handler != null)
                {
                    var nkr = new NKRemotingMessage();
                    nkr.command = NKRemotingMessage.Command.NKScriptMessageSyncReply;

                    try
                    {
                        var result = handler.didReceiveScriptMessageSync(nks);
                        nkr.args = new string[] { context.NKserialize(result) };
                    } catch (Exception ex)
                    {
                        NKLogging.log("!Renderer Message Processing Error: " + ex.Message);
                        NKLogging.log(ex.StackTrace);
                        nkr.args = new string[] { };
                    }
                    writeObject(syncPipeOut, nkr);
                }
                else
                {
                    NKLogging.log("+Renderer Received Unknown Script Message Sync");
                }
            }
            else if (message.command == NKRemotingMessage.Command.NKScriptMessage)
            {
                var name = message.args[0];
                Dictionary <string, object> body = null;
                try
                {
                    body = context.NKdeserialize(message.args[1]) as Dictionary <string, object>;
                }
                catch (Exception ex)
                {
                    NKLogging.log("!Renderer Message Deserialization Error: " + ex.Message);
                }
                var nks = new NKScriptMessage(name, body);

                NKScriptMessageHandler handler = null;
                if (_localHandlers.ContainsKey(name))
                {
                    handler = _localHandlers[name];
                }
                else
                {
                    int target = Int32.Parse(body["$target"].ToString());
                    handler = NKScriptChannel.getNative(target);
                }
                if (handler != null)
                {
                    handler.didReceiveScriptMessage(nks);
                }
                else
                {
                    NKLogging.log("+Renderer Received Unknown Script Message " + message.args[1]);
                }
            }
            else if (message.command == NKRemotingMessage.Command.NKRemotingClose)
            {
                try
                {
                    syncPipeIn.Close();
                    syncPipeOut.Close();
                    asyncPipe.Close();
                }
                catch { }

                Environment.Exit(0);
            }
            else if (message.command == NKRemotingMessage.Command.NKEvent)
            {
                var     eventType   = message.args[0];
                NKEvent eventObject = new NKEvent((IDictionary <string, object>)(NKData.jsonDeserialize(message.args[1])));
                NKEventEmitter.global.emit <NKEvent>(eventType, eventObject, false);
            }

            if (!cancelToken.IsCancellationRequested)
            {
                await _processClientMessages();
            }
            else
            {
                return;
            }
        }