Merge pull request #2570 from pine613/feature/chrome/sockets

Add chrome.sockets.*
2026-09-09 11:13:57 +08:00 · 2014-07-29 10:27:51 +10:00
parent e50b02dcd6 f4dbe8f1e7
commit 44ae7bd485
2 changed files with 437 additions and 2 deletions
@@ -24,4 +24,253 @@ chrome.app.runtime.onLaunched.addListener(function (launchData: runtime.LaunchDa
 chrome.app.runtime.onRestarted.addListener(function () { return; });

 // Get Current Window
-var currentWindow: cwindow.AppWindow = chrome.app.window.current();
+var currentWindow: cwindow.AppWindow = chrome.app.window.current();
+
+// Sockets
+// https://developer.chrome.com/apps/sockets_tcp
+function test_socketsTcp(): void {
+    var socketId: number;
+    var properties: chrome.sockets.tcp.SocketProperties = {};
+    var buffer: ArrayBuffer = new ArrayBuffer(256);
+    
+    // create
+    chrome.sockets.tcp.create((info) => {
+        socketId = info.socketId;
+    });
+
+    chrome.sockets.tcp.create(properties, (info) => {
+        socketId = info.socketId;
+    });
+
+    // update
+    chrome.sockets.tcp.update(socketId, properties);
+    chrome.sockets.tcp.update(socketId, properties, () => { });
+
+    // setPaused
+    chrome.sockets.tcp.setPaused(socketId, true);
+    chrome.sockets.tcp.setPaused(socketId, true, () => { });
+
+    // setKeepAlive
+    chrome.sockets.tcp.setKeepAlive(socketId, true, (result: number) => { });
+    chrome.sockets.tcp.setKeepAlive(socketId, true, 0, (result: number) => { });
+
+    // setNoDelay
+    chrome.sockets.tcp.setNoDelay(socketId, true, (result: number) => { });
+
+    // connect
+    chrome.sockets.tcp.connect(socketId, "192.168.0.1", 8080, (result: number) => { });
+
+    // disconnect
+    chrome.sockets.tcp.disconnect(socketId);
+    chrome.sockets.tcp.disconnect(socketId, () => { });
+
+    // send
+    chrome.sockets.tcp.send(socketId, buffer, (info: chrome.sockets.tcp.SendInfo) => { });
+
+    // close
+    chrome.sockets.tcp.close(socketId);
+    chrome.sockets.tcp.close(socketId, () => { });
+
+    // getInfo
+    chrome.sockets.tcp.getInfo(socketId, (info: chrome.sockets.tcp.SocketInfo) => { });
+
+    // getSockets
+    chrome.sockets.tcp.getSockets(socketId, (infos: chrome.sockets.tcp.SocketInfo[]) => { });
+}
+
+function test_socketsTcpEvents(): void {
+    chrome.sockets.tcp.onReceive.addListener((info: chrome.sockets.tcp.ReceiveEventArgs) => { });
+    chrome.sockets.tcp.onReceiveError.addListener((info: chrome.sockets.tcp.ReceiveErrorEventArgs) => { });
+}
+
+function testSocketsTcpTypes(): void {
+    // SocketProperties
+    var properties: chrome.sockets.tcp.SocketProperties;
+
+    properties = {
+    };
+
+    properties = {
+        persistent: true,
+        name: "test",
+        bufferSize: 1024
+    };
+
+    // SocketInfo
+    var socketInfo: chrome.sockets.tcp.SocketInfo;
+
+    socketInfo = {
+        socketId: 1,
+        persistent: true,
+        paused: true,
+        connected: false
+    };
+
+    socketInfo.name = "test";
+    socketInfo.bufferSize = 1024;
+    socketInfo.localAddress = "192.168.0.2";
+    socketInfo.localPort = 8000;
+    socketInfo.peerAddress = "192.168.0.3";
+    socketInfo.peerPort = 1000;
+}
+
+// https://developer.chrome.com/apps/sockets_udp
+function test_socketsUdp(): void {
+    var socketId: number;
+    var properties: chrome.sockets.udp.SocketProperties = {};
+    var buffer: ArrayBuffer = new ArrayBuffer(256);
+
+    // create
+    chrome.sockets.udp.create((info) => {
+        socketId = info.socketId;
+    });
+
+    chrome.sockets.udp.create(properties, (info) => {
+        socketId = info.socketId;
+    });
+
+    // update
+    chrome.sockets.udp.update(socketId, properties);
+    chrome.sockets.udp.update(socketId, properties, () => { });
+
+    // setPaused
+    chrome.sockets.udp.setPaused(socketId, true);
+    chrome.sockets.udp.setPaused(socketId, true, () => { });
+
+    // bind
+    chrome.sockets.udp.bind(socketId, "0.0.0.0", 8080, (result: number) => { });
+
+    // send
+    chrome.sockets.udp.send(socketId, buffer, "172.21.0.1", 10080, (info: chrome.sockets.udp.SendInfo) => { });
+
+    // close
+    chrome.sockets.udp.close(socketId);
+    chrome.sockets.udp.close(socketId, () => { });
+
+    // getInfo
+    chrome.sockets.udp.getInfo(socketId, (info: chrome.sockets.udp.SocketInfo) => { });
+
+    // getSockets
+    chrome.sockets.udp.getSockets((infos: chrome.sockets.udp.SocketInfo[]) => { });
+
+    // joinGroup
+    chrome.sockets.udp.joinGroup(socketId, "224.0.0.1", (result: number) => { });
+
+    // leaveGroup
+    chrome.sockets.udp.leaveGroup(socketId, "224.0.0.1", (result: number) => { });
+
+    // setMulticastTimeToLive
+    chrome.sockets.udp.setMulticastTimeToLive(socketId, 100, (result: number) => { });
+
+    // setMulticastLoopbackMode
+    chrome.sockets.udp.setMulticastLoopbackMode(socketId, true, (result: number) => { });
+
+    // getJoinedGroups
+    chrome.sockets.udp.getJoinedGroups(socketId, (groups: string[]) => { });
+}
+
+function test_socketsUdpEvents(): void {
+    chrome.sockets.udp.onReceive.addListener((info: chrome.sockets.udp.ReceiveEventArgs) => { });
+    chrome.sockets.udp.onReceiveError.addListener((info: chrome.sockets.udp.ReceiveErrorEventArgs) => { });
+}
+
+function testSocketsUdpTypes(): void {
+    // SocketProperties
+    var properties: chrome.sockets.udp.SocketProperties;
+
+    properties = {
+    };
+
+    properties = {
+        persistent: true,
+        name: "test",
+        bufferSize: 1024
+    };
+
+    // SocketInfo
+    var socketInfo: chrome.sockets.udp.SocketInfo;
+
+    socketInfo = {
+        socketId: 1,
+        persistent: true,
+        paused: true
+    };
+
+    socketInfo.name = "test";
+    socketInfo.bufferSize = 1024;
+    socketInfo.localAddress = "192.168.0.2";
+    socketInfo.localPort = 8000;
+}
+
+// https://developer.chrome.com/apps/sockets_tcpServer
+function test_socketsTcpServer(): void {
+    var socketId: number;
+    var properties: chrome.sockets.tcpServer.SocketProperties = {};
+    var buffer: ArrayBuffer = new ArrayBuffer(256);
+
+    // create
+    chrome.sockets.tcpServer.create((info) => {
+        socketId = info.socketId;
+    });
+
+    chrome.sockets.tcpServer.create(properties, (info) => {
+        socketId = info.socketId;
+    });
+
+    // update
+    chrome.sockets.tcpServer.update(socketId, properties);
+    chrome.sockets.tcpServer.update(socketId, properties, () => { });
+
+    // setPaused
+    chrome.sockets.tcpServer.setPaused(socketId, true);
+    chrome.sockets.tcpServer.setPaused(socketId, true, () => { });
+
+    // listen
+    chrome.sockets.tcpServer.listen(socketId, "0.0.0.0", 80, (result: number) => { });
+    chrome.sockets.tcpServer.listen(socketId, "0.0.0.0", 80, 128, (result: number) => { });
+
+    // disconnect
+    chrome.sockets.tcp.disconnect(socketId);
+    chrome.sockets.tcp.disconnect(socketId, () => { });
+
+    // close
+    chrome.sockets.udp.close(socketId);
+    chrome.sockets.udp.close(socketId, () => { });
+
+    // getInfo
+    chrome.sockets.udp.getInfo(socketId, (info: chrome.sockets.udp.SocketInfo) => { });
+
+    // getSockets
+    chrome.sockets.tcp.getSockets(socketId, (infos: chrome.sockets.tcp.SocketInfo[]) => { });
+}
+
+function test_socketsTcpServerEvents(): void {
+    chrome.sockets.tcpServer.onAccept.addListener((info: chrome.sockets.tcpServer.AcceptEventArgs) => { });
+    chrome.sockets.tcpServer.onAcceptError.addListener((info: chrome.sockets.tcpServer.AcceptErrorEventArgs) => { });
+}
+
+function testSocketsTcpServerTypes(): void {
+    // SocketProperties
+    var properties: chrome.sockets.tcpServer.SocketProperties;
+
+    properties = {
+    };
+
+    properties = {
+        persistent: true,
+        name: "test"
+    };
+
+    // SocketInfo
+    var socketInfo: chrome.sockets.tcpServer.SocketInfo;
+
+    socketInfo = {
+        socketId: 1,
+        persistent: true,
+        paused: true
+    };
+
+    socketInfo.name = "test";
+    socketInfo.localAddress = "192.168.0.2";
+    socketInfo.localPort = 8000;
+}
@@ -1,6 +1,6 @@
 // Type definitions for Chrome packaged application development
 // Project: http://developer.chrome.com/apps/
-// Definitions by: Adam Lay <https://github.com/AdamLay>
+// Definitions by: Adam Lay <https://github.com/AdamLay>, MIZUNE Pine <https://github.com/pine613>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

 ////////////////////
@@ -93,3 +93,189 @@ declare module chrome.app.window {
    var onMinimized: WindowEvent;
    var onRestored: WindowEvent;
 }
+
+
+////////////////////
+// Sockets
+////////////////////
+declare module chrome.sockets.tcp {
+    interface CreateInfo {
+        socketId: number;
+    }
+
+    interface SendInfo {
+        resultCode: number;
+        bytesSent?: number;
+    }
+
+    interface Event<T> {
+        addListener(callback: (info: T) => void): void;
+    }
+
+    interface ReceiveEventArgs {
+        socketId: number;
+        data: ArrayBuffer;
+    }
+
+    interface ReceiveErrorEventArgs {
+        socketId: number;
+        resultCode: number;
+    }
+
+    interface SocketProperties {
+        persistent?: boolean;
+        name?: string;
+        bufferSize?: number;
+    }
+
+    interface SocketInfo {
+        socketId: number;
+        persistent: boolean;
+        name?: string;
+        bufferSize?: number;
+        paused: boolean;
+        connected: boolean;
+        localAddress?: string;
+        localPort?: number;
+        peerAddress?: string;
+        peerPort?: number;
+    }
+
+    export function create(callback: (createInfo: CreateInfo) => void): void;
+    export function create(properties: SocketProperties, callback: (createInfo: CreateInfo) => void): void;
+
+    export function update(socketId: number, properties: SocketProperties, callback?: () => void): void;
+    export function setPaused(socketId: number, paused: boolean, callback?: () => void): void;
+
+    export function setKeepAlive(socketId: number,
+        enable: boolean, callback: (result: number) => void): void;
+    export function setKeepAlive(socketId: number,
+        enable: boolean, delay: number, callback: (result: number) => void): void;
+
+    export function setNoDelay(socketId: number, noDelay: boolean, callback: (result: number) => void): void;
+    export function connect(socketId: number,
+        peerAddress: string, peerPort: number, callback: (result: number) => void): void;
+    export function disconnect(socketId: number, callback?: () => void): void;
+    export function send(socketId: number, data: ArrayBuffer, callback: (sendInfo: SendInfo) => void): void;
+    export function close(socketId: number, callback?: () => void): void;
+    export function getInfo(socketId: number, callback: (socketInfo: SocketInfo) => void): void;
+    export function getSockets(socketId: number, callback: (socketInfos: SocketInfo[]) => void): void;
+
+    var onReceive: Event<ReceiveEventArgs>;
+    var onReceiveError: Event<ReceiveErrorEventArgs>;
+}
+
+declare module chrome.sockets.udp {
+    interface CreateInfo {
+        socketId: number;
+    }
+
+    interface SendInfo {
+        resultCode: number;
+        bytesSent?: number;
+    }
+
+    interface Event<T> {
+        addListener(callback: (info: T) => void): void;
+    }
+
+    interface ReceiveEventArgs {
+        socketId: number;
+        data: ArrayBuffer;
+        remoteAddress: string;
+        remotePort: number;
+    }
+
+    interface ReceiveErrorEventArgs {
+        socketId: number;
+        resultCode: number;
+    }
+
+    interface SocketProperties {
+        persistent?: boolean;
+        name?: string;
+        bufferSize?: number;
+    }
+
+    interface SocketInfo {
+        socketId: number;
+        persistent: boolean;
+        name?: string;
+        bufferSize?: number;
+        paused: boolean;
+        localAddress?: string;
+        localPort?: number;
+    }
+
+    export function create(callback: (createInfo: CreateInfo) => void): void;
+    export function create(properties: SocketProperties,
+        callback: (createInfo: CreateInfo) => void): void;
+
+    export function update(socketId: number, properties: SocketProperties, callback?: () => void): void;
+    export function setPaused(socketId: number, paused: boolean, callback?: () => void): void;
+    export function bind(socketId: number, address: string, port: number, callback: (result: number) => void): void;
+    export function send(socketId: number, data: ArrayBuffer, address: string, port: number, callback: (sendInfo: SendInfo) => void): void;
+    export function close(socketId: number, callback?: () => void): void;
+    export function getInfo(socketId: number, callback: (socketInfo: SocketInfo) => void): void;
+    export function getSockets(callback: (socketInfos: SocketInfo[]) => void): void;
+    export function joinGroup(socketId: number, address: string, callback: (result: number) => void): void;
+    export function leaveGroup(socketId: number, address: string, callback: (result: number) => void): void;
+    export function setMulticastTimeToLive(socketId: number, ttl: number, callback: (result: number) => void): void;
+    export function setMulticastLoopbackMode(socketId: number, enabled: boolean, callback: (result: number) => void): void;
+    export function getJoinedGroups(socketId: number, callback: (groups: string[]) => void): void;
+
+    var onReceive: Event<ReceiveEventArgs>;
+    var onReceiveError: Event<ReceiveErrorEventArgs>;
+}
+
+declare module chrome.sockets.tcpServer {
+    interface CreateInfo {
+        socketId: number;
+    }
+
+    interface Event<T> {
+        addListener(callback: (info: T) => void): void;
+    }
+
+    interface AcceptEventArgs {
+        socketId: number;
+        clientSocketId: number;
+    }
+
+    interface AcceptErrorEventArgs {
+        socketId: number;
+        resultCode: number;
+    }
+
+    interface SocketProperties {
+        persistent?: boolean;
+        name?: string;
+    }
+
+    interface SocketInfo {
+        socketId: number;
+        persistent: boolean;
+        name?: string;
+        paused: boolean;
+        localAddress?: string;
+        localPort?: number;
+    }
+
+    export function create(callback: (createInfo: CreateInfo) => void): void;
+    export function create(properties: SocketProperties, callback: (createInfo: CreateInfo) => void): void;
+
+    export function update(socketId: number, properties: SocketProperties, callback?: () => void): void;
+    export function setPaused(socketId: number, paused: boolean, callback?: () => void): void;
+
+    export function listen(socketId: number, address: string,
+        port: number, backlog: number, callback: (result: number) => void): void;
+    export function listen(socketId: number, address: string,
+        port: number, callback: (result: number) => void): void;
+
+    export function disconnect(socketId: number, callback?: () => void): void;
+    export function close(socketId: number, callback?: () => void): void;
+    export function getInfo(socketId: number, callback: (socketInfos: SocketInfo[]) => void): void;
+
+    var onAccept: Event<AcceptEventArgs>;
+    var onAcceptError: Event<AcceptErrorEventArgs>;
+}