Thread, Handler,...

Hoi,

so ganz spontan würd ich eine Methode machen, die als int die Runde bekommt und dann via for-Schleife die Buttons malt und ihnen i als Position, wann sie gedrückt werden müssen, mit gebe. Dem letzten gebe ich einen Listener mit, der die methode mit ++runde erneut aufruft.

Gruß,
matze

Hoi,

du kannst mal testen, ob das mit Handler.postDelayed klappt.

Evtl im AsyncTask selbst, in der onPreExecute

view.postDelayed(new Runnable() {


            @Override
            public void run() {
                // TODO Auto-generated method stub
                // do something, or maybe not, if you only wanted to wait
            }
        }, 10000);

Mit CountDownTimer gehts wohl auch.

Gruß,
matze

Das klingt jetzt aber nach einem sehr konstruierten Fall ohne wirklich sinnvollen Hintergrund.

Was soll dir das bringen?
Zumal du einen gewaltigen Fehler machst: UI im Hintergrund manipulieren wollen.
Du darfst Interaktionen mit UI Elementen nur im MainThread oder UI Thread machen.
Was du dort tust ist Folgendes:

Du erstellst dir eine Referenz auf deinen UI Thread.
Du erstellst dir eine Runnable, die den Thread schlafen legt, nen Sound abspielt und den Thread noch mal schlafen legt.
Du startest dein Runnable verzögert auf dem UI Thread.

Dieses gesamte Konstrukt könntest du einfach einsparen und die Schleife direkt in der buttons_zeichnen() durchlaufen.
So hast du das Ganze zwar etwas verkompliziert, aber im Endeffekt nix daran geändert.

Für so etwas sind Threads vermutlich der falsche Weg.
Ein Thread sorgt dafür, dass irgendwas getan wird und dein UI nicht blockiert.
Du möchtest aber, dass dein UI blockiert.
Denn solange du die Farbe(n) deines Buttons aufleuchten lässt soll der User ja nicht herumpfuschen können.

Als erster Punkt solltest du auf jeden Fall zuerst die Buttons erstellen und anzeigen, bevor du irgend etwas Anderes tust.
Idealerweise speicherst du dir die Referenz dieser Buttons in einer List.
Im 'Random'-Bereich lässt du dir dann einfach den Button an der Position der Random-Variable ausgeben, färbst ihn ein, wartest ein bisschen, färbst ihn zurück.
(Hast du noch eine weitere Liste mit Integern kannst du dort deine Random-Variable reinpacken. Dann siehst du später auch, ob richtig geraten wurde.)

Allerdings finde ich, dass Threading da ein völlig unsinniger Ansatz ist. Du brauchst es schlicht nicht und andererseits hindert es dich offenbar auch.

Hoi,

also ich hätte für jeden Button einen AsyncTask angelegt, den einem ThreadPoolExecutor hinzugefügt, der maximal 1 Task im Pool ausführt. Im onPreExecute des AsyncTasks dann x sekunden gewartet, in der doInBackground das Bild geholt und in der onPostExecute das Bild gesetzt.

Nachdem ich das jetzt geschrieben hab, ist das vermutlich etwas zu Überdimensioniert mit Kanonen auf Spatzen geschossen ... hmm. Was anderes weiß ich grad nich, dass das schnufft. Wenn da mal 15 Buttons gemalt werden und ich kein bock mehr hab will ich die App ja auch sofort beenden und nicht warten, bis die Buttons endlich fertig sind, drück scho 5 mal auf meinen Home Button und bekomm dann ein "App reagiert nicht" von Android selbst.

Gruß,
matze

Die Idee mit dem AsyncTask finde ich tatsächlich gut.
Allerdings brauchst du da nicht einen AsyncTask für jeden, sondern einer für alle sollte reichen.
Je nachdem, wie man es implementiert...

Den AsyncTask selbst brauchst du nur, um zu warten. Idealerweise um den Sound abzuspielen und so lange nichts zu tun, bis der Sound fertig ist.
In der onPreExecute zeigst du den Button, in der onPostExecute versteckst du ihn wieder.

Und je nach Runde hast rufst du den Task halt einmal, zweimal oder 75 mal hintereinander auf.
Dann musst du dem Task nur noch mitteilen, welchen Button er vermurksen soll und gut ist.

Zumindest fällt mir das spontan ein.

Probier's aus, könnte auch klappen.

Zitat von tomkicker

Folgender Timer müsste mir doch die Methoden buttons_ausgeben(zahlen[0]), buttons_ausgeben(zahlen[1]), usw im Abstand von 2 Sekunden aufrufen oder?

Keine Ahnung.
Eigentlich nicht. Ich zumindest würde nicht davon ausgehen, dass immer dieselbe Instanz von TimerTask gefeuert wird.
i als private static int zu definieren scheint mir sinnvoller – allerdings kann ich mich natürlich auch irren.

Zitat von tomkicker

Allerdings bricht meine App nach dem ersten Aufruf ab... -.-

Da wäre wichtig zu wissen mit welcher Meldung sie abbricht.
Vermutlich ein Scope Problem. Du willst auf zahlen zugreifen, doch da du dich ja in einer neuen (anonymen inneren) Klasse befindest, wird es zahlen nicht geben.

Hier solltest du auf jeden Fall eine finale Variable erstellen, damit du darauf zugreifen kannst. Oder dir eine eigene Subklasse von TimerTask erstellen, der du dann das Array übergeben kannst.

Mal Code für Möglichkeit 1:

Timer timer = new Timer();
	
final int[] indices = zahlen;
timer.scheduleAtFixedRate(new TimerTask() 
{
  private int i=0;
  public void run() 
  {
    buttons_ausgeben(indices[i++]);
  }
}, 0, 2000);

Ach sooo. Daran liegt das.

Tja, ein Timer startet halt auch einen Hintergrundthread. Der darf nicht einfach so an den Buttons rummalen.

Timer timer = new Timer();
	
final int[] indices = zahlen;
final Handler uiHandler = new Handler();
timer.scheduleAtFixedRate(new TimerTask() 
{
  private int i=0;
  public void run() 
  {
    uiHandler.post(new Runnable() 
    {
      public void run() 
      {
        buttons_ausgeben(indices[i++]);
      }
    });
  }
}, 0, 2000);

Irgendwie so halt.
Also musst du das Anpassen der Buttons auf dem UI Thread machen und sonst nirgends.

Wenn du jetzt weiter kommst ist das prima.
Viel Erfolg weiterhin! =)