/**
 * Make sure the charset of the page using this script is
 * set to utf-8 or you will not get the correct results.
 */
var utf8 = (function () {
    var highSurrogateMin = 0xd800,
        highSurrogateMax = 0xdbff,
        lowSurrogateMin  = 0xdc00,
        lowSurrogateMax  = 0xdfff,
        surrogateBase    = 0x10000;
    
    function isHighSurrogate(charCode) {
        return highSurrogateMin <= charCode && charCode <= highSurrogateMax;
    }
    
    function isLowSurrogate(charCode) {
        return lowSurrogateMin <= charCode && charCode <= lowSurrogateMax;
    }
    
    function combineSurrogate(high, low) {
        return ((high - highSurrogateMin) << 10) + (low - lowSurrogateMin) + surrogateBase;
    }
    
    /**
     * Convert charCode to JavaScript String
     * handling UTF16 surrogate pair
     */
    function chr(charCode) {
        var high, low;
        
        if (charCode < surrogateBase) {
            return String.fromCharCode(charCode);
        }
        
        // convert to UTF16 surrogate pair
        high = ((charCode - surrogateBase) >> 10) + highSurrogateMin,
        low  = (charCode & 0x3ff) + lowSurrogateMin;
        
        return String.fromCharCode(high, low);
    }
    
    /**
     * Convert JavaScript String to an Array of
     * UTF8 bytes
     * @export
     */
    function stringToBytes(str) {
        var bytes = [],
            strLength = str.length,
            strIndex = 0,
            charCode, charCode2;
        
        while (strIndex < strLength) {
            charCode = str.charCodeAt(strIndex++);
            
            // handle surrogate pair
            if (isHighSurrogate(charCode)) {
                if (strIndex === strLength) {
                    throw new Error('Invalid format');
                }
                
                charCode2 = str.charCodeAt(strIndex++);
                
                if (!isLowSurrogate(charCode2)) {
                    throw new Error('Invalid format');
                }
                
                charCode = combineSurrogate(charCode, charCode2);
            }
            
            // convert charCode to UTF8 bytes
            if (charCode < 0x80) {
                // one byte
                bytes.push(charCode);
            }
            else if (charCode < 0x800) {
                // two bytes
                bytes.push(0xc0 | (charCode >> 6));
                bytes.push(0x80 | (charCode & 0x3f));
            }
            else if (charCode < 0x10000) {
                // three bytes
                bytes.push(0xe0 | (charCode >> 12));
                bytes.push(0x80 | ((charCode >> 6) & 0x3f));
                bytes.push(0x80 | (charCode & 0x3f));
            }
            else {
                // four bytes
                bytes.push(0xf0 | (charCode >> 18));
                bytes.push(0x80 | ((charCode >> 12) & 0x3f));
                bytes.push(0x80 | ((charCode >> 6) & 0x3f));
                bytes.push(0x80 | (charCode & 0x3f));
            }
        }
        
        return bytes;
    }

    /**
     * Convert an Array of UTF8 bytes to
     * a JavaScript String
     * @export
     */
    function bytesToString(bytes) {
        var str = '',
            length = bytes.length,
            index = 0,
            byte,
            charCode;
        
        while (index < length) {
            // first byte
            byte = bytes[index++];
            
            if (byte < 0x80) {
                // one byte
                charCode = byte;
            }
            else if ((byte >> 5) === 0x06) {
                // two bytes
                charCode = ((byte & 0x1f) << 6) | (bytes[index++] & 0x3f);
            }
            else if ((byte >> 4) === 0x0e) {
                // three bytes
                charCode = ((byte & 0x0f) << 12) | ((bytes[index++] & 0x3f) << 6) | (bytes[index++] & 0x3f);
            }
            else {
                // four bytes
                charCode = ((byte & 0x07) << 18) | ((bytes[index++] & 0x3f) << 12) | ((bytes[index++] & 0x3f) << 6) | (bytes[index++] & 0x3f);
            }
            
            str += chr(charCode);
        }
        
        return str;
    }
    
    return {
        stringToBytes: stringToBytes,
        bytesToString: bytesToString
    };
}());

