FilesExpand file tree

 master

/

IO.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

108 lines (85 loc) · 3.03 KB

 master

/

IO.java

Copy path

Top

File metadata and controls

• Code
• Blame

108 lines (85 loc) · 3.03 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

package io.socket.client;

import io.socket.parser.Parser;

import okhttp3.Call;

import okhttp3.WebSocket;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.concurrent.ConcurrentHashMap;

import java.util.logging.Level;

import java.util.logging.Logger;

public class IO {

private static final Logger logger = Logger.getLogger(IO.class.getName());

private static final ConcurrentHashMap<String, Manager> managers = new ConcurrentHashMap<String, Manager>();

/**

* Protocol version.

*/

public static int protocol = Parser.protocol;

public static void setDefaultOkHttpWebSocketFactory(WebSocket.Factory factory) {

Manager.defaultWebSocketFactory = factory;

}

public static void setDefaultOkHttpCallFactory(Call.Factory factory) {

Manager.defaultCallFactory = factory;

}

private IO() {}

public static Socket socket(String uri) throws URISyntaxException {

return socket(uri, null);

}

public static Socket socket(String uri, Options opts) throws URISyntaxException {

return socket(new URI(uri), opts);

}

public static Socket socket(URI uri) {

return socket(uri, null);

}

/**

* Initializes a {@link Socket} from an existing {@link Manager} for multiplexing.

*

* @param uri uri to connect.

* @param opts options for socket.

* @return {@link Socket} instance.

*/

public static Socket socket(URI uri, Options opts) {

if (opts == null) {

opts = new Options();

}

URL parsed = Url.parse(uri);

URI source;

try {

source = parsed.toURI();

} catch (URISyntaxException e) {

throw new RuntimeException(e);

}

String id = Url.extractId(parsed);

String path = parsed.getPath();

boolean sameNamespace = managers.containsKey(id)

&& managers.get(id).nsps.containsKey(path);

boolean newConnection = opts.forceNew || !opts.multiplex || sameNamespace;

Manager io;

if (newConnection) {

if (logger.isLoggable(Level.FINE)) {

logger.fine(String.format("ignoring socket cache for %s", source));

}

io = new Manager(source, opts);

} else {

if (!managers.containsKey(id)) {

if (logger.isLoggable(Level.FINE)) {

logger.fine(String.format("new io instance for %s", source));

}

managers.putIfAbsent(id, new Manager(source, opts));

}

io = managers.get(id);

}

String query = parsed.getQuery();

if (query != null && (opts.query == null || opts.query.isEmpty())) {

opts.query = query;

}

return io.socket(parsed.getPath(), opts);

}

public static class Options extends Manager.Options {

public boolean forceNew;

/**

* Whether to enable multiplexing. Default is true.

*/

public boolean multiplex = true;

}

}