import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
@Override
public void run() {
    setPriority(Thread.MIN_PRIORITY);
    while (!MTProto.this.isClosed) {
        if (Logger.LOG_THREADS) {
            Logger.d(MTProto.this.TAG, "Response Iteration");
        }
        synchronized (MTProto.this.inQueue) {
            if (MTProto.this.inQueue.isEmpty()) {
                try {
                    MTProto.this.inQueue.wait();
                } catch (InterruptedException e) {
                    return;
                }
            }
            if (MTProto.this.inQueue.isEmpty()) {
                continue;
            }
        }
        MTMessage message = MTProto.this.inQueue.poll();
        onMTMessage(message);
        BytesCache.getInstance().put(message.getContent());
    }
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
@Override
public void run() {
    setPriority(Thread.MIN_PRIORITY);
    while (!isClosed) {
        if (Logger.LOG_THREADS) {
            Logger.d(TAG, "Response Iteration");
        }
        synchronized (inQueue) {
            if (inQueue.isEmpty()) {
                try {
                    inQueue.wait();
                } catch (InterruptedException e) {
                    return;
                }
            }
            if (inQueue.isEmpty()) {
                continue;
            }
        }
        MTMessage message = inQueue.poll();
        onMTMessage(message);
        BytesCache.getInstance().put(message.getContent());
    }
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
private byte[] readBytes(int count, int timeout, InputStream stream) throws IOException {
    byte[] res = BytesCache.getInstance().allocate(count);
    int offset = 0;
    long start = System.nanoTime();
    while (offset < count) {
        int readed = stream.read(res, offset, count - offset);
        Thread.yield();
        if (readed > 0) {
            offset += readed;
            onRead();
        } else if (readed < 0) {
            throw new IOException();
        } else {
            if (System.nanoTime() - start > timeout * 1000000L) {
                throw new IOException();
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Logger.e(TAG, e);
                throw new IOException();
            }
        }
    }
    return res;
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
@Override
public void deserializeBody(InputStream stream, TLContext context) throws IOException {
    this.messageId = readLong(stream);
    int contentSize = stream.available();
    this.content = BytesCache.getInstance().allocate(contentSize);
    readBytes(this.content, 0, contentSize, stream);
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
@Override
public void deserializeBody(InputStream stream, TLContext context) throws IOException {
    this.messageId = readLong(stream);
    this.seqNo = readInt(stream);
    int size = readInt(stream);
    this.content = BytesCache.getInstance().allocate(size);
    readBytes(this.content, 0, size, stream);
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
@Override
public void deserializeBody(InputStream stream, TLContext context) throws IOException {
    messageId = readLong(stream);
    int contentSize = stream.available();
    content = BytesCache.getInstance().allocate(contentSize);
    readBytes(content, 0, contentSize, stream);
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
@Override
public void deserializeBody(InputStream stream, TLContext context) throws IOException {
    messageId = readLong(stream);
    seqNo = readInt(stream);
    int size = readInt(stream);
    content = BytesCache.getInstance().allocate(size);
    readBytes(content, 0, size, stream);
}
 

import org.telegram.mtproto.util.BytesCache; //导入依赖的package包/类
/**
 * Instantiates a new Telegram api.
 *
 * @param state        the state
 * @param _appInfo     the _ app info
 * @param _apiCallback the _ api callback
 */
public TelegramApi(AbsApiState state, AppInfo _appInfo, ApiCallback _apiCallback) {
    this.INSTANCE_INDEX = instanceIndex.incrementAndGet();
    this.TAG = "TelegramApi#" + this.INSTANCE_INDEX;

    long start = System.currentTimeMillis();
    this.apiCallback = _apiCallback;
    this.appInfo = _appInfo;
    this.state = state;
    this.primaryDc = state.getPrimaryDc();
    this.isClosed = false;
    this.callback = new ProtoCallback();
    Logger.d(this.TAG, "Phase 0 in " + (System.currentTimeMillis() - start) + " ms");

    start = System.currentTimeMillis();
    this.apiContext = new TLApiContext() {
        private AtomicInteger integer = new AtomicInteger(0);

        @Override
        public TLObject deserializeMessage(int clazzId, InputStream stream) throws IOException {
            if ((this.integer.incrementAndGet() % 10) == 9) {
                Thread.yield();
            }
            return super.deserializeMessage(clazzId, stream);
        }

        @Override
        public TLBytes allocateBytes(int size) {
            return new TLBytes(BytesCache.getInstance().allocate(size), 0, size);
        }

        @Override
        public void releaseBytes(TLBytes unused) {
            BytesCache.getInstance().put(unused.getData());
        }
    };

    Logger.d(this.TAG, "Phase 1 in " + (System.currentTimeMillis() - start) + " ms");

    start = System.currentTimeMillis();
    this.timeoutThread = new TimeoutThread();
    this.timeoutThread.start();

    this.dcThread = new ConnectionThread();
    this.dcThread.start();

    this.senderThread = new SenderThread();
    this.senderThread.start();
    Logger.d(this.TAG, "Phase 2 in " + (System.currentTimeMillis() - start) + " ms");

    start = System.currentTimeMillis();
    this.downloader = new Downloader(this);
    this.uploader = new Uploader(this);
    Logger.d(this.TAG, "Phase 3 in " + (System.currentTimeMillis() - start) + " ms");
}