Java ProgressBar，用于显示方法中正在完成的工作的进度，以及如何完成

我试图实现一个ProgressBar，这样当我的应用程序由于试图计算一个有很多东西在进行的方法而变得稍微空闲时，它应该显示该方法的完成进度，这是一个布尔方法，它应该在最后返回true 所以现在我很困惑，当一个进程不是一个整数返回类型的方法时，我是如何作为一个整数值来监控它的

我尝试了很多不同的方法，但当我使用处理程序时，我不知道如何将其编码为：

..当此带有progressbar处理程序的线程完成时，method=true，显示数据

我将展示我在做什么，即使我的逻辑现在可能不太正常

private ProgressDialog progressBar;
private int percentageStatus = 0;
private Handler progressBarHandler = new Handler();


    Thread loadingBar = new Thread(new Runnable() {

            public void run() {


                while(percentageStatus <= 100)
                {
                    percentageStatus++;

                    try 
                    {
                        Thread.sleep(20);
                    } 
                    catch (InterruptedException e) 
                    {
                        e.printStackTrace();
                    }


                    progressBarHandler.post(new Runnable() {

                        public void run() 
                        {
                            progressBar.setProgress(percentageStatus);

                            Log.i("TESTS", "check..." + percentageStatus);
                        }
                    });
                }

                if (percentageStatus >= 100) 
                {


                    try 
                    {
                        Thread.sleep(100);
                    } 
                    catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    // close the progress bar dialog
                    //progressBar.dismiss();

                    progressBar.cancel();
                }
            }
        });



        @Override
        public void onCreate(Bundle savedInstanceState){
            super.onCreate(savedInstanceState);

            progressBar = new ProgressDialog(this);
            progressBar.setCancelable(true);
            progressBar.setMessage("Loading...");
            progressBar.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            progressBar.setProgress(0);
            progressBar.setMax(100);
            progressBar.show();

            loadingBar.start();


            while(doWaitTask() < 100)
            {
                doWaitTask();
            }

            programCreated = true;

            if(programCreated == true)      
            {   
                data = (TextView)findViewById(R.id.debug);      
                MyAsyncTask task = new  MyAsyncTask();
                task.execute(); //this is an async task which just appends some text to a TextView
            }

        }



public int doWaitTask() {

        while (loadingValue <= 10000) {

            loadingValue++;
        }

        return 100;
    }

doWaitTask只是我用来模拟为SSSCCEE而做的一些工作的一种方法

总结一下：当progressBar显示和更新进度时，我试图使屏幕空白，没有文本，一旦进度完成，它应该在进度完成后显示屏幕上的内容，所以我试图让它像加载栏一样工作

---

使用异步任务会更好吗？在这种情况下如何处理？

我要求您使用AsyncTask。您可以在下面找到我们如何使用它的示例：

首先，我们需要创建活动的界面，在我的示例中，我们将使用按钮和进度条：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/myLayout"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<Button
    android:id="@+id/btDoTask"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentLeft="true"
    android:layout_alignParentTop="true"
    android:layout_marginLeft="102dp"
    android:layout_marginTop="24dp"
    android:text="Do Async Task" />
<ProgressBar
    android:id="@+id/pbAsyncBackgroundTraitement"
    style="?android:attr/progressBarStyleHorizontal"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:layout_alignParentLeft="true"
    android:layout_alignParentRight="true"
    android:layout_below="@+id/button1"
    android:layout_marginTop="20dp"    />  
</RelativeLayout>

---

你不应该只是人为地弥补已经取得的进展。完成的进度要么太慢，这将导致任务完成得太早；要么太快，这将导致进度条长时间显示100%

如果你确实知道实际的进展情况，那么你应该使用它。如果处理需要大约相同长度的N个步骤，并且您已经完成了x个步骤，那么您的百分比是100*x/N。使用AsyncTask来包含逻辑是一个很好的方法，可以让UI线程保持响应

另一方面，如果您不知道已经取得了多少进展，那么应该使用不确定模式ProgressBar。引述:

在不确定模式下，进度条显示循环动画 没有进展的迹象。此模式由应用程序使用 当任务的长度未知时。不确定进度条 可以是纺车或水平杆

---

我已经为我想要的做了一个变通，一个非常“确定”的方式

首先，我有一个登录类

公共类登录扩展活动实现OnClickListener

我打算进入一个加载屏幕，该屏幕专门用于等待所需的类加载

公共类加载器扩展登录

我必须创建一个单例来从Login超类获取静态变量数据，原因是，如果我在处理程序中启动了一个intent bundle，那么数据将无法在所需的类中检索，因此，在本例中，我使用了一个postdelayed处理程序，它启动一个Intent，并在处理程序结束之前等待一段指定的时间。这个时间值可以通过反复试验获得，这样我就避免了在活动尝试加载时出现黑屏

公共类MainActivity扩展了FragmentActivity

---

