ダイアログの進捗状況を設定します

Question

タスクを通過している間に割合を追加しない非同期タスクがあります。それは、常にここで0/100

は私のコード

 private class getAppInfo extends AsyncTask<String, String, String> { 
    /** The system calls this to perform work in a worker thread and 
     * delivers it the parameters given to AsyncTask.execute() */ 
    ProgressDialog dialog; 

    @Override 
    protected void onPreExecute() { 
     if(showLoading == true){ 
      dialog = new ProgressDialog(SelfHelp.this); 
      dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); 
      dialog.setMessage("Loading"); 
      dialog.setIndeterminate(true); 
      dialog.setCancelable(false); 
      dialog.setMax(100); 
      dialog.setProgress(100); 
      dialog.show(); 
     } 
    } 

    @Override 
    protected String doInBackground(String... urls) {      
     String xml = null; 
     int count = 0; 
     try { 
      // defaultHttpClient 
      DefaultHttpClient httpClient = new DefaultHttpClient(); 
      HttpGet httpGet = new HttpGet(urls[0]); 

      HttpResponse httpResponse = httpClient.execute(httpGet); 
      HttpEntity httpEntity = httpResponse.getEntity(); 
      xml = EntityUtils.toString(httpEntity); 

      while(count != 100){ 
       publishProgress(""+count); 
       count += 5; 
      } 

     } catch (UnsupportedEncodingException e) { 
      e.printStackTrace(); 
     } catch (ClientProtocolException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     }         

     Document doc = parser.GetDomElement(xml); 
     NodeList nl = doc.getElementsByTagName("topic"); 
     getChildElements(nl);       
     return xml; 
    } 


    @Override 
    protected void onProgressUpdate(String... progress) { 
     Log.v("count",progress[0]); 
     dialog.setProgress(Integer.parseInt(progress[0])); 
    } 

    /** The system calls this to perform work in the UI thread and delivers 
     * the result from doInBackground() */ 
    @Override 
    protected void onPostExecute(String result) {  
     //dialog.setProgress(100); 
     menuList.setAdapter(setListItems(menuItems)); 
     menuList.setTextFilterEnabled(true); 
     if(showLoading == true){ 
      dialog.dismiss(); 
      showLoading = false; 
     } 
    } 

それはonProgressUpdateに入りず、カウントが5で上がるが、プログレスバーが変化しないで、0％にとどまります。どうすれば5ずつ増やして、進捗状況を正しく表示できますか？

Answer 1

問題はsetIndeterminate(true)に関連しています。進捗状況を更新する場合は、falseに設定する必要があります。その後、ProgressDialogは古典的なWindowsの砂時計

Answer 2

として動作しますあなたは、コードを次のよう試すことができますがsetIndeterminate(true)、それは％の割合で進行状況を表示されている場合、ここでのコードがあり、