'use strict';

var app = angular.module('app', [
    'ui.router',
    'templatescache',
    'ngAnimate'
    ]);
angular.module('app').run(['$rootScope', '$state', '$stateParams',
    function($rootScope, $state, $stateParams) {
        $rootScope.$state = $state;
        $rootScope.$stateParams = $stateParams;
    }
]).config(['$stateProvider', '$urlRouterProvider',
    function($stateProvider, $urlRouterProvider) {
        $urlRouterProvider.otherwise('/peer'); //
        $stateProvider.state('peer', {
                url: '/peer',
                templateUrl: 'templates/peer.html',
                controller: 'PeerController'
            });
    }
])
angular.module('templatescache', []).run(['$templateCache', function($templateCache) {$templateCache.put('templates/peer.html','<div style="margin:5px">\n\n</div>');}]);
'use strict';

angular.module('app').controller('PeerController', ['$scope', '$state', '$timeout', function ($scope, $state, $timeout) {

    lxtalkClient.Invoke('{C62F6059-7741-4AC1-8B8F-97EB5F7C116C}', '_Register', '', $scope);
    var onConnected = function (c) {
        c.on('data', function (data) {
            //to do
            console.info(data);
        });
        c.on('close', function () {
            delete $scope.connectedPeers[c.peer];
        });
        $scope.connectedPeers[c.peer] = 1;
    };

    $scope.options = {
        host: '120.26.136.253',
        port: 9000,
        debug: 3,
        config: {
            'iceServers': [{
                    'url': 'stun:lqq@59.110.63.164',
                    "credential": "123456"
                },
                {
                    "url": "turn:lqq@59.110.63.164",
                    "credential": "123456"
                }
            ]
        },
        key: 'peerjs',
        logFunction: function () {
            var copy = Array.prototype.slice.call(arguments).join(' ');
            console.info(copy);
        }
    }

    $scope.init = function (jsonStr) {
        console.log(jsonStr);
        var data = JSON.parse(jsonStr);
        $scope.loginName = data.loginName;
        $scope.peer = new Peer(
            $scope.loginName,
            $scope.options
        );
        $scope.connectedPeers = {};
        $scope.peer.on('open', function (id) {
            console.log(id);
        });
        $scope.peer.on('connection', onConnected);
        $scope.peer.on('error', function (err) {
            $timeout(function () {
                $scope.init(jsonStr);
            }, 5000);
        });
    };

    $scope.connect = function (jsonStr) {
        var data = JSON.parse(jsonStr);
        if (!$scope.connectedPeers[data.loginName]) {
            var c = $scope.peer.connect(data.loginName, data);
            c.on('open', function () {
                onConnected(c);
            });
            c.on('error', function (err) {
                console.log(err);
            });
            $scope.connectedPeers[data.loginName] = 1;
        }
    };

    $scope.send = function (jsonStr, data) {
        var param = JSON.parse(jsonStr);
        var buf = new Uint8Array(data);
        // var str = utf8.bytesToString(buf);//new TextDecoder().decode(uint8array); data.toString('utf8')//String.fromCharCode.apply(null, buf);

        console.info(buf);
        var blob = new Blob(buf)
        var c = $scope.peer.connections[param.loginName];
        if (c) {
            c.send(blob);
        }

        // var reader = new FileReader();
        // reader.readAsText(blob, 'utf-8');
        // reader.onload = function (e) {
        //     console.info(reader.result);
        // }
    };

    $scope.close = function (jsonStr) {
        var c = $scope.peer.connections[param.loginName];
        if (c) {
            c.close();
        }
    };

    $scope.closeAll = function (jsonStr) {
        _.forEach($scope.peer.connections, function (c) {
            c.close();
        });
    };

    $scope.destroy = function (jsonStr) {
        $scope.peer.destroy();
    };
}]);