ProgressBar Horizontal int[ ] Array nacheinander durchlaufen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • ProgressBar Horizontal int[ ] Array nacheinander durchlaufen

    Hallo,

    ich versuche gerade eine ProgressBar (horizontal) zu basteln.

    Dabei soll diese mehrer Zeitabschnitte durchlaufen z.B. int [ ] times = { 10 , 5 , 8 , 15 };

    Zwischendurch sollte man den Prozess auch anhalten können.

    Als erstes hab ich das ganze mit einem CountDownTimer versucht aber der hat nie bis zum ende gezählt, war ein bisschen seltsam das ganze.

    Jetzt bin ich dabei das ganze mit einem extra Thread zu basteln.

    Dabei ist aber das Problem des anderen Thread anzuhalten bzw mitgeteilt zu bekommen dass zb times[0] erledigt ist und ich einen neuen Thread mit times[1] starten kann.
    Bei Anhalten weis ich nicht wie das geht. myThread.destroy() stürzt die App ab und bei stop() auch ... mit interrupt() stürzt die kiste nicht ab aber es passiert auch nicht.

    hier mal mein code:

    Quellcode

    1. package de.heinrich;
    2. import android.app.Activity;
    3. import android.content.Intent;
    4. import android.os.Bundle;
    5. import android.os.Handler;
    6. import android.os.Message;
    7. import android.view.Menu;
    8. import android.view.MenuItem;
    9. import android.widget.ProgressBar;
    10. import android.widget.Toast;
    11. public class ProgressActivity extends Activity {
    12. ProgressBar myProgressBar;
    13. Thread barThread = null;
    14. int myProgress = 0;
    15. int delay = 1000; // eine Sekunde delay
    16. int maxBarValue;
    17. boolean ready = true;
    18. boolean STOP = false;
    19. private final int FINISH = 0;
    20. private static final int CONTINUE = 1;
    21. private static final int MENU_BACK = 1;
    22. private static final int MENU_10 = 2;
    23. private static final int MENU_20 = 3;
    24. private static final int MENU_TIMES = 4;
    25. private static final int STOP_THREAD = 5;
    26. private int[] times = {10, 2, 5, 6, 4};
    27. /** Called when the activity is first created. */
    28. @Override
    29. public void onCreate(Bundle savedInstanceState) {
    30. super.onCreate(savedInstanceState);
    31. setContentView(R.layout.progress);
    32. myProgressBar = (ProgressBar) findViewById(R.id.progress_bar);
    33. }
    34. private Runnable myThread = new Runnable() {
    35. @Override
    36. public void run() {
    37. while (myProgress < maxBarValue && !STOP) {
    38. try {
    39. myHandle.sendMessage(myHandle.obtainMessage(CONTINUE));
    40. Thread.sleep(delay);
    41. } catch (Throwable t) {
    42. }
    43. }
    44. myHandle.sendMessage(myHandle.obtainMessage(FINISH));
    45. }
    46. Handler myHandle = new Handler() {
    47. @Override
    48. public void handleMessage(Message msg) {
    49. switch (msg.what) {
    50. case CONTINUE:
    51. myProgressBar.setProgress(++myProgress);
    52. break;
    53. case FINISH:
    54. myProgress = 0;
    55. myProgressBar.setProgress(myProgress);
    56. ready = true;
    57. Toast.makeText(ProgressActivity.this, "Fertig", Toast.LENGTH_LONG).show();
    58. break;
    59. }
    60. }
    61. };
    62. };
    63. @Override
    64. public boolean onCreateOptionsMenu(Menu menu) {
    65. menu.add(0, MENU_BACK, 0, "Back");
    66. menu.add(0, MENU_10, 0, "Start 10");
    67. menu.add(0, MENU_20, 0, "Start 20");
    68. menu.add(0, MENU_TIMES, 0, "Start Sequenz");
    69. menu.add(0, STOP_THREAD, 0, "Anhalten");
    70. return super.onCreateOptionsMenu(menu);
    71. }
    72. @Override
    73. public boolean onOptionsItemSelected(MenuItem item) {
    74. switch (item.getItemId()) {
    75. case MENU_BACK:
    76. Intent MyIntent = new Intent(ProgressActivity.this, StartActivity.class);
    77. startActivityForResult(MyIntent, 0);
    78. break;
    79. case MENU_10:
    80. maxBarValue = 10;
    81. myProgressBar.setMax(maxBarValue);
    82. barThread = new Thread(myThread);
    83. barThread.start();
    84. break;
    85. case MENU_20:
    86. maxBarValue = 20;
    87. myProgressBar.setMax(maxBarValue);
    88. barThread = new Thread(myThread);
    89. barThread.start();
    90. break;
    91. case MENU_TIMES:
    92. int i = 0;
    93. while (i < times.length) {
    94. if (ready) {
    95. maxBarValue = times[i];
    96. myProgressBar.setMax(times[i]);
    97. barThread = new Thread(myThread);
    98. barThread.start();
    99. ready = false;
    100. i++;
    101. }
    102. }
    103. break;
    104. case STOP_THREAD:
    105. Thread r = barThread;
    106. if (r != null) {
    107. r.interrupt();
    108. }
    109. break;
    110. }
    111. return super.onOptionsItemSelected(item);
    112. }
    113. }
    Alles anzeigen


    mit ready habe ich versucht zu erfahren dass der andere Thread abgeschlossen ist aber das funktioniert iwie nicht.

    Gruß
  • Also generell würd ich das mit AsyncTask machen, als mit nem eigenen Thread. In Android kann man auch nicht wirklich feststellen, ob der Thread fertig ist, außer man implementiert ne eigene Variable dafür in der entsprechenden Unterklasse von Thread. Man muss einen Thread auch nicht anhalten, der hört von alleine auf, wenn er das gemacht hat, was er tun soll...also keine Instruktionen mehr hat.
    Gruß
    Thorsten
  • Ich habe das ganze jetzt mit einem CountDownTimer gemacht ...

    allerdings kommt es mir jetzt so vor als würde die onFinish() anweisung sehr lange brauchen um ausgelöst zu werden, somit ist die TimerFunktion unkonsestent und hat nicht die gleichen Intervalle.

    Doof ist auch und was ich nicht verstehe ... wann wird der erste Tick ausgelöst ? gleich beim starten einer oder erst wenn der erste Intervall abgelaufen ist ... weil bei mir zählt der doofe timer nur bis 3 im endeffekt
    nur durch umbiegen in der onFinish zählt er so weit wie er soll

    Quellcode

    1. package de.heinrich.count;
    2. import android.app.Activity;
    3. import android.os.Bundle;
    4. import android.os.CountDownTimer;
    5. import android.widget.TextView;
    6. import android.widget.Toast;
    7. public class MainActivity extends Activity {
    8. TextView tv;
    9. Integer i = 0;
    10. /** Called when the activity is first created. */
    11. @Override
    12. public void onCreate(Bundle savedInstanceState) {
    13. super.onCreate(savedInstanceState);
    14. tv = new TextView(this);
    15. tv.setText(i.toString());
    16. setContentView(tv);
    17. MyCounter counter = new MyCounter(5, 1);
    18. counter.start();
    19. }
    20. public class MyCounter extends CountDownTimer {
    21. public MyCounter(float secInFuture, float intervall) {
    22. super((long) (secInFuture * 1000), (long) (intervall * 1000));
    23. }
    24. @Override
    25. public void onTick(long l) {
    26. i++;
    27. tv.setText(i.toString());
    28. }
    29. @Override
    30. public void onFinish() {
    31. i++;
    32. tv.setText(i.toString());
    33. Toast.makeText(MainActivity.this, "Fetsch :D", Toast.LENGTH_LONG).show();
    34. }
    35. }
    36. }
    Alles anzeigen



    ---------------------------------------------------------------------------------------------------------------
    alt
    ---------------------------------------------------------------------------------------------------------------

    Ja ich finde das langsam etwas viel code nur um so ne kleine aufgabe zu erledigen.

    Das anhalten des Threads sollte realisiert werden, da ich den ProgressBar anhalten will und wieder weiter laufen lassen.

    Das funktioniert jetzt hab einfach ne boolean STOP eigebaut und den Thread damit vorzeitig aus seiner arbeitsschleife geworfen.

    Problem is jetzt immernoch das abarbeiten der zeiten.

    das funktioniert natürlich nicht:

    Quellcode

    1. case MENU_TIMES:
    2. int i = 0;
    3. while (i < times.length) {
    4. maxBarValue = times[i];
    5. myProgressBar.setMax(times[i]);
    6. barThread = new Thread(myThread);
    7. barThread.start();
    8. ready = false;
    9. i++;}


    die schleife funktioniert natürlich nicht. Ich muss warten bis der erste Thread abgeschlossen ist.

    dann hab ich boolean ready eingebaut um zu erkennen ob der Thread abgeschlossen ist.

    Quellcode

    1. case MENU_TIMES:
    2. int i = 0;
    3. while (i < times.length) {
    4. if (ready) {
    5. maxBarValue = times[i];
    6. myProgressBar.setMax(times[i]);
    7. barThread = new Thread(myThread);
    8. barThread.start();
    9. ready = false;
    10. i++;
    11. }
    Alles anzeigen


    würde wahrscheinlich auch mit Thread.isalive() gehen.

    Das Problem an der ganzen geschichte ist aber das der hauptThread dann in der while hängt, dann könnt ich den sleep() befehl auch gleich da rein schreiben und hätte kein stress mit anderen threads.

    habt ihr ne elegantere lösung?

    AsyncTask ist ja eig nicht viel anders nur dass man zb besser abbrechen kann und so.

    Gruß

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von _PASCAL_ ()

  • Also ich hab jetzt hier eine recht einfach lösung für den Timer, allerdings ist hier das Problem, dass schon bei 30sec der countdown eine sekunde zwischendrin bei 10-15 verschluckt da der interrupt anscheined zu lahm ist.

    Quellcode

    1. package de.heinrich;
    2. import android.app.Activity;
    3. import android.os.Bundle;
    4. import android.os.CountDownTimer;
    5. import android.view.Gravity;
    6. import android.view.View;
    7. import android.widget.LinearLayout;
    8. import android.widget.TextView;
    9. import android.widget.ToggleButton;
    10. public class start extends Activity {
    11. private CountDownTimer cdTimer;
    12. private TextView tv;
    13. private ToggleButton tgg;
    14. private long total = 30000;
    15. /** Called when the activity is first created. */
    16. @Override
    17. public void onCreate(Bundle savedInstanceState) {
    18. super.onCreate(savedInstanceState);
    19. LinearLayout ll = new LinearLayout(this);
    20. ll.setOrientation(LinearLayout.VERTICAL);
    21. tv = new TextView(this);
    22. tgg = new ToggleButton(this);
    23. tgg.setGravity(Gravity.CENTER);
    24. ll.addView(tv);
    25. ll.addView(tgg);
    26. setContentView(ll);
    27. tgg.setOnClickListener(new View.OnClickListener() {
    28. public void onClick(View view) {
    29. if (tgg.isChecked()) {
    30. startCountDownTimer();
    31. } else {
    32. cdTimer.cancel();
    33. }
    34. }
    35. });
    36. }
    37. private void startCountDownTimer() {
    38. cdTimer = new CountDownTimer(total, 1000) {
    39. public void onTick(long millisUntilFinished) {
    40. //update total with the remaining time left
    41. total = millisUntilFinished;
    42. tv.setText("seconds remaining: " + millisUntilFinished/1000);
    43. }
    44. public void onFinish() {
    45. tv.setText("done!");
    46. tgg.setChecked(false);
    47. total = 30000;
    48. }
    49. }.start();
    50. }
    51. }
    Alles anzeigen


    kann man da was machen ?