Final Proxy Commit!

API/src/main/java/io/github/jwdeveloper/tiktok/data/dto/ProxyData.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.data.dto;
+
+import lombok.*;
+
+import java.net.*;
+
+@Data
+@AllArgsConstructor
+public class ProxyData
+{
+	private final String address;
+	private final int port;
+
+	public static ProxyData map(String string) {
+		if (string == null || string.isBlank())
+			throw new IllegalArgumentException("Provided address cannot be null or empty!");
+		int portIndex = string.lastIndexOf(':');
+		try {
+			String address = string.substring(0, portIndex);
+			int port = Integer.parseInt(string.substring(portIndex+1));
+
+			// Port validation
+			if (port < 0 || port > 65535)
+				throw new IndexOutOfBoundsException("Port out of range: "+port);
+
+			// IP Validation
+			InetAddress res = InetAddress.getByName(address);
+
+			return new ProxyData(address, port);
+		} catch (NumberFormatException e) {
+			throw new IllegalArgumentException("Port must be a valid integer!");
+		} catch (UnknownHostException e) {
+			throw new IllegalArgumentException("Address must be valid IPv4, IPv6, or domain name!");
+		}
+	}
+
+	public ProxyData clone() {
+		return new ProxyData(address, port);
+	}
+
+	public InetSocketAddress toSocketAddress() {
+		return new InetSocketAddress(address, port);
+	}
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokDisconnectedEvent.java

@@ -24,7 +24,7 @@ package io.github.jwdeveloper.tiktok.data.events;
 import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
-
+import lombok.Getter;
 
 /**
  * Triggered when the connection gets disconnected. In that case you can call connect() again to have a reconnect logic.
@@ -32,4 +32,12 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
  */
 @EventMeta(eventType = EventType.Control)
 public class TikTokDisconnectedEvent extends TikTokLiveClientEvent {
-}
+	@Getter private final String reason;
+	public TikTokDisconnectedEvent(String reason) {
+		this.reason = reason.isBlank() ? "None" : reason;
+	}
+
+	public TikTokDisconnectedEvent() {
+		this("None");
+	}
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/requests/LiveUserData.java

@@ -22,10 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.data.requests;
 
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.Getter;
-import lombok.Setter;
+import lombok.*;
 
 public class LiveUserData {
 
@@ -38,15 +35,18 @@ public class LiveUserData {
     @Getter
     @AllArgsConstructor
     public static class Response {
-
         private String json;
-
         private UserStatus userStatus;
-
         private String roomId;
-
-
         private long startedAtTimeStamp;
+
+        public boolean isLiveOnline() {
+            return userStatus == LiveUserData.UserStatus.Live || userStatus == LiveUserData.UserStatus.LivePaused;
+        }
+
+        public boolean isHostNameValid() {
+            return userStatus != LiveUserData.UserStatus.NotFound;
+        }
     }
 
     public enum UserStatus {
@@ -55,6 +55,4 @@ public class LiveUserData {
         LivePaused,
         Live,
     }
-}
-
-
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/settings/HttpClientSettings.java

@@ -46,6 +46,7 @@ public class HttpClientSettings {
     final Map<String, String> cookies;
 
     @Getter
+    @Setter
     ProxyClientSettings proxyClientSettings;
 
     @Getter
@@ -74,7 +75,7 @@ public class HttpClientSettings {
      * @param consumer Use to configure proxy settings for http client
      */
     public void configureProxy(Consumer<ProxyClientSettings> consumer) {
-        proxyClientSettings.setUseProxy(true);
+        proxyClientSettings.setEnabled(true);
         consumer.accept(proxyClientSettings);
     }
 
@@ -104,8 +105,8 @@ public class HttpClientSettings {
         newSettings.getHeaders().putAll(new TreeMap<>(this.headers));
         newSettings.getCookies().putAll(new TreeMap<>(this.cookies));
         newSettings.getParams().putAll(new TreeMap<>(this.params));
-        newSettings.proxyClientSettings = this.proxyClientSettings.clone();
+        newSettings.proxyClientSettings = this.proxyClientSettings;
 
         return newSettings;
     }
-}
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/settings/ProxyClientSettings.java

@@ -22,19 +22,101 @@
  */
 package io.github.jwdeveloper.tiktok.data.settings;
 
-import lombok.Getter;
-import lombok.Setter;
+import io.github.jwdeveloper.tiktok.data.dto.ProxyData;
+import lombok.*;
+
+import java.net.*;
+import java.util.*;
+import java.util.function.Consumer;
 
-//TODO proxy implementation
 @Getter
-public class ProxyClientSettings
+@Setter
+public class ProxyClientSettings implements Iterator<ProxyData>
 {
-    @Setter
-    private boolean useProxy;
+    private boolean enabled, lastSuccess;
+    private Rotation rotation = Rotation.CONSECUTIVE;
+    private final List<ProxyData> proxyList = new ArrayList<>();
+    private int index = 0;
+    private boolean autoDiscard = true;
+    private Proxy.Type type = Proxy.Type.DIRECT;
+    private Consumer<ProxyData> onProxyUpdated = x -> {};
 
+    public boolean addProxy(String addressPort) {
+        return proxyList.add(ProxyData.map(addressPort));
+    }
 
+    public boolean addProxy(String address, int port) {
+        return addProxy(new InetSocketAddress(address, port));
+    }
+
+    public boolean addProxy(InetSocketAddress inetAddress) {
+        return proxyList.add(new ProxyData(inetAddress.getHostString(), inetAddress.getPort()));
+    }
+
+    public void addProxies(List<String> list) {
+        list.forEach(this::addProxy);
+    }
+
+    @Override
+    public boolean hasNext() {
+        return !proxyList.isEmpty();
+    }
+
+    @Override
+    public ProxyData next() {
+		return lastSuccess ? proxyList.get(index) : rotate();
+	}
+
+    public ProxyData rotate() {
+        var nextProxy = switch (rotation)
+        {
+            case CONSECUTIVE -> {
+                index = (index+1) % proxyList.size();
+                yield proxyList.get(index).clone();
+            }
+            case RANDOM -> {
+                index = new Random().nextInt(proxyList.size());
+                yield proxyList.get(index).clone();
+            }
+            case NONE -> proxyList.get(index).clone();
+        };
+        onProxyUpdated.accept(nextProxy);
+        return nextProxy;
+    }
+
+    @Override
+    public void remove() {
+        proxyList.remove(index);
+    }
+
+    public void setIndex(int index) {
+        if (index == 0 && proxyList.isEmpty())
+            this.index = 0;
+        else {
+            if (index < 0 || index >= proxyList.size())
+                throw new IndexOutOfBoundsException("Index " + index + " exceeds list of size: " + proxyList.size());
+            this.index = index;
+        }
+    }
     public ProxyClientSettings clone()
     {
-        return new ProxyClientSettings();
+        ProxyClientSettings settings = new ProxyClientSettings();
+        settings.setEnabled(enabled);
+        settings.setRotation(rotation);
+        settings.setIndex(index);
+        settings.setType(type);
+        settings.setOnProxyUpdated(onProxyUpdated);
+        proxyList.forEach(proxyData -> settings.addProxy(proxyData.getAddress(), proxyData.getPort()));
+        return settings;
     }
-}
+
+    public enum Rotation
+    {
+        /** Rotate addresses consecutively, from proxy 0 -> 1 -> 2 -> ...etc. */
+        CONSECUTIVE,
+        /** Rotate addresses randomly, from proxy 0 -> 69 -> 420 -> 1 -> ...etc. */
+        RANDOM,
+        /** Don't rotate addresses at all, pin to the indexed address. */
+        NONE
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokProxyRequestException.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.exceptions;
+
+
+/*
+ * Happens while bad response from http proxy request to TikTok
+ */
+public class TikTokProxyRequestException extends TikTokLiveException
+{
+    public TikTokProxyRequestException() {
+    }
+
+    public TikTokProxyRequestException(String message) {
+        super(message);
+    }
+
+    public TikTokProxyRequestException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TikTokProxyRequestException(Throwable cause) {
+        super(cause);
+    }
+
+    public TikTokProxyRequestException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLive.java

@@ -26,6 +26,8 @@ package io.github.jwdeveloper.tiktok;
 import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
 import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 
+import java.util.concurrent.CompletableFuture;
+
 public class TikTokLive {
 
     /**
@@ -37,6 +39,50 @@ public class TikTokLive {
         return new TikTokLiveClientBuilder(hostName);
     }
 
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true if live is Online, false if is offline
+     */
+    public static boolean isLiveOnline(String hostName)
+    {
+        return requests().fetchLiveUserData(hostName).isLiveOnline();
+    }
+
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true if live is Online, false if is offline
+     */
+    public static CompletableFuture<Boolean> isLiveOnlineAsync(String hostName)
+    {
+        return CompletableFuture.supplyAsync(()-> isLiveOnline(hostName));
+    }
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true is hostName name is valid and exists, false if not
+     */
+    public static boolean isHostNameValid(String hostName)
+    {
+        return requests().fetchLiveUserData(hostName).isHostNameValid();
+    }
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true is hostName name is valid and exists, false if not
+     */
+    public static CompletableFuture<Boolean> isHostNameValidAsync(String hostName)
+    {
+        return CompletableFuture.supplyAsync(()-> isHostNameValid(hostName));
+    }
 
     /**
      * Use to get some data from TikTok about users are lives
@@ -44,9 +90,6 @@ public class TikTokLive {
      * @return LiveHttpClient
      */
     public static LiveHttpClient requests() {
-
-
         return new TikTokLiveHttpClient();
     }
-
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClient.java

@@ -76,19 +76,15 @@ public class TikTokLiveClient implements LiveClient {
 
 
     public void connectAsync(Consumer<LiveClient> onConnection) {
-        CompletableFuture.supplyAsync(() ->
-        {
+        CompletableFuture.runAsync(() -> {
             connect();
             onConnection.accept(this);
-            return this;
         });
-
     }
 
 
     public CompletableFuture<LiveClient> connectAsync() {
-        return CompletableFuture.supplyAsync(() ->
-        {
+        return CompletableFuture.supplyAsync(() -> {
             connect();
             return this;
         });
@@ -105,8 +101,7 @@ public class TikTokLiveClient implements LiveClient {
             if (e instanceof TikTokLiveOfflineHostException && clientSettings.isRetryOnConnectionFailure()) {
                 try {
                     Thread.sleep(clientSettings.getRetryConnectionTimeout().toMillis());
-                } catch (Exception ignored) {
-                }
+                } catch (Exception ignored) {}
                 logger.info("Reconnecting");
                 tikTokEventHandler.publish(this, new TikTokReconnectingEvent());
                 this.connect();
@@ -120,14 +115,12 @@ public class TikTokLiveClient implements LiveClient {
     }
 
     public void tryConnect() {
-        if (!liveRoomInfo.hasConnectionState(ConnectionState.DISCONNECTED))
-        {
+        if (!liveRoomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
             throw new TikTokLiveException("Already connected");
         }
 
         setState(ConnectionState.CONNECTING);
 
-
         var userDataRequest = new LiveUserData.Request(liveRoomInfo.getHostName());
         var userData = httpClient.fetchLiveUserData(userDataRequest);
         liveRoomInfo.setStartTime(userData.getStartedAtTimeStamp());
@@ -139,7 +132,6 @@ public class TikTokLiveClient implements LiveClient {
             throw new TikTokLiveOfflineHostException("User not found: "+liveRoomInfo.getHostUser());
         }
 
-
         var liveDataRequest = new LiveData.Request(userData.getRoomId());
         var liveData = httpClient.fetchLiveData(liveDataRequest);
         if (liveData.getLiveStatus() == LiveData.LiveStatus.HostNotFound) {
@@ -155,7 +147,6 @@ public class TikTokLiveClient implements LiveClient {
         liveRoomInfo.setAgeRestricted(liveData.isAgeRestricted());
         liveRoomInfo.setHost(liveData.getHost());
 
-
         var liveConnectionRequest =new LiveConnectionData.Request(userData.getRoomId());
         var liveConnectionData = httpClient.fetchLiveConnectionData(liveConnectionRequest);
         webSocketClient.start(liveConnectionData, this);
@@ -181,7 +172,6 @@ public class TikTokLiveClient implements LiveClient {
         tikTokEventHandler.publish(this, event);
     }
 
-
     public LiveRoomInfo getRoomInfo() {
         return liveRoomInfo;
     }
@@ -200,6 +190,4 @@ public class TikTokLiveClient implements LiveClient {
     public GiftManager getGiftManager() {
         return tikTokGiftManager;
     }
-
-
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClientBuilder.java

@@ -156,7 +156,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
 
         var httpClientFactory = new HttpClientFactory(clientSettings);
-        var tikTokLiveHttpClient = new TikTokLiveHttpClient(httpClientFactory);
+        var tikTokLiveHttpClient = new TikTokLiveHttpClient(httpClientFactory, clientSettings);
 
         var webSocketClient = new TikTokWebSocketClient(
                 clientSettings,
@@ -346,7 +346,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
 
     @Override
-    public LiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
+    public TikTokLiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
         tikTokEventHandler.subscribe(TikTokRoomInfoEvent.class, event);
         return this;
     }
@@ -358,7 +358,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
     }
 
     @Override
-    public LiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
+    public TikTokLiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
         tikTokEventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
         return this;
     }

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveHttpClient.java

@@ -24,18 +24,14 @@ package io.github.jwdeveloper.tiktok;
 
 import com.google.protobuf.InvalidProtocolBufferException;
 import io.github.jwdeveloper.tiktok.data.requests.*;
-import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokSignServerException;
-import io.github.jwdeveloper.tiktok.http.HttpClientFactory;
-import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
-import io.github.jwdeveloper.tiktok.http.mappers.GiftsDataMapper;
-import io.github.jwdeveloper.tiktok.http.mappers.LiveDataMapper;
-import io.github.jwdeveloper.tiktok.http.mappers.LiveUserDataMapper;
-import io.github.jwdeveloper.tiktok.http.mappers.SignServerResponseMapper;
+import io.github.jwdeveloper.tiktok.data.settings.*;
+import io.github.jwdeveloper.tiktok.exceptions.*;
+import io.github.jwdeveloper.tiktok.http.*;
+import io.github.jwdeveloper.tiktok.http.mappers.*;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 
 import java.net.http.HttpResponse;
+import java.util.Optional;
 
 public class TikTokLiveHttpClient implements LiveHttpClient {
 
@@ -48,21 +44,23 @@ public class TikTokLiveHttpClient implements LiveHttpClient {
     private static final String TIKTOK_URL_WEBCAST = "https://webcast.tiktok.com/webcast/";
 
     private final HttpClientFactory httpFactory;
+    private final LiveClientSettings clientSettings;
     private final LiveUserDataMapper liveUserDataMapper;
     private final LiveDataMapper liveDataMapper;
-    private final SignServerResponseMapper singServerResponseMapper;
+    private final SignServerResponseMapper signServerResponseMapper;
     private final GiftsDataMapper giftsDataMapper;
 
-    public TikTokLiveHttpClient(HttpClientFactory factory) {
+    public TikTokLiveHttpClient(HttpClientFactory factory, LiveClientSettings settings) {
         this.httpFactory = factory;
+        clientSettings = settings;
         liveUserDataMapper = new LiveUserDataMapper();
         liveDataMapper = new LiveDataMapper();
-        singServerResponseMapper = new SignServerResponseMapper();
+        signServerResponseMapper = new SignServerResponseMapper();
         giftsDataMapper = new GiftsDataMapper();
     }
 
     public TikTokLiveHttpClient() {
-        this(new HttpClientFactory(LiveClientSettings.createDefault()));
+        this(new HttpClientFactory(LiveClientSettings.createDefault()), LiveClientSettings.createDefault());
     }
 
 
@@ -87,7 +85,26 @@ public class TikTokLiveHttpClient implements LiveHttpClient {
 
     @Override
     public LiveUserData.Response fetchLiveUserData(LiveUserData.Request request) {
+        var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
+        if (proxyClientSettings.isEnabled()) {
+            while (proxyClientSettings.hasNext()) {
+                try {
+                    var url = TIKTOK_URL_WEB + "api-live/user/room";
+                    var optional = httpFactory.client(url)
+                        .withParam("uniqueId", request.getUserName())
+                        .withParam("sourceType", "54")
+                        .build()
+                        .toJsonResponse();
 
+                    if (optional.isEmpty()) {
+                        throw new TikTokLiveRequestException("Unable to get information's about user");
+                    }
+
+                    var json = optional.get();
+                    return liveUserDataMapper.map(json);
+                } catch (TikTokProxyRequestException ignored) {}
+            }
+        }
         var url = TIKTOK_URL_WEB + "api-live/user/room";
         var optional = httpFactory.client(url)
                 .withParam("uniqueId", request.getUserName())
@@ -110,7 +127,25 @@ public class TikTokLiveHttpClient implements LiveHttpClient {
 
     @Override
     public LiveData.Response fetchLiveData(LiveData.Request request) {
+        var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
+        if (proxyClientSettings.isEnabled()) {
+            while (proxyClientSettings.hasNext()) {
+                try {
+                    var url = TIKTOK_URL_WEBCAST + "room/info";
+                    var optional = httpFactory.client(url)
+                        .withParam("room_id", request.getRoomId())
+                        .build()
+                        .toJsonResponse();
 
+                    if (optional.isEmpty()) {
+                        throw new TikTokLiveRequestException("Unable to get info about live room");
+                    }
+
+                    var json = optional.get();
+                    return liveDataMapper.map(json);
+                } catch (TikTokProxyRequestException ignored) {}
+            }
+        }
         var url = TIKTOK_URL_WEBCAST + "room/info";
         var optional = httpFactory.client(url)
                 .withParam("room_id", request.getRoomId())
@@ -132,14 +167,15 @@ public class TikTokLiveHttpClient implements LiveHttpClient {
 
     @Override
     public LiveConnectionData.Response fetchLiveConnectionData(LiveConnectionData.Request request) {
-
-        var signServerResponse = getSignedUrl(request.getRoomId());
-        var credentialsResponse = getWebsocketCredentialsResponse(signServerResponse.getSignedUrl());
+		HttpResponse<byte[]> credentialsResponse = getOptionalProxyResponse(request).orElseGet(()-> {
+            SignServerResponse signServerResponse = getSignedUrl(request.getRoomId());
+            return getWebsocketCredentialsResponse(signServerResponse.getSignedUrl());
+        });
 
         try {
             var optionalHeader = credentialsResponse.headers().firstValue("set-cookie");
             if (optionalHeader.isEmpty()) {
-                throw new TikTokSignServerException("Sign server does not returned set-cookie header");
+                throw new TikTokSignServerException("Sign server did not return the set-cookie header");
             }
             var websocketCookie = optionalHeader.get();
             var webcastResponse = WebcastResponse.parseFrom(credentialsResponse.body());
@@ -180,18 +216,32 @@ public class TikTokLiveHttpClient implements LiveHttpClient {
         }
 
         var json = optional.get();
-        return singServerResponseMapper.map(json);
+        return signServerResponseMapper.map(json);
     }
 
     HttpResponse<byte[]> getWebsocketCredentialsResponse(String signedUrl) {
         var optionalResponse = httpFactory
                 .clientEmpty(signedUrl)
                 .build()
-                .toResponse(HttpResponse.BodyHandlers.ofByteArray());
+                .toResponse();
         if (optionalResponse.isEmpty()) {
             throw new TikTokSignServerException("Unable to get websocket connection credentials");
         }
         return optionalResponse.get();
     }
 
-}
+    Optional<HttpResponse<byte[]>> getOptionalProxyResponse(LiveConnectionData.Request request) {
+        var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
+        if (proxyClientSettings.isEnabled()) {
+            while (proxyClientSettings.hasNext()) {
+                try {
+                    SignServerResponse signServerResponse = getSignedUrl(request.getRoomId());
+                    HttpResponse<byte[]> credentialsResponse = getWebsocketCredentialsResponse(signServerResponse.getSignedUrl());
+                    clientSettings.getHttpSettings().getProxyClientSettings().rotate();
+                    return Optional.of(credentialsResponse);
+                } catch (TikTokProxyRequestException | TikTokSignServerException ignored) {}
+            }
+        }
+        return Optional.empty();
+    }
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpClient.java

@@ -26,57 +26,62 @@ import io.github.jwdeveloper.tiktok.data.settings.HttpClientSettings;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 import lombok.AllArgsConstructor;
 
-import java.net.CookieManager;
-import java.net.URI;
-import java.net.URLEncoder;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.charset.StandardCharsets;
-import java.util.Map;
-import java.util.Optional;
+import java.net.*;
+import java.net.http.*;
+import java.nio.charset.*;
+import java.util.*;
+import java.util.regex.*;
 import java.util.stream.Collectors;
 
 @AllArgsConstructor
 public class HttpClient {
-    private final HttpClientSettings httpClientSettings;
-    private final String url;
+    protected final HttpClientSettings httpClientSettings;
+    protected final String url;
+    private final Pattern pattern = Pattern.compile("charset=(.*?)(?=&|$)");
 
-
-    public <T> Optional<HttpResponse<T>> toResponse(HttpResponse.BodyHandler<T> bodyHandler) {
+    public  Optional<HttpResponse<byte[]>> toResponse() {
         var client = prepareClient();
         var request = prepareGetRequest();
-        try
-        {
-            var response = client.send(request, bodyHandler);
-            if(response.statusCode() != 200)
-            {
+        try {
+            var response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
+            if (response.statusCode() != 200) {
                 return Optional.empty();
             }
 
-
-
             return Optional.of(response);
         } catch (Exception e) {
             throw new TikTokLiveRequestException(e);
         }
     }
 
-
     public Optional<String> toJsonResponse() {
-        var optional = toResponse(HttpResponse.BodyHandlers.ofString());
+        var optional = toResponse();
         if (optional.isEmpty()) {
             return Optional.empty();
         }
 
         var response = optional.get();
-
-
         var body = response.body();
-        return Optional.of(body);
+        var charset = charsetFrom(response.headers());
+        return Optional.of(new String(body,charset));
+    }
+
+    private Charset charsetFrom(HttpHeaders headers) {
+        String type = headers.firstValue("Content-type").orElse("text/html; charset=utf-8");
+        int i = type.indexOf(";");
+        if (i >= 0) type = type.substring(i+1);
+        try {
+            Matcher matcher = pattern.matcher(type);
+            if (!matcher.find())
+                return StandardCharsets.UTF_8;
+            return Charset.forName(matcher.group(1));
+        } catch (Throwable x) {
+            return StandardCharsets.UTF_8;
+        }
     }
 
     public Optional<byte[]> toBinaryResponse() {
-        var optional = toResponse(HttpResponse.BodyHandlers.ofByteArray());
+        var optional = toResponse();
         if (optional.isEmpty()) {
             return Optional.empty();
         }
@@ -84,13 +89,12 @@ public class HttpClient {
         return Optional.of(body);
     }
 
-
     public URI toUrl() {
         var stringUrl = prepareUrlWithParameters(url, httpClientSettings.getParams());
         return URI.create(stringUrl);
     }
 
-    private HttpRequest prepareGetRequest() {
+    protected HttpRequest prepareGetRequest() {
         var requestBuilder = HttpRequest.newBuilder().GET();
         requestBuilder.uri(toUrl());
         requestBuilder.timeout(httpClientSettings.getTimeout());
@@ -100,18 +104,17 @@ public class HttpClient {
         return requestBuilder.build();
     }
 
-    private java.net.http.HttpClient prepareClient() {
+    protected java.net.http.HttpClient prepareClient() {
         var builder = java.net.http.HttpClient.newBuilder()
-                .followRedirects(java.net.http.HttpClient.Redirect.NORMAL)
-                .cookieHandler(new CookieManager())
-                .connectTimeout(httpClientSettings.getTimeout());
-
+            .followRedirects(java.net.http.HttpClient.Redirect.NORMAL)
+            .cookieHandler(new CookieManager())
+            .connectTimeout(httpClientSettings.getTimeout());
 
         httpClientSettings.getOnClientCreating().accept(builder);
         return builder.build();
     }
 
-    private String prepareUrlWithParameters(String url, Map<String, Object> parameters) {
+    protected String prepareUrlWithParameters(String url, Map<String, Object> parameters) {
         if (parameters.isEmpty()) {
             return url;
         }
@@ -123,4 +126,4 @@ public class HttpClient {
             return encodedKey + "=" + encodedValue;
         }).collect(Collectors.joining("&"));
     }
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpClientBuilder.java

@@ -77,11 +77,9 @@ public class HttpClientBuilder {
         return this;
     }
 
-
     public HttpClient build() {
-
+        if (httpClientSettings.getProxyClientSettings().isEnabled())
+            return new HttpProxyClient(httpClientSettings, url);
         return new HttpClient(httpClientSettings, url);
     }
-
-
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpClientFactory.java

@@ -22,7 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.http;
 
-import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
+import io.github.jwdeveloper.tiktok.data.settings.*;
 
 public class HttpClientFactory {
     private final LiveClientSettings liveClientSettings;
@@ -37,6 +37,8 @@ public class HttpClientFactory {
 
     //Does not contains default httpClientSettings, Params, headers, etd
     public HttpClientBuilder clientEmpty(String url) {
-        return new HttpClientBuilder(url);
+        var settings = new HttpClientSettings();
+        settings.setProxyClientSettings(liveClientSettings.getHttpSettings().getProxyClientSettings());
+        return new HttpClientBuilder(url, settings);
     }
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpProxyClient.java

@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.http;
+
+import io.github.jwdeveloper.tiktok.data.settings.*;
+import io.github.jwdeveloper.tiktok.exceptions.*;
+
+import javax.net.ssl.*;
+import java.io.IOException;
+import java.net.*;
+import java.net.http.*;
+import java.net.http.HttpResponse.ResponseInfo;
+import java.security.*;
+import java.security.cert.X509Certificate;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class HttpProxyClient extends HttpClient
+{
+	private final ProxyClientSettings proxySettings;
+
+	public HttpProxyClient(HttpClientSettings httpClientSettings, String url) {
+		super(httpClientSettings, url);
+		this.proxySettings = httpClientSettings.getProxyClientSettings();
+	}
+
+	public Optional<HttpResponse<byte[]>> toResponse() {
+		return switch (proxySettings.getType()) {
+			case HTTP, DIRECT -> handleHttpProxyRequest();
+			default -> handleSocksProxyRequest();
+		};
+	}
+
+	public Optional<HttpResponse<byte[]>> handleHttpProxyRequest() {
+		var builder = java.net.http.HttpClient.newBuilder()
+			.followRedirects(java.net.http.HttpClient.Redirect.NORMAL)
+			.cookieHandler(new CookieManager())
+			.connectTimeout(httpClientSettings.getTimeout());
+
+		while (proxySettings.hasNext()) {
+			try {
+				InetSocketAddress address = proxySettings.next().toSocketAddress();
+				builder.proxy(ProxySelector.of(address));
+
+				httpClientSettings.getOnClientCreating().accept(builder);
+				var client = builder.build();
+				var request = prepareGetRequest();
+
+				var response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
+				if (response.statusCode() != 200) {
+					proxySettings.setLastSuccess(false);
+					continue;
+				}
+				proxySettings.setLastSuccess(true);
+				return Optional.of(response);
+			} catch (HttpConnectTimeoutException | ConnectException e) {
+				if (proxySettings.isAutoDiscard())
+					proxySettings.remove();
+				proxySettings.setLastSuccess(false);
+			} catch (Exception e) {
+				throw new TikTokLiveRequestException(e);
+			}
+		}
+		throw new TikTokLiveRequestException("No more proxies available!");
+	}
+
+	private Optional<HttpResponse<byte[]>> handleSocksProxyRequest() {
+		try {
+			SSLContext sc = SSLContext.getInstance("SSL");
+			sc.init(null, new TrustManager[]{ new X509TrustManager() {
+				public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {}
+				public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {}
+				public X509Certificate[] getAcceptedIssuers() { return null; }
+			}}, null);
+
+			URL url = toUrl().toURL();
+
+			if (proxySettings.hasNext()) {
+				try {
+					Proxy proxy = new Proxy(Proxy.Type.SOCKS, proxySettings.next().toSocketAddress());
+
+					System.err.println("Connecting to "+ url);
+					HttpsURLConnection socksConnection = (HttpsURLConnection) url.openConnection(proxy);
+					socksConnection.setSSLSocketFactory(sc.getSocketFactory());
+					socksConnection.setConnectTimeout(httpClientSettings.getTimeout().toMillisPart());
+					socksConnection.setReadTimeout(httpClientSettings.getTimeout().toMillisPart());
+
+					byte[] body = socksConnection.getInputStream().readAllBytes();
+
+					Map<String, List<String>> headers = socksConnection.getHeaderFields()
+						.entrySet()
+						.stream()
+						.filter(entry -> entry.getKey() != null)
+						.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+					var responseInfo = createResponseInfo(socksConnection.getResponseCode(), headers);
+
+					var response = createHttpResponse(body, toUrl(), responseInfo);
+
+					proxySettings.setLastSuccess(true);
+					return Optional.of(response);
+				} catch (IOException e) {
+					if (proxySettings.isAutoDiscard())
+						proxySettings.remove();
+					proxySettings.setLastSuccess(false);
+					throw new TikTokProxyRequestException(e);
+				} catch (Exception e) {
+					throw new TikTokLiveRequestException(e);
+				}
+			}
+			throw new TikTokLiveRequestException("No more proxies available!");
+		} catch (NoSuchAlgorithmException | MalformedURLException | KeyManagementException e) {
+			// Should never be reached!
+			System.out.println("handleSocksProxyRequest()! If you see this message, reach us on discord!");
+			e.printStackTrace();
+			return Optional.empty();
+		} catch (TikTokLiveRequestException e) {
+			e.printStackTrace();
+			return Optional.empty();
+		}
+	}
+
+	private ResponseInfo createResponseInfo(int code, Map<String, List<String>> headers) {
+		return new ResponseInfo() {
+			@Override
+			public int statusCode() {
+				return code;
+			}
+
+			@Override
+			public HttpHeaders headers() {
+				return HttpHeaders.of(headers, (s, s1) -> s != null);
+			}
+
+			@Override
+			public java.net.http.HttpClient.Version version() {
+				return java.net.http.HttpClient.Version.HTTP_2;
+			}
+		};
+	}
+
+	private HttpResponse<byte[]> createHttpResponse(byte[] body,
+												   URI uri,
+												   ResponseInfo info) {
+		return new HttpResponse<>()
+		{
+			@Override
+			public int statusCode() {
+				return info.statusCode();
+			}
+
+			@Override
+			public HttpRequest request() {
+				throw new UnsupportedOperationException("TODO");
+			}
+
+			@Override
+			public Optional<HttpResponse<byte[]>> previousResponse() {
+				return Optional.empty();
+			}
+
+			@Override
+			public HttpHeaders headers() {
+				return info.headers();
+			}
+
+			@Override
+			public byte[] body() {
+				return body;
+			}
+
+			@Override
+			public Optional<SSLSession> sslSession() {
+				throw new UnsupportedOperationException("TODO");
+			}
+
+			@Override
+			public URI uri() {
+				return uri;
+			}
+
+			@Override
+			public java.net.http.HttpClient.Version version() {
+				return info.version();
+			}
+		};
+	}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/http/mappers/LiveUserDataMapper.java

@@ -26,12 +26,10 @@ import com.google.gson.JsonParser;
 import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 
-public class LiveUserDataMapper {
-
-
+public class LiveUserDataMapper
+{
     public LiveUserData.Response map(String json) {
-        var parsedJson = JsonParser.parseString(json);
-        var jsonObject = parsedJson.getAsJsonObject();
+        var jsonObject = JsonParser.parseString(json).getAsJsonObject();
 
         var message = jsonObject.get("message").getAsString();
 
@@ -64,6 +62,5 @@ public class LiveUserDataMapper {
         };
 
         return new LiveUserData.Response(json, statusEnum, roomId, startTime);
-
     }
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/TikTokWebSocketClient.java

@@ -23,14 +23,17 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
 
-import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
-import io.github.jwdeveloper.tiktok.TikTokLiveMessageHandler;
+import io.github.jwdeveloper.tiktok.*;
+import io.github.jwdeveloper.tiktok.data.dto.ProxyData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
+import io.github.jwdeveloper.tiktok.data.settings.*;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import org.java_websocket.client.WebSocketClient;
 
+import javax.net.ssl.*;
+import java.net.Proxy;
+import java.security.cert.X509Certificate;
 import java.util.HashMap;
 
 public class TikTokWebSocketClient implements SocketClient {
@@ -49,10 +52,10 @@ public class TikTokWebSocketClient implements SocketClient {
         this.tikTokEventHandler = tikTokEventHandler;
         isConnected = false;
     }
+
     @Override
     public void start(LiveConnectionData.Response connectionData, LiveClient liveClient)
     {
-
         if (isConnected) {
             stop();
         }
@@ -68,8 +71,15 @@ public class TikTokWebSocketClient implements SocketClient {
                 tikTokEventHandler,
                 liveClient);
 
-        try
-        {
+        // ProxyClientSettings proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
+        // if (proxyClientSettings.isEnabled())
+        //     connectProxy(proxyClientSettings);
+		// else
+            connectDefault();
+    }
+
+    private void connectDefault() {
+        try {
             webSocketClient.connect();
             isConnected = true;
         } catch (Exception e)
@@ -79,15 +89,46 @@ public class TikTokWebSocketClient implements SocketClient {
         }
     }
 
+    public void connectProxy(ProxyClientSettings proxySettings) {
+        while (proxySettings.hasNext()) {
+            ProxyData proxyData = proxySettings.next();
+            if (!tryProxyConnection(proxySettings, proxyData)) {
+                if (proxySettings.isAutoDiscard())
+                    proxySettings.remove();
+                continue;
+            }
+            isConnected = true;
+            break;
+        }
+        if (!isConnected)
+            throw new TikTokLiveException("Failed to connect to the websocket");
+    }
 
-
-
+    public boolean tryProxyConnection(ProxyClientSettings proxySettings, ProxyData proxyData) {
+        webSocketClient.setProxy(new Proxy(proxySettings.getType(), proxyData.toSocketAddress()));
+        try {
+            if (proxySettings.getType() == Proxy.Type.SOCKS) {
+                SSLContext sc = SSLContext.getInstance("SSL");
+                sc.init(null, new TrustManager[]{new X509TrustManager() {
+                    public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {}
+                    public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {}
+                    public X509Certificate[] getAcceptedIssuers() { return null; }
+                }}, null);
+                webSocketClient.setSocketFactory(sc.getSocketFactory());
+            }
+            webSocketClient.connect();
+            return true;
+        } catch (Exception e)
+        {
+            return false;
+        }
+    }
 
     public void stop() {
-        if (isConnected && webSocketClient != null) {
+        if (isConnected && webSocketClient != null && webSocketClient.isOpen()) {
             webSocketClient.closeConnection(0, "");
         }
         webSocketClient = null;
         isConnected = false;
     }
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/TikTokWebSocketListener.java

@@ -23,23 +23,18 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
 import com.google.protobuf.ByteString;
-import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
+import io.github.jwdeveloper.tiktok.*;
+import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokProtocolBufferException;
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
-import io.github.jwdeveloper.tiktok.TikTokLiveMessageHandler;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastPushFrame;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
+import io.github.jwdeveloper.tiktok.messages.webcast.*;
 import org.java_websocket.client.WebSocketClient;
 import org.java_websocket.drafts.Draft_6455;
 import org.java_websocket.handshake.ServerHandshake;
 
 import java.net.URI;
 import java.nio.ByteBuffer;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 
 public class TikTokWebSocketListener extends WebSocketClient {
 
@@ -86,13 +81,12 @@ public class TikTokWebSocketListener extends WebSocketClient {
             pushFrameBuilder.setPayload(webcastResponse.getInternalExtBytes());
             if (isNotClosing())
             {
-              this.send(pushFrameBuilder.build().toByteArray());
+                this.send(pushFrameBuilder.build().toByteArray());
             }
         }
         messageHandler.handle(tikTokLiveClient, webcastResponse);
     }
 
-
     @Override
     public void onOpen(ServerHandshake serverHandshake) {
         tikTokEventHandler.publish(tikTokLiveClient, new TikTokConnectedEvent());
@@ -101,10 +95,10 @@ public class TikTokWebSocketListener extends WebSocketClient {
         }
     }
 
-
     @Override
-    public void onClose(int i, String s, boolean b) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokDisconnectedEvent());
+    public void onClose(int code, String reason, boolean remote) {
+        tikTokEventHandler.publish(tikTokLiveClient, new TikTokDisconnectedEvent(reason));
+        tikTokLiveClient.disconnect();
     }
 
     @Override
@@ -115,8 +109,6 @@ public class TikTokWebSocketListener extends WebSocketClient {
         }
     }
 
-
-
     private Optional<WebcastPushFrame> getWebcastPushFrame(byte[] buffer) {
         try {
             var websocketMessage = WebcastPushFrame.parseFrom(buffer);
@@ -141,9 +133,8 @@ public class TikTokWebSocketListener extends WebSocketClient {
         return !isClosed() && !isClosing();
     }
 
-
     @Override
     public void onMessage(String s) {
-
+        // System.err.println(s);
     }
-}
+}

Examples/src/main/java/io/github/jwdeveloper/tiktok/ProxyExample.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok;
+
+import java.net.Proxy;
+
+public class ProxyExample
+{
+    public static void main(String[] args) throws Exception {
+        TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
+            .configure(clientSettings -> {
+                clientSettings.setPrintToConsole(true);
+                clientSettings.getHttpSettings().configureProxy(proxySettings -> {
+                    proxySettings.setOnProxyUpdated(proxyData -> System.err.println("Next proxy: " + proxyData.toString()));
+                    proxySettings.setType(Proxy.Type.SOCKS);
+                    proxySettings.addProxy("localhost", 8080);
+                });
+            })
+            .onConnected((liveClient, event) ->
+                liveClient.getLogger().info("Connected "+liveClient.getRoomInfo().getHostName()))
+            .onDisconnected((liveClient, event) ->
+                liveClient.getLogger().info("Disconnect reason: "+event.getReason()))
+            .onLiveEnded((liveClient, event) ->
+                liveClient.getLogger().info("Live Ended"))
+            .onError((liveClient, event) ->
+                event.getException().printStackTrace())
+            .buildAndConnect();
+        System.in.read();
+    }
+}