嗯，很有趣，但在这种情况下，我不想把我的work方法放在doInBackground中，因为我实际上打算使用该方法在不同的类之间静态共享数据，ascync任务将锁定其中的所有数据。你说，你想用进度条锁定屏幕来完成你必须做的事情，然后显示结果，我认为asynkTask是这种情况下的命令选择。至于在类之间共享数据，您尝试过Sqlite吗？！通过共享数据，我的意思是共享一个类的静态对象静态实例的数据，而不是共享实际的文本数据；我基本上需要一个方法，它需要在onCreate中运行，而不需要线程。我认为，如果我在doInBackground中再次调用该方法，异步任务可以计算该方法的进度。。我明天会试试我认为你应该有com.example.devhacksecuretest包；不导入com.example.devhacksecuretest.R；您的编译器可能建议您导入com.example.devhacksecuretest.R如果您使用的是默认软件包，android中的默认软件包是无goBoth；，我忘了添加包，但我认为这并不重要，因为您将使用自己的包进行测试，eclipse会自动添加它

package com.exemple.devhacksecuretest.asynctaskwithprogressbar;
import com.example.devhacksecuretest.R;
import android.app.Activity;
import android.os.AsyncTask;
import android.util.Log;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.Toast;

public class CustomAsyncTask extends AsyncTask<String, Integer, Integer>{
    private Activity  mContext;
    private ProgressBar pbAsyncBackgroundTraitement;

    public CustomAsyncTask(Activity  mContext) {
        super();
        this.mContext = mContext;
    }


    /* function which is called first */
    @Override
    protected void onPreExecute() {
        this.pbAsyncBackgroundTraitement = (ProgressBar) mContext.findViewById(R.id.pbAsyncBackgroundTraitement);
        this.pbAsyncBackgroundTraitement.setVisibility(View.VISIBLE);
        super.onPreExecute();
    }


    /* function work on background */
    @Override
    protected Integer doInBackground(String... params) {

        // Here you have to put what you want to do
        for (int i = 0; i< params[0].length(); i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            int progress = (i * 100 / params[0].length());
            Log.i("test", " progress : " + progress);

            //  call onProgressUpdate()
            publishProgress(progress);
        }
        return null;
    }


    /* function to update the ProgressBar */
    @Override
    protected void onProgressUpdate(Integer... values) {

        // update the progress bar
        this.pbAsyncBackgroundTraitement.setProgress(values[0]);
        super.onProgressUpdate(values);
    }

    /* function called after work on background function is over */
    @Override
    protected void onPostExecute(Integer result) {

        // The work is done, you can do an action like create an activity or set invisible some UI components
        this.pbAsyncBackgroundTraitement.setVisibility(View.GONE);
        Toast.makeText(this.mContext, "Work is over... Do what you want now...bla bla bla", Toast.LENGTH_LONG).show();
        super.onPostExecute(result);
    }

}

 public void onClick(View v) {
    // TODO Auto-generated method stub
    switch (v.getId()){
    case R.id.btDoTask:

        // Call CustomAsyncTask
        CustomAsyncTask myCustomTask = new CustomAsyncTask(this);

        // Execute task, we give it the parameter to work with
        myCustomTask.execute("Params to execute in background");
        break;
    }
}

static String port_text;
static String ip_text;
static int portnum;

public void onClick(View v) {

    if(v.getId() == btn1.getId())
    {
        port_text = port.getText().toString();
        ip_text = ip.getText().toString();

        portnum = Integer.parseInt(port_text);  


        /**.....exception handling operations...... 

        **/

            Intent myIntent = new Intent(Login.this, Loader.class);

            startActivity(myIntent);        

    }
}

private ProgressDialog progressBar;

    static LoadingScreen instance;


    static LoadingScreen getInstance()
    {
        return instance;
    }


    public int getPort()
    {
        return portnum;
    }

    public String getIP()
    {
        return ip_text;
    }


    @Override
    public void onCreate(Bundle savedInstanceState){

        super.onCreate(savedInstanceState); 
        setContentView(R.layout.blank_activity);

        instance = this;

        progressBar = new ProgressDialog(this);
        progressBar.setCancelable(true);
        progressBar.setMessage("Loading...");
        progressBar.setProgressStyle(ProgressDialog.STYLE_SPINNER); 
        progressBar.setIndeterminate(true);
        progressBar.show();


        final Intent mainIntent = new Intent(LoadingScreen.this, MainActivity.class); 

        new Handler().postDelayed(new Runnable(){ 

            @Override 
            public void run() { 

                try 
                {
                    Thread.sleep(1000);
                } 
                catch (InterruptedException e) 
                {
                    e.printStackTrace();
                }

                startActivity(mainIntent);              
                finish(); 

                progressBar.cancel();
            } 
        }, 2000);
    }

    Loader ls = Loader.getInstance();

    int port_num = ls.getPort();
    String ip_address = ls.getIP();

/*  ....do operations with the port num and IP address...*/