Beiträge von fargotof

    Hey, danke für die Antwort! Das eine List automatisch mitwächst, habe ich verstanden. Mein Problem ist aber folgendes, hab ich wohl unklar ausgedrückt: Meine Buttons "repräsentieren" Objekte einer Klasse mit jeweils einer id --> Klick auf Button x bearbeitet Objekt mit id=x. Die IDs sind nicht zwingend fortlaufend, sodass ich die Buttons trotzdem gerne so:


    1. Button für Objekt 1
    2. Button für Objekt 2
    3. leer
    4. leer
    5. Button für Objekt 5
    6. Button für Objekt 6
    ...


    in der Liste hätte, was aber bedingt, dass ich der (anfangs leeren) Liste u.U. als erstes zB Button 6 hinzufügen können müsste. Das geht so halt nicht. Aber anscheinend muss ich mir da einen anderen Mechanismus bauen (HashMap o.ä.), was mir nicht so komfortabel erscheint. Richtig?

    Hallo,


    ich hätte mal wieder eine Frage ;) Ich nutze in meiner Activity eine ArrayList festgelegter Kapazität:


    Java
    private ArrayList<Button> inside1Buttons = new ArrayList<Button>(100);


    die ich an anderer Stelle gern mit Buttons füllen möchte. Jeder dieser Buttons benötigt grundsätzlich eine ID, sodass ich gern den "Index" des Buttons innerhalb der Liste hierfür nutzen würde. Leider führt aber z.B.


    Java
    inside1Buttons.set(1, myNewButton);


    zu einer IndexOutOfBoundsException (Invalid index 1, size is 0). Wenn ich mir die ArrayList vorher im Debugger ansehe, besitzt diese tatsächlich ein Array aus 100x "null", aber eine size von "0" (was ja sinnig ist, da size die Anzahl der Objekte liefert).


    Mit einem Array aus Buttons ( Button[] myButtons = new Buttons[100]; ) sollte das Ganze ja funktionieren, mir stellt sich also die Frage - und ich werd nicht recht schlau draus - wo eigentlich genau der Unterschied (Vorteile, Nachteile) zwischen beiden liegt.. Ich kanns grad nicht testen, aber zB iterieren kann ich doch auch über ein Array?


    EDIT: Was dem Array natürlich fehlt sind die Methoden contains(), indexOf(), ... Gibt´s also ggf. einen Weg, o.g. Problem auch mit einer ArrayList zu umgehen?


    Grüße,
    FargoTof

    Hallo zusammen,


    wenn ich z.B. durch


    PHP
    protected static final int SET_COLOR_REQUEST = 0;
    //...
    
    
    public void meineMethode(){
        // ...
        startActivityForResult(myIntent, MEIN_EIGENER_REQUEST);
    }


    mir einen final int für einen RequestCode anlege, steht dieser ja zunächt mal nur der aufrufenden Activity zur Verfügung. In der aufgerufenen Activity müsste ich dann ja ebenfalls ein final int deklarieren, um z.B.


    PHP
    setResult(MEIN_EIGENER_REQUEST, myIntent);


    machen zu können. Einfacher und weniger fehleranfällig wäre es doch aber, wenn alle ResultCodes (und des weiteren betrifft es ja auch Keynamen für Intent-Extras, ...) einmal definiert würden, oder? Wie mache ich das am besten?


    Grüße,
    FargoTof

    Okay, ich hatte schon befürchtet, dass es schwer verständlich ein könnte ;)


    Also: Es geht im Prinzip um eine Art Hausautomation, bei der eine große Anzahl (ca. 100) an RGB-Leuchten 1. einzeln eingestellt werden können soll, 2. diese einzelnen Einstellungen zu Gesamteinstellungen zusammengefasst werden sollen und 3. verschiedene Inszenierungen abgespielt werden können.


    Insbesondere letztere sind es, die mir Sorge bereiten:
    Eine Insznierung besteht dann aus X (ca. 20) Schritten, in der für alle 100 Lichtquellen die zugehörige Einzeleinstellung gespecihert werden muss, also in etwa so:



    Macht also bereits für eine einzige Insznierung ne Menge Daten... Problem ist jetzt also, dass ich das Laden dieser xml (von einem Server) gern ins Model verlagern würde (asynchron muss es ja eh laufen), und gleichzeitig eine Visualisierung in verschiedenen Activities brauche, beispielsweise eine "tabellarische" Ansicht der Inszenierung, ... Und genau da weiß ich eben nicht, wie ich am besten vorgehe: Alle Daten auf einmal laden geht halt mangels Speicher nicht. Also müsste ich irgendwie vom Model "SequenceXY" anfordern können und bräuchte in meiner Activity die entsprechenden Methoden, die das Model nach dem Laden dann zur Übergabe der Daten aufrufen könnte. Nur stellt sich das in meinem Kopf grade recht unübersichtlich und kompliziert dar... :(


    Hast du da eine bessere Idee? (Bestimmt hast du die ;)!)


    PS: XML auf dem zentralen Server wäre grundsätzlich schon das Mittel meiner Wahl, da man da bei Bedarf auch mal "von Hand" ändern könnte.

    Hallo zusammen,


    ergänzend zur ursprünglichen Frage (ist alles halbwegs umgesetzt, superglobale Variable funktioniert soweit) hat sich mittlerweile eine neue Fragestellung ergeben: In meinem zentralen "Model" führe ich alle Dinge durch, die ggf. für mehrere Activities von Belang sein könnten. Dazu gehört nun u.a. auch das "Deserialisieren" verschiedener XML-Files (auf einem externen Server) mithilfe des SimpleXML-Frameworks in einem AsyncTask.


    Problematisch ist, dass es sich um eine recht große Menge an Daten handelt, im entscheidenden Fall um eine Sammlung 200 verschiedener Varianten eines Datensatzes von je etwa 1000 Zeilen Länge. Da das den Memory schnell überlaufen lässt, habe ich mich entschlossen, das Ganze auf Setting000.xml bis Setting200.xml aufzuteilen, die ich dann gern jeweils nach Bedarf laden würde.


    Stellt sich die Frage nach einem vernünftigen Callback-Mechanismus, über den die Activities jeweils ein konkretes Setting "anfordern" könnten: Für eine einzelne Datei wäre das ja noch recht übersichltich zu handeln, aber auch aktuell kamen bereits noch verschiendene andere XML-Files hinzu, sodass alle ModelListener ein mehrere Methoden umfassendes Interface implementieren mussten; im Wesentlichen konnte ich mich aber darauf beschränken, mitzuteilen, wenn eine Datei deserialisiert wurde, also die Daten verfügbar waren.


    Jetzt müsste ich nach meiner Vorstellung aus der Activity dem AsyncTask des Models die Anfrage nach z.B. Setting100 übergeben, das Ergebnis würde dann an alle Listeners, also zB. meine Activity, übergeben. Nun käme dort eine doch recht fehleranfällige Prüfung, ob ich diese Daten überhaupt brauche (zB. ob ich sie überhaupt selber angefordert habe, ...)


    Alles in allem erstmal irgendwie nicht sonderlich übersichtlich und ich frage mich, wie man das geschickter lösen könnte..?! Ich hoffe mein Problem verständlich dargestellt zu haben und freue mich auf eure Vorschläge,


    Viele Grüße,
    FargoTof

    hmm, nagut, ich sehe es ja schon ein.. :) Vllt ist mein Problem auch einfach, dass mir globale Variablen/Singletons immer ein Stück weit als Behelfslösung vorkamen, aber wenn a) es ein "common Java way" ist und b) der bei Stackoverflow genannte Weg über die Einbindung in den App-Context ja noch ein Stück "sauberer" erscheint, nehme ich das vllt einfach mal so hin :)


    Trotzdem mal anders gefragt: Haltet ihr eure Daten / eurer Model auch so, oder habt ihr intelligentere Klassendesigns gefunden, die dieses Problem i.d.R gar nicht erst aufkommen lassen?


    Grüße!

    Das hat zusätzlich den Vorteil, dass du schon mal Daten hast, auch wenn noch nix aus dem Internet angekommen ist.


    Ob du die Daten in einer Document-Struktur hältst oder lieber eine eigene Struktur aufbaust, ist eher Geschmackssache - kommt auch drauf an, ob du die Daten im XML-Format wieder rausgeben möchtest - da ist Document klar im Vorteil. Nur die Zugriffe in den Baum sind ziemlich nervig, wenn man einzelne Werte braucht.



    Hmm, naja, die App wird in einem lokalen Netzwerk mit einer bestehenden Hardware zusammenarbeiten, quasi ein Art Fernbedienung, die "offline" ohnehin keinen Sinn ergibt. Und: Die Daten sollen auch wieder als xml-rausgeschrieben werden - Es ist quasi:


    Aktuelle Einstellungen vom Server laden
    Aktuelle Einstellungen bearbeiten (und dabei "live" anwenden)
    Aktuelle Einstellungen wieder abspeichern


    Von daher muss ich eigentlich nichts persistent auf dem Gerät speichern (zumal die Einstellungen auf dem Server auch von einem zweiten Device aus geändert werden können).

    Du musst doch die Daten sowieso wieder übergeben, unter Android kannst du doch nie wissen ob er die Activity schon aus dem Speicher gehauen hat, weil er Platz brauchte.



    Hmmm, das ist natürlich ein berechtigter Einwand... Allerdings gibt es abgesehen von globalen Variablen wirklich keine Möglichkeit, Daten (ein Model) zu halten, auf die verschiedene Objekte zu verschiedenen Zeiten gleichberechtigt zugreifen können?


    Ich meine das ist ja kein ungewöhnlicher Ansatz, zB einmal Daten zu laden und diese dann auf unterschiedliche Arten (also aus unterschiedlichen Activities) zu bearbeiten..


    FargoTof

    Dann schreib dein doc in eine Klasse, verpasse ihr die Möglichkeit Serializable zu sein und dann halt per putextra / getextra wie gehabt an andere Activities übergeben. (Komplexe Datentypen müssen dieses Interface besitzen.)


    hmm... ist es nicht aber so, dass per putextra beim serialisieren / deserialisieren eine neue Instanz erzeugt wird? Sodass ich nach Änderungen an den Daten beim zurückschalten auf die erste Activity diese wieder extra übergeben muss? Von anderen Programmiersprachen (zuletzt Objektive-C für iOS) bin ich es zB gewohnt, einem neuen ViewController (was ja IN ETWA einer Activity entspricht), einfach eine Referenz auf das entsprechende Objekt zu übergeben..


    Aber generell tue ich mich leider etwas schwer, die einzelnen Funktionen sinnvoll auf Klassen aufzuteilen, MVC und andere Entwurfsmuster hin oder her: In der Theorie klingts immer alles super logisch, in der Praxis trennt sichs schon deutlich schwerer... Gibts denn hierfür irgendwelche allgemeinen Tips?


    Grüße,
    FargoTof

    Hallo zusammen,


    ich hätt´ da mal wieder ein Problem: Es erweitert im grunde einer meiner früheren Fragen, die ich zum Glück als gelöst betrachte. Es geht dabei um eine grundlegende Frage zur Struktur meiner App:


    Ausgangssituation 1:
    - Was will ich können: Ich parse aus meiner main-Activity mit einem DocumentBuilder aus javax.xml.parsers ein XML-Dokument. Ob ich dieses außerhalb der Activity noch brauche, weiß ich noch nicht ganz genau. Ich habe das Ganze jetzt außerdem in einen AsyncTask ausgelagert, der mir nach Ende des Parsens das Attribut setzt, also in Kurzform:



    Frage 1:
    Ist das so soweit erstmal sinnig, also insbesondere "doc" als Attribut anzulegen und dann direkt "aus der Activity heraus" zu parsen? Oder sollte man diese ganze Funktionalität irgendwie in einer weiteren Klasse "kapseln"?


    Frage 2:
    Gesetzt den Fall, ich würde dieses doc nun auch in anderen Activities verwenden wollen (und z.B. auch ändern wollen), wie übergebe ich es dann sinnvollerweise an andere Activities? Ich habe an dieser Stelle einiges über das Singleton-Entwurfsmuster gelesen, aber das wird ja gern auch als versteckte globale Variable verpönt. Also: Letzten Endes sind die Daten des docs gemäß einer Aufteilung in Model-View-Controller ja der Model-Schicht zuzuordnen, wie baue ich mir aber diese Model-Schicht sinnvollerweise am besten auf? Insbesondere könnte ja meine main-Activity nicht die einzige sein, die daran interessiert ist, ob z.B. das Parsen beendet ist?!


    EDIT Frage 3:
    Die letzte Frage ergänzend: Wieviel "Logik" was das Aufbauen irgendwelcher Verbindungen, das Parsen einer xml, ... angeht sollte denn die Activity überhaupt beinhalten?


    Erneut leicht verwirrte Grüße,
    FargoTof

    Danke der Nachfrage ;)... Das ist ja das Seltsame:


    - Ich erzeuge mir in der onCreate() als erstes beim Aufruf von setContentView(R.layout.main); den TextView. Erst dannach instanziere ich die Klasse, die dann die irgendwann newMessage() aufruft.


    - Innerhalb der onCreate() - und auch noch innerhalb der onStart() - kann ich noch problemlos auf die TextView zugreifen und z.B. den Text ändern. Ab da wird es dann komisch.


    Ich kann es jetzt grade nicht nachprüfen, aber ist ggf. auch ein unterschiedliches Verhalten zwischen debug und run denkbar?


    Grüße,
    FargoTof

    Hallo zusammen,


    bei mir kristallisiert sich allmälich ein neues "Problem" heraus


    Ich habe folgende Activity:



    Dabei wird die Methode newMessage von einem anderen Objekt regelmäßig aufgerufen, sodass auch die Runnable updateUI regelmäßig ausgeführt wird, mit der ich den Text einer TextView ändern möchte.


    Wenn ich das Ganze mit einem Breakpoint in der entsprechenden Zeile debugge, kommt es zu folgendem, seltsamen Verhalten:


    - Ich sehe, dass die Zeile wie gewünscht angesprungen wird.
    - Bei der ersten Ausführung vom setText() passiert grundsätzlich nie etwas.
    - Resume ich nun das Debuggen mehrmals, wird "irgendwann" - also nachdem der Breakpoint x-mal angesprungen wurde - der Text endlich gesetzt, mal beim 2. Mal, mal aber auch erst beim 10. Mal...
    - Ausgeführt wird das Ganze aber nach meinem Verständnis immer wie geplant im Main-Thread:


    Thread [<1> main] (Suspended (breakpoint at line 32 in SitzkisteActivity$1))
    MyActivity$1.run() line: 32
    ...


    Ist das jetzt eine nicht zu erklärende Merkwürdigkeit, oder sehe ich nur einen offensichtlichen Fehler nicht?


    Danke und Grüße,
    FargoTof

    Hallo


    ich habe mir eben nochmal alles durchgelesen und bin zu dem Schluss gekommen, dass meine Frage vllt spezieller klingt, als sie eigentlich ist, mir hapert es ja an dieser Stelle vllt an einem gewissen Grundverständnis.


    Daher möchte ich noch einmal mein Ziel formulieren, ggf. ist ja o.g. Ansatz schon zu falsch und zu verwirrend.. ;)


    Also:


    Ich habe ja meine Klasse Connection. Diese dient dazu, die Socketverbindung aufzubauen, auf dem Socket zu lauschen und ggf. auch über entsprechende Methoden etwas darüber zu schreiben.


    In meiner MyAppActivity erzeuge ich mir dazu also eine Instanz von Connection und rufe dessen Methode open() auf. Der Socket wird geöffnet und anschließend meine Runnable runnable als neuer Thread gestartet, der im Hintergrund in Endlossschleife auf eingehende Infos wartet und diese bei Bedarf weiter verarbeitet.


    Soweit so gut. Das von mir geschilderte Problem, nämlich dass ich einen Socket im MainThread öffnen möchte (nämlich beim aufrufen von open()) ließe sich nun noch umgehen, indem ich den try/catch-Block mit dem Öffnen den Sockets mit in die runnable packe. Dann passiert auch das schon im neuen Thread.


    Was aber nun, wenn ich eine weitere Methode, sagen wir sendString(String s) für meine Klasse Connection definieren möchte, mit der man Strings auf den socket schreiben kann:


    PHP
    public void send(String s){
        	try {
            	output.write(s);
            	output.flush();
        	} catch(IOException ex) {
            	// ...
        	}
    	}


    (output ist der OutputStreamWriter vom Socket)


    Wie kriege ich es hin, dass auch dieses Schreiben in einem anderen Thread ausgeführt wird? Weil rufe ich aus Meiner MyAppActivity zb. myConnection.send("Hallo!"); auf, geschieht das ja im Hauptthread (dem UI-Thread), oder nicht?


    Verwirrte Grüße,
    FargoTof

    Also, der Socket bleibt dauerhaft auf und wartet auf Botschaften gemäß eines eigenen Protokolls (in der Endlosschleife). Bei jeder Botschaft wird dann irgendetwas durchgeführt, aber das ist ja erstmal nebensächlich.


    Aber solange ich mir aus meiner Activity heraus wie oben beschriebe meine Instanz von Connection baue, wird open() ja eben auch im Main-Thread ausgeführt, was zu einer NetworkOnMainThreadException führt.


    Viele Grüße,
    Fargotof

    Hallo zusammen,


    ich habe eine Frage zum Thema Threading/Nebenläufigkeit:


    Ausgangssituation:
    Ich habe eine Klasse MyConnection, die


    1. Eine Runable beinhaltet, um den Datenstrom einer Socketverbindung auszuwerten
    2. Eine Methode beinhaltet, die erst diesen Socket aufmacht und dann den Thread für die Runable startet:



    Wenn ich nun in meiner MyAppActivity zB in der onCreate() ein Objekt dieser Klasse erstellen möchte, hängt der Socket ja zunächst mal im Main Thread, was ja werder sinnvoll noch erlaubt ist. Nur: Wie strukturiere ich das besser?


    - Das Öffnen des Sockets mit in die run()-Methode packen (vor die Endlosschleife)?
    - Das Objekt der Klasse MyConnection noch einmal in einer anderen Klasse "kapseln" (Also eine neue Klasse MyWrapper implements runable bekommt eine Methode run(), in der ich das Objekt erzeuge; aus meiner Activity erstelle ich dann ein Objekt von MyWrapper)?
    - ...?


    Vielen Dank schonmal,
    FargoTof