Java LibGDX SwingWorker冻结GUI（块上传器）

Question

I am currently working on a chunk uploader (in Java) to upload files to a private server. Everything works perfectly, but while the application is uploading the file, it freezes the window. After the upload everythin returns to normal, but not during. I know it uploads because it works and it displays the progress in the Console. So, I tried to move all the calculations on a different thread. It still ran properly, but froze. Furthermore I read about SwingWorker, and I gave that a go, but it is still freezing the main GUI.

Here is the class for SwingWorker (All methods are in order so you shouldn't get lost, and each contains a comment explaining purpose) (It is a lot of code, but you should really only need to look through the BeginUpload() method, as that is where the loop is located)

public class ChunkUploader extends SwingWorker<String, Object> {
    public String Text="";
    public String Text2="";

    boolean Uploading=false;
    private String Actual="";
    private int CurrentChunk=0;

    private int BytePosition=0;

    private int ChunkSize=100000;
    private String Contents="";
    private String FileName;
    private int PackageNumber;
    private String ByteString;
    private boolean Finalize;
    private String Password;
    private int TotalChunks;
    private byte[] bytes;
    TextPrompt Prompt;

    public double Progress=0;

    public boolean done=false;
    public ChunkUploader(String FileName) {
    //Prepares the thing
        this.FileName=FileName;
        Prompt = new TextPrompt();
    }

    @Override
    protected String doInBackground() throws Exception {
    //Calls the first method
            PrepareUpload(FileName);
        return null;
    }

    private void PrepareUpload(String FileName) {
    //Loads the file and then prompts for a password;
        if(Gdx.files.absolute(FileName).exists()) {
            Actual=FileName;
            System.out.println(FileName);///C:/T/Image.png
            Uploading=true;
            String pp[]=FileName.split("/");
            this.FileName=pp[pp.length-1];
            System.out.println(this.FileName);///C:/T/Forgive.txt
            FileHandle h=Gdx.files.absolute(Actual);
            Text = "Loading file..."+Actual;
            bytes = h.readBytes();
            Text2="";
            Prompt.Prepare("Password", this);
            Gdx.input.getTextInput(Prompt, "Input Dynamic Password:", "");
        }
    }

    public void PromptReturn(String Return, String Text) {
    //Reads the user input into the variable Password. Starts the upload
        if(Return.equals("Password")) {
            Password=Text;
            BeginUpload();
        }
    }

    private void BeginUpload() {
    //Splits the data to chunks and encodes it Base64. Sends the data to Return();

        Text = "Total size: "+Integer.toString(Contents.length());
        TotalChunks=(int) Math.ceil(bytes.length/ChunkSize);
        TotalChunks++;
        String CurrentSend="";
        CurrentChunk=0;

        String All="";

        Text2="Starting Upload...";

        for(int i=0; i<TotalChunks; i++) {
                byte[] temp=GetByteRange(CurrentChunk*ChunkSize, GetWidth(CurrentChunk*ChunkSize, bytes.length, ChunkSize));
                System.out.print(Double.toString(100*BytePosition/bytes.length)+"% complete.");
                Text = Double.toString(100*BytePosition/bytes.length)+"% complete.";
                BytePosition=GetWidth(CurrentChunk*ChunkSize, bytes.length, ChunkSize);

                CurrentSend=Base64.getEncoder().encodeToString(temp);CurrentChunk, false, Password, TotalChunks, FileName);
                String p="";
                while(p.isEmpty()) {
                    try {
                        p=Return(CurrentSend, CurrentChunk, false);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                All = All+CurrentSend;
                CurrentChunk=CurrentChunk+1;
        }
        Text2="Finalizing...";
        String p="";
        while(p.isEmpty()) {
            try {
                p=Return(CurrentSend, TotalChunks, true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        Text2="Upload should be complete.";
    }

    public byte[] GetByteRange(int Start, int End) {
        byte[] temp = new byte[End-Start];

        for(int i=Start; i<End; i++) {
            temp[i-Start] = bytes[i];
        }

        return temp;
    }

    public int GetWidth(int Position, int Size, int ChunkSize) {
        if(Position+ChunkSize<=Size) {
            int p=ChunkSize+Position;
            return p;
        }
        else {
            return Size;
        }
    }

    public String Return(String ByteString, int PackageNumber, boolean finalize) throws Exception {
    //Sends the file data to the server.
        String url = "http://www.stackoverflow.com/";
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();

        con.setRequestMethod("POST");
        con.setRequestProperty("User-Agent", "Mozilla/5.0");
        con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");

        String urlParameters = "Pass="+Password+"&FileName="+FileName+"&PackageNumber="+Integer.toString(PackageNumber)+"&FinalPackageNum="+TotalChunks+"&Bytes="+ByteString;
        if(finalize==true) {
            urlParameters=urlParameters+"&State=Final&FinalPackageNum="+Integer.toString(TotalChunks);
        }
        con.setDoOutput(true);
        DataOutputStream wr = new DataOutputStream(con.getOutputStream());
        wr.write(urlParameters.getBytes(StandardCharsets.UTF_8));
        wr.flush();
        wr.close();

        BufferedReader in = new BufferedReader(
                new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();
        con.disconnect();
        System.out.println(response.toString());
        System.out.println("___________________");
        return response.toString();
    }
}

Here is the LibGDX Screen that the ChunkUploader class is created on.

public class FileUploadScreen implements Screen {
    String FilePath;
    String Text="";
    String Text2="";

    ChunkUploader Uploader;
    OrthographicCamera camera;

    MyGame game;
    public FileUploadScreen(String FilePath, MyGame game) {
        this.game=game;
        camera = new OrthographicCamera();
        camera.setToOrtho(false, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
        this.FilePath = FilePath;
        Uploader = new ChunkUploader(FilePath);
        Uploader.execute();
    }
    @Override
    public void render(float delta) {
        Text=Float.toString(delta);
        game.MainFont.setColor(Color.WHITE);
        game.Screen.set(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
        camera.setToOrtho(false, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
        camera.update();
        game.batch.setProjectionMatrix(camera.combined);

        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        game.batch.begin();
            game.MainFont.draw(game.batch, Text, 100, game.Screen.y-50);
            game.MainFont.draw(game.batch, Text2, 100, game.Screen.y-100);
        game.batch.end();
    }
}

And for good measure, here is the text prompt:

public class TextPrompt implements TextInputListener {
            private String Text="";
            public boolean Active;
            private String Return;
            private ChunkUploader parent;

            public TextPrompt() {
                Active = false;
            }
            public void Prepare(String Return, ChunkUploader Parent) {
                Active = true;
                this.Return=Return;
                this.parent=Parent;
            }
            @Override
            public void input(String text) {
                Text = text;
                Active = false;
                parent.PromptReturn(Return, Text);
            }
            @Override
            public void canceled() {
                Text = "";
                Active = false;
            }
            public String GetInput() {
                return Text;
            }
}

Again, as long as the file is not uploading everything runs fine. I'm just confused, because if it is uploading on a separate thread then it should not be conflicting with the GUI. Can anybody inform me as to what I am doing wrong?

Answer 1

Alright, so it looks like there are a few problems with this. First of all, all methods in the ChunkUploader class need to be called by doInBackground(). When you look inside the PromptReturn method, BeginUpload(); is called.

To fix this, we need to get a little creative. Here are the changes that should be made:

A boolean variable needs to be created that is accessible by both doInBackground() and PromptReturn(). Its initial value should be false.

Next, make this change to the first few methods:

private boolean Begin = false;

public void PromptReturn(String Return, String Text) {
//Reads the user input into the variable Password. Starts the upload
    if(Return.equals("Password")) {
        Password=Text;
        //BeginUpload();
        Begin = true;
    }
}

@Override
protected String doInBackground() throws Exception {
    //Calls the first method, and waits to call the second.
    PrepareUpload(FileName);
    boolean run=true;
    while(run) {
        if(Begin) {
            BeginUpload()
            run=false;
        }
    }
    return null;
}

Furthermore it is worthwhile to note that the Base64 encoder you are using only works with desktop applications. You should consider switching to this Base64 encoder/decoder. It fulfills all of your current needs with the way you are using it, and is super easy to implement. Just copy the Base64.java into your project and you can now use it for desktop and android.