Mam usługę WebSocket, która działa świetnie po załadowaniu strony. Jednakże, jeśli połączenie zostanie utracone, a usługa próbuje podłączyć, otrzymuję błąd: "Nieprzemoc ReededError: Usługa nie jest zdefiniowana". Gdy ręcznie odświeżę stronę, serwis działa ponownie. Jak mogę ponownie połączyć się bez odświeżania strony? Aplikacja musi przywrócić to połączenie bez zaangażowania użytkownika. Jest to moja pierwsza aplikacja kątowa, więc nadal jestem w trakcie uczenia się ram. Dziękuję Ci.

angular.module('proApp').factory('webSocketService',
    ['$q', '$rootScope', function($q, $rootScope) {

            var timeout = 2000;
            var clearTimer = -1;
            var port = '8081';
            var server = '127.0.0.1';
            var socket;
            var host;
            var Service = {};

            function getSocketState() {
                return (socket != null) ? socket.readyState : 0;
            }

            function onMessage(e) {
                //console.log(e.data);
                Service.message = JSON.parse(e.data);

                $rootScope.$apply(function() {
                    Service.send();
                });
            }
            //allows data to be used in controller
            Service.send = function() {
                $rootScope.$broadcast('broadcast');
            };
            function onError() {
                clearInterval(clearTimer);
                socket.onclose = function() {
                };
                clearTimer = setInterval("Service.getData()", timeout);
            }

            function onClose() {
                clearInterval(clearTimer);
                clearTimer = setInterval("Service.getData()", timeout);

            }

            function onOpen() {
                clearInterval(clearTimer);
                console.log("open" + getSocketState());
            }

            Service.getData = function() {

                if ("WebSocket" in window) {
                    if (getSocketState() === 1) {
                        socket.onopen = onOpen;
                        clearInterval(clearTimer);
                        console.log(getSocketState());
                    } else {
                        try {
                            host = "ws://" + server + ":" + port + '';
                            socket = new WebSocket(host);
                            socket.onopen = onOpen;
                            socket.onmessage = function(e) {
                                onMessage(e);
                            };
                            socket.onerror = onError;
                            socket.onclose = onClose;
                        } catch (exeption) {
                            console.log(exeption);
                        }
                    }
                }
            };
            // Public API here
            return Service;

        }]);
1
kaplievabell 16 sierpień 2014, 00:56

1 odpowiedź

To jest kod, którego używam, może:

  • Podłącz ponownie, jeśli połączenie zostanie utracone.
  • elementy kolejki podczas rozłączania i wysyłania ich na ponowne połączenie.
  • regularne subskrybowanie metody "słuchania".
  • "Słuchaj" na zdarzenie raz z obietnicą, po czym subskrypcja zostanie usunięta. Idealny do żądania / odpowiedzi za pomocą korelacji
  • $ rootscope.WeBsocketavailable Wskazuje, gdy połączenie jest dostępne.
  • $ rootscope.QuedMessages wskazuje, gdy są w oczekiwaniu na przesłanie wiadomości.

Wciąż jest częścią projektu w rozwoju, ale myślę, że możesz uzyskać pomysł:

.service('$connection', ["$q", "$timeout", "websocketUrl", "$rootScope", function ($q, $timeout, websocketUrl, $rootScope) {
    var connection = function () {

        var me = {};
        var listeners = [];
        var oneListeners = [];

        me.isConnected = false;

        oneListeners.removeOne = function (listener) {
            var index = oneListeners.indexOf(listener);
            if(index!=-1)
                oneListeners.splice(index, 1);
        };

        var correlationId = 0;
        me.nextCorrelationId = function () {
            return correlationId++;
        };

        $rootScope.queuedMessages = [];

        me.listen = function (predicate, handler) {
            listeners.push({ p: predicate, h: handler });
        };

        me.listenOnce = function (predicate, timeout) {
            var deferred = $q.defer();
            deferred.done = false;
            var listener = { d: deferred, p: predicate };
            oneListeners.push(listener);
            if (timeout) {
                $timeout(function () {
                    if (!deferred.done)
                        deferred.reject('timeout');
                    oneListeners.removeOne(listener);
                }, timeout);
            }
            var promise = deferred.promise;
            promise.then(function (data) {
                deferred.done = true;
            });
            return promise;
        };

        var onopen = function () {
            console.log('onopen');
            $rootScope.websocketAvailable = true;
            me.isConnected = true;
            $rootScope.$$phase || $rootScope.$apply();
            if ($rootScope.queuedMessages) {
                for (var i = 0; i < $rootScope.queuedMessages.length; i++) {
                    ws.send(JSON.stringify($rootScope.queuedMessages[i]));
                }
                $rootScope.queuedMessages = null;
                $rootScope.$$phase || $rootScope.$apply();
            }
        };

        var onclose = function () {
            console.log('onclose');
            me.isConnected = false;
            $rootScope.websocketAvailable = false;
            $rootScope.$$phase || $rootScope.$apply();
            $rootScope.queuedMessages = $rootScope.queuedMessages || [];

            setTimeout(function () {
                ws = connect();
            }, 5000);
        };

        var onmessage = function (msg) {
            console.log('onmessage');
            var obj = JSON.parse(msg.data);
            for (var i = 0; i < listeners.length; i++) {
                var listener = listeners[i];
                if (listener.p(obj))
                    listener.h(obj);
            }
            var remove = [];
            for (var i = 0; i < oneListeners.length; i++) {
                var listener = oneListeners[i];
                if (listener.p(obj)) {
                    var o = obj;
                    listener.d.resolve(o);
                    remove.push(listener);
                }
            }
            for (var i = 0; i < remove.length; i++) {
                oneListeners.removeOne(remove[i]);
            }
        };

        var onerror = function () {
            console.log('onerror');
        };

        me.send = function (obj) {

            if ($rootScope.queuedMessages)
                $rootScope.queuedMessages.push(obj);
            else
                ws.send(JSON.stringify(obj));
        }

        var setHandlers = function (w) {
            w.onopen = onopen;
            w.onclose = onclose;
            w.onmessage = onmessage;
            w.onerror = onerror;
        };

        var connect = function () {
            console.log('connecting...');
            var w = new WebSocket(websocketUrl);
            setHandlers(w);
            return w;
        }

        var ws = connect();

        return me;
    };
    return connection();
}])
0
vtortola 17 sierpień 2014, 12:02