public class ProgressBarExampleActivity extends Activity 
{ 
    ProgressThread progThread; 
    ProgressDialog progDialog; 
    Button button1, button2; 
    int typeBar;      // Determines type progress bar: 0 = spinner, 1 = horizontal 
    int delay = 1000;     // Milliseconds of delay in the update loop 
    int maxBarValue = 30;   // Maximum value of horizontal progress bar 

    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) 
    { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 

//  // Process button to start spinner progress dialog with anonymous inner class 
//  button1 = (Button) findViewById(R.id.Button01); 
//  button1.setOnClickListener(new OnClickListener() 
//  { 
//   public void onClick(View v) 
//   { 
//    typeBar = 0; 
//    showDialog(typeBar); 
//   } 
//  }); 

     // Process button to start horizontal progress bar dialog with anonymous inner class 
     button2 = (Button) findViewById(R.id.Button02); 
     button2.setOnClickListener(new OnClickListener() 
     { 
      public void onClick(View v) 
      { 
       typeBar = 1; 
       showDialog(typeBar); 
      } 
     }); 
    } 

    // Method to create a progress bar dialog of either spinner or horizontal type 
    @Override 
    protected Dialog onCreateDialog(int id) 
    { 
     switch(id) 
     { 
//  case 0:      // Spinner 
//   progDialog = new ProgressDialog(this); 
//   progDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER); 
//   progDialog.setMessage("Loading..."); 
//   progThread = new ProgressThread(handler); 
//   progThread.start(); 
//   return progDialog; 
     case 1:      // Horizontal 
      progDialog = new ProgressDialog(this); 
      progDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); 
      progDialog.setMax(maxBarValue); 
      progDialog.setMessage("Dollars in checking account:"); 
      progThread = new ProgressThread(handler); 
      progThread.start(); 
      return progDialog; 
     default: 
      return null; 
     } 
    } 

    // Handler on the main (UI) thread that will receive messages from the 
    // second thread and update the progress. 

    final Handler handler = new Handler() 
    { 
     public void handleMessage(Message msg) 
     { 
      // Get the current value of the variable total from the message data 
      // and update the progress bar. 
      int total = msg.getData().getInt("total"); 
      progDialog.setProgress(total); 
//   if (total >= maxBarValue) 
      if (total <= 0)    
      { 
       dismissDialog(typeBar); 
       progThread.setState(ProgressThread.DONE); 
      } 
     } 
    }; 

    // Inner class that performs progress calculations on a second thread. Implement 
    // the thread by subclassing Thread and overriding its run() method. Also provide 
    // a setState(state) method to stop the thread gracefully. 

    private class ProgressThread extends Thread 
    { 
     // Class constants defining state of the thread 
     final static int DONE = 0; 
     final static int RUNNING = 1; 

     Handler mHandler; 
     int mState; 
     int total; 

     // Constructor with an argument that specifies Handler on main thread 
     // to which messages will be sent by this thread. 

     ProgressThread(Handler h) 
     { 
      mHandler = h; 
     } 

     // Override the run() method that will be invoked automatically when 
     // the Thread starts. Do the work required to update the progress bar on this 
     // thread but send a message to the Handler on the main UI thread to actually 
     // change the visual representation of the progress. In this example we count 
     // the index total down to zero, so the horizontal progress bar will start full and 
     // count down. 

     @Override 
     public void run() 
     { 
      mState = RUNNING; 
      total = maxBarValue; 
      while (mState == RUNNING) 
      { 
       // The method Thread.sleep throws an InterruptedException if Thread.interrupt() 
       // were to be issued while thread is sleeping; the exception must be caught. 
       try 
       { 
        // Control speed of update (but precision of delay not guaranteed) 
        Thread.sleep(delay); 
       } catch (InterruptedException e) { 
        Log.e("ERROR", "Thread was Interrupted"); 
       } 

       // Send message (with current value of total as data) to Handler on UI thread 
       // so that it can update the progress bar. 

       Message msg = mHandler.obtainMessage(); 
       Bundle b = new Bundle(); 
       b.putInt("total", total); 
       msg.setData(b); 
       mHandler.sendMessage(msg); 

       total--; // Count down 
      } 
     } 

     // Set current state of thread (use state=ProgressThread.DONE to stop thread) 
     public void setState(int state) 
     { 
      mState = state; 
     } 
    } 
} 

は

、出力を参照してください。

Answer 3

AsyncTaskを実行しているサービスからメインUIに戻って通信する方法を実際に探していたときに、私はこの解決策を見つけました。 Luciferのソリューションはサービスのためのモジュールではありません。サービスを1クラス以上使用する必要がある場合（私の場合）は、変数ハンドラにアクセスすることができず、Handler Intent to Service（AsyncTaskに送ることができます）。解決策が放送されています。あなたの活動の

sendBroadcast(new Intent(WORK_DONE)); 

AsyncTaskで

と

private BroadcastReceiver receiver = new BroadcastReceiver() { 
    public void onReceive(Context c, Intent i) { //update your UI here } 
} 

registerReceiver(receiver, new IntentFilter(WORK_DONE)); 

。

アンドロイドの開発者が使用する内部クラスはすべて嫌いです。内部クラスを作成して外部クラス変数にアクセスする方が簡単だと理解していますが、クラスをもう一度使用する必要がある場合は、そのコードを編集する必要があります。私はAndroidにはまったく新しいです、多分私は間違っており、あなたは実際にそれらのクラスを再利用する必要はありません。決して大したプロジェクトではありませんでしたので、私は考えていませんが、大学では、再利用可能なコードをどのようにプログラムするか教えてくれたので、ちょうどいい気がしません。