Share Any v2.1.7 - CoolTransfer.java 源代码

package com.genonbeta.CoolSocket;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public abstract class CoolTransfer<T> {
    public static final int DELAY_DISABLED = -1;
    private ExecutorService mExecutor;
    private final ArrayList<TransferHandler<T>> mProcess = new ArrayList<>();
    private int mNotifyDelay = -1;
    private Object mBlockingObject = new Object();

    public enum Flag {
        CONTINUE,
        CANCEL_ALL,
        CANCEL_CURRENT
    }

    public static class ParentBuilder<T> {
        private byte[] mBuffer;
        private T mExtra;
        private long mFileSize;
        private Flag mFlag = Flag.CANCEL_ALL;
        private int mPort;
        private TransferProgress<T> mProgress;
        private long mSkippedBytes;
        private Socket mSocket;

        public byte[] getBuffer() {
            return this.mBuffer;
        }

        public T getExtra() {
            return this.mExtra;
        }

        public long getFileSize() {
            return this.mFileSize;
        }

        public Flag getFlag() {
            return this.mFlag;
        }

        public int getPort() {
            return this.mPort;
        }

        public long getSkippedBytes() {
            return this.mSkippedBytes;
        }

        public Socket getSocket() {
            return this.mSocket;
        }

        public TransferProgress<T> getTransferProgress() {
            if (this.mProgress == null) {
                setTransferProgress(new TransferProgress<>());
            }
            return this.mProgress;
        }

        public ParentBuilder<T> reset() {
            this.mPort = 0;
            this.mFileSize = 0L;
            this.mSkippedBytes = 0L;
            this.mBuffer = null;
            this.mSocket = null;
            getTransferProgress().resetCurrentTransferredByte();
            return this;
        }

        public ParentBuilder<T> setBuffer(byte[] bArr) {
            this.mBuffer = bArr;
            return this;
        }

        public ParentBuilder<T> setExtra(T t10) {
            this.mExtra = t10;
            return this;
        }

        public ParentBuilder<T> setFileSize(long j10) {
            this.mFileSize = j10;
            return this;
        }

        public void setFlag(Flag flag) {
            this.mFlag = flag;
        }

        public ParentBuilder<T> setPort(int i10) {
            this.mPort = i10;
            return this;
        }

        public ParentBuilder<T> setSkippedBytes(long j10) {
            this.mSkippedBytes = j10;
            return this;
        }

        public ParentBuilder<T> setSocket(Socket socket) {
            this.mSocket = socket;
            return this;
        }

        public ParentBuilder<T> setTransferProgress(TransferProgress<T> transferProgress) {
            this.mProgress = transferProgress;
            return this;
        }

        public ParentBuilder<T> skipBytes(long j10) {
            if (getSkippedBytes() > 0) {
                getTransferProgress().decrementTransferredByte(getSkippedBytes());
            }
            setSkippedBytes(j10);
            getTransferProgress().incrementTransferredByte(j10);
            return this;
        }
    }

    public static abstract class Receive<T> extends CoolTransfer<T> {

        public static class Builder<T> extends ParentBuilder<T> {
            private OutputStream mOutputStream;
            private ServerSocket mServerSocket;
            private int mTimeout = -1;

            public OutputStream getOutputStream() {
                return this.mOutputStream;
            }

            public ServerSocket getServerSocket() {
                return this.mServerSocket;
            }

            public int getTimeout() {
                return this.mTimeout;
            }

            @Override
            public ParentBuilder<T> reset() {
                this.mOutputStream = null;
                this.mServerSocket = null;
                this.mTimeout = -1;
                return super.reset();
            }

            public Builder<T> setOutputStream(File file) {
                return setOutputStream(new FileOutputStream(file));
            }

            public Builder<T> setOutputStream(OutputStream outputStream) {
                this.mOutputStream = outputStream;
                return this;
            }

            public Builder<T> setServerSocket(ServerSocket serverSocket) {
                this.mServerSocket = serverSocket;
                return this;
            }

            public Builder<T> setTimeout(int i10) {
                this.mTimeout = i10;
                return this;
            }
        }

        public class Handler extends TransferHandler<T> {
            public Handler(Builder<T> builder) {
                super(builder);
            }

            public Builder<T> getBuilder() {
                return (Builder) getParentBuilder();
            }

            public OutputStream getOutputStream() {
                return getBuilder().getOutputStream();
            }

            public ServerSocket getServerSocket() {
                return getBuilder().getServerSocket();
            }

            public int getTimeout() {
                return getBuilder().getTimeout();
            }

            @Override
            public void onRun() {
                throw new UnsupportedOperationException("Method not decompiled: com.genonbeta.CoolSocket.CoolTransfer.Receive.Handler.onRun():void");
            }

            public void setServerSocket(ServerSocket serverSocket) {
                getBuilder().setServerSocket(serverSocket);
            }

            @Override
            public void skipBytes(long j10) {
                super.skipBytes(j10);
            }
        }

        public abstract Flag onTaskPrepareSocket(TransferHandler<T> transferHandler, ServerSocket serverSocket);

        public Receive<T>.Handler prepare(Builder<T> builder) {
            return new Handler(builder);
        }

        public Receive<T>.Handler receive(Builder<T> builder, boolean z10) {
            return receive(prepare(builder), z10);
        }

        public Receive<T>.Handler receive(Receive<T>.Handler handler, boolean z10) {
            if (z10) {
                handler.run();
            } else {
                getExecutor().submit(handler);
            }
            return handler;
        }
    }

    public static abstract class Send<T> extends CoolTransfer<T> {

        public static class Builder<T> extends ParentBuilder<T> {
            private InputStream mInputStream;
            private String mServerIp;

            public InputStream getInputStream() {
                return this.mInputStream;
            }

            public String getServerIp() {
                return this.mServerIp;
            }

            @Override
            public ParentBuilder<T> reset() {
                this.mInputStream = null;
                this.mServerIp = null;
                return super.reset();
            }

            public Builder<T> setInputStream(File file) {
                return setInputStream(new FileInputStream(file));
            }

            public Builder<T> setInputStream(InputStream inputStream) {
                this.mInputStream = inputStream;
                return this;
            }

            public Builder<T> setServerIp(String str) {
                this.mServerIp = str;
                return this;
            }
        }

        public class Handler extends TransferHandler<T> {
            public Handler(Builder<T> builder) {
                super(builder);
            }

            public Builder<T> getBuilder() {
                return (Builder) getParentBuilder();
            }

            public InputStream getInputStream() {
                return getBuilder().getInputStream();
            }

            public String getServerIp() {
                return getBuilder().getServerIp();
            }

            @Override
            public void onRun() {
                throw new UnsupportedOperationException("Method not decompiled: com.genonbeta.CoolSocket.CoolTransfer.Send.Handler.onRun():void");
            }

            @Override
            public void skipBytes(long j10) {
                super.skipBytes(j10);
                getInputStream().skip(j10);
            }
        }

        public Send<T>.Handler prepare(Builder<T> builder) {
            return new Handler(builder);
        }

        public Send<T>.Handler send(Builder<T> builder, boolean z10) {
            return send(prepare(builder), z10);
        }

        public Send<T>.Handler send(Send<T>.Handler handler, boolean z10) {
            if (z10) {
                handler.run();
            } else {
                getExecutor().submit(handler);
            }
            return handler;
        }
    }

    public enum Status {
        INTERRUPTED,
        RUNNING,
        PENDING
    }

    public static abstract class TransferHandler<T> implements Runnable {
        private ParentBuilder<T> mParentBuilder;
        private Status mStatus = Status.PENDING;

        public TransferHandler(ParentBuilder<T> parentBuilder) {
            this.mParentBuilder = parentBuilder;
        }

        public byte[] getBuffer() {
            return getParentBuilder().getBuffer();
        }

        public T getExtra() {
            return getParentBuilder().getExtra();
        }

        public long getFileSize() {
            return getParentBuilder().getFileSize();
        }

        public Flag getFlag() {
            return getParentBuilder().getFlag();
        }

        public ParentBuilder<T> getParentBuilder() {
            return this.mParentBuilder;
        }

        public int getPort() {
            return getParentBuilder().getPort();
        }

        public long getSkippedBytes() {
            return getParentBuilder().getSkippedBytes();
        }

        public Socket getSocket() {
            return getParentBuilder().getSocket();
        }

        public Status getStatus() {
            return this.mStatus;
        }

        public TransferProgress<T> getTransferProgress() {
            return getParentBuilder().getTransferProgress();
        }

        public abstract void onRun();

        @Override
        public void run() {
            getTransferProgress().resetCurrentTransferredByte();
            setStatus(Status.RUNNING);
            onRun();
            setStatus(Status.INTERRUPTED);
        }

        public void setFlag(Flag flag) {
            getParentBuilder().setFlag(flag);
        }

        public void setSocket(Socket socket) {
            getParentBuilder().setSocket(socket);
        }

        public void setStatus(Status status) {
            this.mStatus = status;
        }

        public void setTransferProgress(TransferProgress<T> transferProgress) {
            getParentBuilder().setTransferProgress(transferProgress);
        }

        public void skipBytes(long j10) {
            getParentBuilder().skipBytes(j10);
        }
    }

    public static class TransferProgress<T> {
        private long mCurrentTransferredByte;
        private long mLastNotified;
        private long mTimeElapsed;
        private long mTimePassed;
        private long mTimeRemaining;
        private long mTotalByte;
        private long mTransferredByte;
        private int mTransferredFileCount;
        private long mStartTime = System.currentTimeMillis();
        private boolean mInterrupted = false;

        public int calculatePercentage(long j10, long j11) {
            return (int) ((100.0f / j10) * j11);
        }

        public long decrementTransferredByte(long j10) {
            this.mCurrentTransferredByte -= j10;
            long j11 = this.mTransferredByte - j10;
            this.mTransferredByte = j11;
            return j11;
        }

        public int decrementTransferredFileCount() {
            int i10 = this.mTransferredFileCount - 1;
            this.mTransferredFileCount = i10;
            return i10;
        }

        public boolean doNotify(CoolTransfer<T> coolTransfer, TransferHandler<T> transferHandler) {
            if (coolTransfer.getNotifyDelay() != -1 && System.currentTimeMillis() - getLastNotified() < coolTransfer.getNotifyDelay()) {
                return false;
            }
            int calculatePercentage = calculatePercentage(getTotalByte(), getTransferredByte());
            setTimeElapsed(System.currentTimeMillis() - getStartTime());
            if (getTotalByte() > 0 && getTransferredByte() > 0) {
                setTimePassed((getTotalByte() * getTimeElapsed()) / getTransferredByte());
                setTimeRemaining(getTimePassed() - getTimeElapsed());
            }
            coolTransfer.onNotify(transferHandler, calculatePercentage);
            this.mLastNotified = System.currentTimeMillis();
            return true;
        }

        public long getCurrentTransferredByte() {
            return this.mCurrentTransferredByte;
        }

        public long getLastNotified() {
            return this.mLastNotified;
        }

        public long getStartTime() {
            return this.mStartTime;
        }

        public long getTimeElapsed() {
            return this.mTimeElapsed;
        }

        public long getTimePassed() {
            return this.mTimePassed;
        }

        public long getTimeRemaining() {
            return this.mTimeRemaining;
        }

        public long getTotalByte() {
            return this.mTotalByte;
        }

        public long getTransferredByte() {
            return this.mTransferredByte;
        }

        public int getTransferredFileCount() {
            return this.mTransferredFileCount;
        }

        public long incrementTransferredByte(long j10) {
            this.mCurrentTransferredByte += j10;
            long j11 = this.mTransferredByte + j10;
            this.mTransferredByte = j11;
            return j11;
        }

        public int incrementTransferredFileCount() {
            int i10 = this.mTransferredFileCount + 1;
            this.mTransferredFileCount = i10;
            return i10;
        }

        public void interrupt() {
            this.mInterrupted = true;
        }

        public boolean isInterrupted() {
            return this.mInterrupted;
        }

        public void resetCurrentTransferredByte() {
            this.mCurrentTransferredByte = 0L;
        }

        public void setStartTime(long j10) {
            this.mStartTime = j10;
        }

        public void setTimeElapsed(long j10) {
            this.mTimeElapsed = j10;
        }

        public void setTimePassed(long j10) {
            this.mTimePassed = j10;
        }

        public void setTimeRemaining(long j10) {
            this.mTimeRemaining = j10;
        }

        public void setTotalByte(long j10) {
            this.mTotalByte = j10;
        }

        public void setTransferredByte(long j10) {
            this.mTransferredByte = j10;
        }

        public void setTransferredFileCount(int i10) {
            this.mTransferredFileCount = i10;
        }
    }

    public void addProcess(TransferHandler<T> transferHandler) {
        synchronized (getProcessList()) {
            getProcessList().add(transferHandler);
            onProcessListChanged(getProcessList(), transferHandler, true);
        }
    }

    public Object getBlockingObject() {
        return this.mBlockingObject;
    }

    public ExecutorService getExecutor() {
        if (this.mExecutor == null) {
            this.mExecutor = Executors.newFixedThreadPool(10);
        }
        return this.mExecutor;
    }

    public int getNotifyDelay() {
        return this.mNotifyDelay;
    }

    public ArrayList<TransferHandler<T>> getProcessList() {
        return this.mProcess;
    }

    public abstract void onDestroy(TransferHandler<T> transferHandler);

    public abstract Flag onError(TransferHandler<T> transferHandler, Exception exc);

    public abstract void onNotify(TransferHandler<T> transferHandler, int i10);

    public abstract Flag onPrepare(TransferHandler<T> transferHandler);

    public void onPrepareNext(TransferHandler<T> transferHandler) {
    }

    public void onProcessListChanged(ArrayList<TransferHandler<T>> arrayList, TransferHandler<T> transferHandler, boolean z10) {
    }

    public abstract void onTaskEnd(TransferHandler<T> transferHandler);

    public Flag onTaskOrientateStreams(TransferHandler<T> transferHandler, InputStream inputStream, OutputStream outputStream) {
        return Flag.CONTINUE;
    }

    public abstract Flag onTaskPrepareSocket(TransferHandler<T> transferHandler);

    public void removeProcess(TransferHandler<T> transferHandler) {
        synchronized (getProcessList()) {
            getProcessList().remove(transferHandler);
            onProcessListChanged(getProcessList(), transferHandler, false);
        }
    }

    public void setBlockingObject(Object obj) {
        this.mBlockingObject = obj;
    }

    public void setExecutor(ExecutorService executorService) {
        this.mExecutor = executorService;
    }

    public void setNotifyDelay(int i10) {
        this.mNotifyDelay = i10;
    }
}