SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));

        ClientConnectionManager connectionManager = new ThreadSafeClientConnManager(schemeRegistry);

        this.client = new DefaultHttpClient(connectionManager);

package client.Impl;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.InputStreamEntity;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FilePutThread extends FileTransferThread  {

    private HttpPut put;

    private ListenableInputStreamEntity entity;

    public RitconFilePutThread(final HttpClient client, final String fullURL, final File file, final long offset) {
        super(offset, client, file, fullURL);
    }

    @Override
    public void run() {

        this.put = new HttpPut(this.fullURL);

        try {

            putFile();

        } catch (Exception e) {

            //Обработки ошибок пока нет
        }
    }

    @Override
    public void interrupt() {

        if (!super.isInterrupted()) {

            super.interrupt();

            if ((this.put != null) && (!this.put.isAborted())) {

                this.put.abort();

                this.offset = entity.getOffset();
            }
        }
    }


    private void putFile() throws Exception {

        final long localSize = super.fileToTransfer.length();

        entity = getInputStreamEntityToPut(localSize);

        this.put.setEntity(entity);

        this.put.setHeader(CONTENT_RANGE, new ContentRange(offset, localSize).toString());

        this.response = client.execute(put);
    }


    private ListenableInputStreamEntity getInputStreamEntityToPut(final long localSize)

            throws IOException {

        final InputStream inputStream = new FileInputStream(super.fileToTransfer);

        return new ListenableInputStreamEntity(inputStream, super.listener,
                localSize, super.offset);
    }
}

public abstract class FileTransferThread extends Thread {

    protected static final String CONTENT_RANGE = "Content-Range";

    protected HttpClient client;

    protected final File fileToTransfer;

    protected final String fullURL;

    protected HttpResponse response;

    protected TransferProgressListener listener;

    protected long offset;

    public FileTransferThread(final long offset, final HttpClient client,
                                    final File fileToTransfer, final String fullURL) {

        super();

        this.offset = offset;

        this.client = client;

        this.fileToTransfer = fileToTransfer;

        this.fullURL = fullURL;

        this.listener = null;
    }

    public void setListener(final TransferProgressListener listener) {

        this.listener = listener;
    }

    @Override
    public void run() {};


    protected void callUpdateProgress(final long transferred, final long total) {

        if (this.listener != null) {

            final double percentage = ((double)transferred / (double)total) * 100;

            this.listener.progress(percentage);
        }
    }
}

public class ListenableInputStreamEntity extends AbstractHttpEntity {

    private final static int BUFFER_SIZE = 2048;

    private final InputStream content;

    private long length;

    private final TransferProgressListener listener;

    private long transferred = 0L;

    private long offset;


    public ListenableInputStreamEntity(final InputStream instream,
                                       final TransferProgressListener listener,
                                       final long length,
                                       final long offset) {
        super();

        if (instream == null) {
            throw new IllegalArgumentException("Source input stream may not be null");
        }

        this.content = instream;

        this.offset = offset;

        this.length = length;

        this.listener = listener;

        this.offset = offset;
    }


    public boolean isRepeatable() {
        return false;
    }


    public long getContentLength() {
        return this.length;
    }


    public InputStream getContent() throws IOException {
        return this.content;
    }


    public void writeTo(final OutputStream outstream) throws IOException {

        if (outstream == null) {
            throw new IllegalArgumentException("Output stream may not be null");
        }

        final InputStream instream = this.content;

        if (offset > 0L){

            offset = instream.skip(offset);

        } else {

            offset = 0L;
        }

        this.length -= offset;

        try {

            byte[] buffer = new byte[BUFFER_SIZE];

            int l;

            if (this.length < 0) {

                this.transferred = 0L;

                while ((l = instream.read(buffer)) != -1) {

                    outstream.write(buffer, 0, l);

                    this.transferred += l;

                    callUpdateProgress(this.offset + this.transferred, this.length);
                }

            } else {

                long remaining = this.length;

                while (remaining > 0) {

                    l = instream.read(buffer, 0, (int)Math.min(BUFFER_SIZE, remaining));

                    if (l == -1) {
                        break;
                    }

                    outstream.write(buffer, 0, l);

                    remaining -= l;

                    this.transferred += l;

                    callUpdateProgress(this.offset + this.transferred, this.length);
                }
            }

        } finally {

            instream.close();
        }
    }

    protected void callUpdateProgress(final long transferred, final long total) {

        if (this.listener != null) {

            final double percentage = ((double)transferred / (double)total) * 100;

            this.listener.progress(percentage);
        }
    }


    public boolean isStreaming() {
        return true;
    }

    public long getOffset() {

        return this.offset;
    }
}