SocketTimeoutException when testing on Android Studio simulator - android-studio

Question

When I attempt to connect through a socket to my Android App, I get the following error:
10-02 01: 32: 30.295 1738-1892 / me.schat E / schat / SimpleSocket: java.net.SocketTimeoutException: failed to connect to schat.me/188.40.116.82 (port 7667) after 20000ms
This error occurs only in the emulator. When i test directly on the phone it works.
Internet works on the emulator, the browser opens any website.
My socket code in its entirety
package me.schat.net;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import javax.net.SocketFactory;
import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
public class SimpleSocket {
private static final String TAG = "schat/SimpleSocket";
private final Object m_sendLock = new Object();
private boolean m_authorized = false; // true после успешной авторизации.
private DataInputStream m_in; // Поток чтения транспортных пакетов.
private DataOutputStream m_out; // Поток записи транспортных пакетов.
private Handler m_handler; // Объект доступа к потоку отправки пакетов.
private int m_reconnects = 0; // Число попыток восстановить соединение.
private long m_rxSequence = 0; // Счётчик полученных пакетов.
private long m_txSequence = 0; // Счётчик отправленных пакетов.
private Network network; // Информация для подключения.
private PacketListener m_packets; // Слушатель пакетов.
private Socket m_socket; // Сокет подключения.
private SocketListener m_listener; // Слушатель сокета.
private Thread m_thread; // Поток чтения пакетов.
private Timer m_timer; // Таймер обслуживающий соединение.
private TimerTask m_killTask; // Задача для отключения от сервера, если он не ответил за определённое время.
private TransportReader m_reader; // Объект чтения транспортных пакетов.
private ByteArrayOutputStream m_send = new ByteArrayOutputStream(); // Поток отправки пакетов.
public SimpleSocket(SocketListener listener, PacketListener packets) {
m_listener = listener;
m_packets = packets;
m_reader = new TransportReader(this);
m_timer = new Timer("SocketTimer");
HandlerThread thread = new HandlerThread("simplesocket-thread");
thread.start();
m_handler = new Handler(thread.getLooper());
}
public boolean connect(Network network) {
this.network = network;
return connect();
}
public boolean connect() {
Log.d(TAG, "connect()");
if ((m_thread != null && m_thread.isAlive()) || network == null)
return false;
m_thread = new Thread(new Runnable() {
public void run() {
Log.d(TAG, "RUN " + Thread.currentThread().getId());
int port = network.uri.getPort();
if (port == -1)
port = Protocol.DEFAULT_PORT;
try {
SocketAddress sockaddr = new InetSocketAddress(network.uri.getHost(), port);
SocketFactory factory = SocketFactory.getDefault();
m_socket = factory.createSocket();
m_socket.setTcpNoDelay(true);
m_socket.setKeepAlive(true);
m_socket.connect(sockaddr, Protocol.CONNECT_TIMEOUT);
m_in = new DataInputStream(new BufferedInputStream(m_socket.getInputStream()));
m_out = new DataOutputStream(new BufferedOutputStream(m_socket.getOutputStream()));
} catch (IOException ioe) {
Log.e(TAG, ioe.toString());
reconnect();
return;
}
catch (NullPointerException npe) {
Log.e(TAG, npe.toString());
reconnect();
return;
}
ping();
m_reconnects = 0;
m_listener.onConnect();
m_listener.onAuthRequired();
try {
m_reader.start(m_in);
} catch (IOException ioe) {
Log.e(TAG, "Socket read exception", ioe);
reconnect();
}
}
});
m_thread.start();
return true;
}
public boolean send(final WritablePacket packet) {
List<WritablePacket> packets = new ArrayList<WritablePacket>();
packets.add(packet);
return send(packets);
}
public boolean send(final List<WritablePacket> packets) {
if (packets.isEmpty())
return false;
m_handler.post(new Runnable() {
public void run() {
synchronized (m_sendLock) {
try {
List<byte[]> raws = new ArrayList<byte[]>(packets.size());
int options = Protocol.NO_OPTIONS;
for (WritablePacket packet : packets) {
final byte[] raw = packet.write(m_send).toByteArray();
raws.add(raw);
if (raw.length > 65535)
options = Protocol.HUGE_PACKETS;
}
new TransportWriter(m_out, raws, m_txSequence, options);
m_txSequence++;
} catch (IOException ioe) {
Log.e(TAG, "Send failed", ioe);
}
}
}
});
return true;
}
public final Network getNetwork() {
return network;
}
public final PacketListener packets() {
return m_packets;
}
public final synchronized boolean isAuthorized() {
return m_authorized;
}
public final synchronized void setAuthorized(boolean authorized) {
m_authorized = authorized;
}
public final void leave() {
m_reconnects = -1;
disconnect();
}
/**
* Отключение от сервера.
*/
public final void disconnect() {
if (m_socket == null)
return;
m_handler.post(new Runnable() {
public void run() {
try {
if (m_socket != null) {
m_socket.close();
m_socket = null;
}
} catch (IOException ioe) {
Log.e(TAG, "Error while disconnecting", ioe);
}
if (m_thread != null) {
m_thread.interrupt();
m_thread = null;
}
}
});
}
public final void ping() {
if (m_killTask != null)
m_killTask.cancel();
m_timer.schedule(new TimerTask() {
public void run() {
if (isAuthorized()) {
transmit(new byte[0], Protocol.INTERNAL_PACKET);
m_killTask = new TimerTask() {
public void run() {
disconnect();
}
};
m_timer.schedule(m_killTask, Protocol.REPLY_TIMEOUT);
} else
disconnect();
}
}, Protocol.IDLE_TIMEOUT);
}
private void reconnect() {
if (m_thread != null) {
m_thread.interrupt();
m_thread = null;
}
if (m_reconnects == -1)
return;
if (m_reconnects >= Protocol.MAX_FAST_RECONNECTS + Protocol.MAX_NORMAL_RECONNECTS)
m_reconnects = 0;
++m_reconnects;
m_timer.schedule(new TimerTask() {
public void run() {
connect();
}
}, m_reconnects <= Protocol.MAX_FAST_RECONNECTS ? Protocol.FAST_RECONNECT_TIME : Protocol.NORMAL_RECONNECT_TIME);
m_listener.onReconnect();
}
private boolean transmit(final byte[] packet, final int options) {
List<byte[]> packets = new ArrayList<byte[]>();
packets.add(packet);
return transmit(packets, options);
}
private boolean transmit(final List<byte[]> packets, final int options) {
// Log.d(TAG, "transmit(List<byte[]> packets)");
if (packets.isEmpty())
return false;
m_handler.post(new Runnable() {
public void run() {
synchronized (m_sendLock) {
try {
new TransportWriter(m_out, packets, m_txSequence, options);
if (options != Protocol.INTERNAL_PACKET)
m_txSequence++;
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
return false;
}
}