https://wiki.byte-welt.net/api.php?action=feedcontributions&feedformat=atom&user=Tomate+SalatByte-Welt Wiki - Benutzerbeiträge [de]2026-07-07T21:53:43ZBenutzerbeiträgeMediaWiki 1.45.1https://wiki.byte-welt.net/index.php?title=Emulatoren&diff=6607Emulatoren2014-10-29T15:35:33Z<p>Tomate Salat: /* Manymo */ Rechtschreibung</p>
<hr />
<div>Eine Liste von verfügbaren Emulatoren für das Android-OS.<br />
<br />
=Standard Emulator=<br />
Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfänger ausreichend, kommt aber aufgrund seiner Trägheit schnell an seine Grenzen. <br />
<br />
=YouWave= <br />
[http://youwave.com/ YouWave] ist eher für Endanwender gedacht und unterstützt keine Tabletansicht. Zudem ist es nicht möglich seine Apps zu debuggen (dies könnte sich in neueren/aktuellen Version geändert haben). Wer kein Android-Gerät besitzt kann diesen Emulator gut dazu verwenden um seine App in einer Umgebung zu testen, die Leistungstechnisch vergleichsweise besser an gängige Smartphones ran kommt als der Standardemulator.<br />
<br />
=Manymo=<br />
[https://www.manymo.com/ Manymo] ist ein kostenpflichtiger cloudbasierter Service - die App muss also auf den Server des Dienstleisters hochgeladen werden. Einmal hochgeladen kann man seine App gegen verschiedene Android-Versionen und Displayauflösungen testen.<br />
<br />
=BlueStacks=<br />
[http://www.bluestacks.com/ BlueStacks] ist ein performanter Emulator für Tablets der auch bei der Entwicklung überzeugen kann. BlueStacks kann auch eine SD-Karte simulieren, das hochladen von eigenen Dateien darauf ist nur etwas versteckt. Einziges aufgefallenes Manko: es ist anscheinend nicht möglich die Google Play Services darauf zu installieren (dies könnte sich in neueren/aktuellen Version geändert haben).<br />
<br />
==Anleitung für die SD-Karte==<br />
Um Dateien auf der SD-Karte von BlueStacks ablegen zu können, müsst ihr die Daten unter folgendem Pfad ablegen:<br />
<br />
C:\ProgramData\BlueStacks\UserData\SharedFolder<br />
<br />
=Virtual Box=<br />
Eine sehr perfomante Möglichkeit Android zu emulieren ist das nutzen von Virtual Box. Eine ausführliche Beschreibung dazu finden Ihr hier: http://blog.geniali.ch/2012/12/15/android-dev-schneller-android-emulator/<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Emulatoren&diff=6606Emulatoren2014-10-29T15:35:04Z<p>Tomate Salat: /* YouWave */ Rechtschreibung</p>
<hr />
<div>Eine Liste von verfügbaren Emulatoren für das Android-OS.<br />
<br />
=Standard Emulator=<br />
Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfänger ausreichend, kommt aber aufgrund seiner Trägheit schnell an seine Grenzen. <br />
<br />
=YouWave= <br />
[http://youwave.com/ YouWave] ist eher für Endanwender gedacht und unterstützt keine Tabletansicht. Zudem ist es nicht möglich seine Apps zu debuggen (dies könnte sich in neueren/aktuellen Version geändert haben). Wer kein Android-Gerät besitzt kann diesen Emulator gut dazu verwenden um seine App in einer Umgebung zu testen, die Leistungstechnisch vergleichsweise besser an gängige Smartphones ran kommt als der Standardemulator.<br />
<br />
=Manymo=<br />
[https://www.manymo.com/ Manymo] ist ein kostenpflichtiger Cloudbasierter Service - die App muss also auf den Server des Dienstleisters hochgeladen werden. Einmal hochgeladen kann man seine App gegen verschiedene Android-Versionen und Displayauflösungen testen. <br />
<br />
=BlueStacks=<br />
[http://www.bluestacks.com/ BlueStacks] ist ein performanter Emulator für Tablets der auch bei der Entwicklung überzeugen kann. BlueStacks kann auch eine SD-Karte simulieren, das hochladen von eigenen Dateien darauf ist nur etwas versteckt. Einziges aufgefallenes Manko: es ist anscheinend nicht möglich die Google Play Services darauf zu installieren (dies könnte sich in neueren/aktuellen Version geändert haben).<br />
<br />
==Anleitung für die SD-Karte==<br />
Um Dateien auf der SD-Karte von BlueStacks ablegen zu können, müsst ihr die Daten unter folgendem Pfad ablegen:<br />
<br />
C:\ProgramData\BlueStacks\UserData\SharedFolder<br />
<br />
=Virtual Box=<br />
Eine sehr perfomante Möglichkeit Android zu emulieren ist das nutzen von Virtual Box. Eine ausführliche Beschreibung dazu finden Ihr hier: http://blog.geniali.ch/2012/12/15/android-dev-schneller-android-emulator/<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Emulatoren&diff=6605Emulatoren2014-10-29T15:28:08Z<p>Tomate Salat: /* Virtual Box */ link zeigt wieder mehr an als nur [1]</p>
<hr />
<div>Eine Liste von verfügbaren Emulatoren für das Android-OS.<br />
<br />
=Standard Emulator=<br />
Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfänger ausreichend, kommt aber aufgrund seiner Trägheit schnell an seine Grenzen. <br />
<br />
=YouWave= <br />
[http://youwave.com/ YouWave] ist eher für Endanwender gedacht und unterstützt keine Tabletansicht. Zudem ist es nicht Möglich seine Apps zu debuggen (dies könnte sich in neueren/aktuellen Version geändert haben). Wer kein Android-Gerät besitzt kann diesen Emulator gut dazu verwenden um seine App in einer Umgebung zu testen, die Leistungstechnisch vergleichsweise besser an gängige Smartphones ran kommt als der Standardemulator.<br />
<br />
=Manymo=<br />
[https://www.manymo.com/ Manymo] ist ein kostenpflichtiger Cloudbasierter Service - die App muss also auf den Server des Dienstleisters hochgeladen werden. Einmal hochgeladen kann man seine App gegen verschiedene Android-Versionen und Displayauflösungen testen. <br />
<br />
=BlueStacks=<br />
[http://www.bluestacks.com/ BlueStacks] ist ein performanter Emulator für Tablets der auch bei der Entwicklung überzeugen kann. BlueStacks kann auch eine SD-Karte simulieren, das hochladen von eigenen Dateien darauf ist nur etwas versteckt. Einziges aufgefallenes Manko: es ist anscheinend nicht möglich die Google Play Services darauf zu installieren (dies könnte sich in neueren/aktuellen Version geändert haben).<br />
<br />
==Anleitung für die SD-Karte==<br />
Um Dateien auf der SD-Karte von BlueStacks ablegen zu können, müsst ihr die Daten unter folgendem Pfad ablegen:<br />
<br />
C:\ProgramData\BlueStacks\UserData\SharedFolder<br />
<br />
=Virtual Box=<br />
Eine sehr perfomante Möglichkeit Android zu emulieren ist das nutzen von Virtual Box. Eine ausführliche Beschreibung dazu finden Ihr hier: http://blog.geniali.ch/2012/12/15/android-dev-schneller-android-emulator/<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Emulatoren&diff=6604Emulatoren2014-10-29T15:27:17Z<p>Tomate Salat: toten link ausgewechselt</p>
<hr />
<div>Eine Liste von verfügbaren Emulatoren für das Android-OS.<br />
<br />
=Standard Emulator=<br />
Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfänger ausreichend, kommt aber aufgrund seiner Trägheit schnell an seine Grenzen. <br />
<br />
=YouWave= <br />
[http://youwave.com/ YouWave] ist eher für Endanwender gedacht und unterstützt keine Tabletansicht. Zudem ist es nicht Möglich seine Apps zu debuggen (dies könnte sich in neueren/aktuellen Version geändert haben). Wer kein Android-Gerät besitzt kann diesen Emulator gut dazu verwenden um seine App in einer Umgebung zu testen, die Leistungstechnisch vergleichsweise besser an gängige Smartphones ran kommt als der Standardemulator.<br />
<br />
=Manymo=<br />
[https://www.manymo.com/ Manymo] ist ein kostenpflichtiger Cloudbasierter Service - die App muss also auf den Server des Dienstleisters hochgeladen werden. Einmal hochgeladen kann man seine App gegen verschiedene Android-Versionen und Displayauflösungen testen. <br />
<br />
=BlueStacks=<br />
[http://www.bluestacks.com/ BlueStacks] ist ein performanter Emulator für Tablets der auch bei der Entwicklung überzeugen kann. BlueStacks kann auch eine SD-Karte simulieren, das hochladen von eigenen Dateien darauf ist nur etwas versteckt. Einziges aufgefallenes Manko: es ist anscheinend nicht möglich die Google Play Services darauf zu installieren (dies könnte sich in neueren/aktuellen Version geändert haben).<br />
<br />
==Anleitung für die SD-Karte==<br />
Um Dateien auf der SD-Karte von BlueStacks ablegen zu können, müsst ihr die Daten unter folgendem Pfad ablegen:<br />
<br />
C:\ProgramData\BlueStacks\UserData\SharedFolder<br />
<br />
=Virtual Box=<br />
Eine sehr perfomante Möglichkeit Android zu emulieren ist das nutzen von Virtual Box. Eine ausführliche Beschreibung dazu finden Ihr hier: [http://blog.geniali.ch/2012/12/15/android-dev-schneller-android-emulator/]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Emulatoren&diff=5703Emulatoren2013-09-16T12:04:55Z<p>Tomate Salat: /* YouWave */</p>
<hr />
<div>Eine Liste von verfügbaren Emulatoren für das Android-OS.<br />
<br />
=Standard Emulator=<br />
Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfänger ausreichend, kommt aber aufgrund seiner Trägheit schnell an seine Grenzen. <br />
<br />
=YouWave= <br />
[http://youwave.com/ YouWave] ist eher für Endanwender gedacht und unterstützt keine Tabletansicht. Zudem ist es nicht Möglich seine Apps zu debuggen (dies könnte sich in neueren/aktuellen Version geändert haben). Wer kein Android-Gerät besitzt kann diesen Emulator gut dazu verwenden um seine App in einer Umgebung zu testen, die Leistungstechnisch vergleichsweise besser an gängige Smartphones ran kommt als der Standardemulator.<br />
<br />
=Manymo=<br />
[https://www.manymo.com/ Manymo] ist ein kostenpflichtiger Cloudbasierter Service - die App muss also auf den Server des Dienstleisters hochgeladen werden. Einmal hochgeladen kann man seine App gegen verschiedene Android-Versionen und Displayauflösungen testen. <br />
<br />
=BlueStacks=<br />
[http://www.bluestacks.com/ BlueStacks] ist ein performanter Emulator für Tablets der auch bei der Entwicklung überzeugen kann. BlueStacks kann auch eine SD-Karte simulieren, das hochladen von eigenen Dateien darauf ist nur etwas versteckt. Einziges aufgefallenes Manko: es ist anscheinend nicht möglich die Google Play Services darauf zu installieren (dies könnte sich in neueren/aktuellen Version geändert haben).<br />
<br />
==Anleitung für die SD-Karte==<br />
Um Dateien auf der SD-Karte von BlueStacks ablegen zu können, müsst ihr die Daten unter folgendem Pfad ablegen:<br />
<br />
C:\ProgramData\BlueStacks\UserData\SharedFolder<br />
<br />
=Virtual Box=<br />
Eine sehr perfomante Möglichkeit Android zu emulieren ist das nutzen von Virtual Box. Eine ausführliche Beschreibung dazu finden Ihr hier: [http://blog.geniali.ch/post/2012/12/15/Android-Dev-%E2%80%93-Schneller-Android-Emulator.aspx http://blog.geniali.ch/post/2012/12/15/Android-Dev-%E2%80%93-Schneller-Android-Emulator.aspx]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Samsung_SDK_(Android)&diff=5660Samsung SDK (Android)2013-09-06T20:15:00Z<p>Tomate Salat: Die Seite wurde neu angelegt: „Hier wird beschrieben, wie man Features aus dem Samsung SDK für Android verwenden kann. Alles nachfolgende setzt also voraus, dass ihr ein Gerät (Smartphone/Tab…“</p>
<hr />
<div>Hier wird beschrieben, wie man Features aus dem Samsung SDK für Android verwenden kann. Alles nachfolgende setzt also voraus, dass ihr ein Gerät (Smartphone/Tablet) von Samsung besitzt und dieses auch die beschriebene Funktionalität unterstützt. Eine Zusammenfassung davon kann hier gefunden werden: http://developer.samsung.com/samsung-mobile-sdk/sdk<br />
<br />
=Multi-Window=<br />
Samsung bietet an, 2 Activitys zur gleichen Zeit offen haben zu können. Zusätzlich existiert noch Leiste in der Apps gelistet werden können, die entsprechende Funktionalität unterstützen. Hier wird sowohl beschrieben wie ihr in eurer App entsprechende Unterstützung schafft.<br />
<br />
==Multi-Window Voraussetzung==<br />
Android 4.1 (16) oder höher<br />
<br />
==Multi-Window-Leiste==<br />
Diese Leiste ist vergleichbar mit dem Android-Launcher, einziger Unterschied: Ihr könnt nur eine Activity aus eurer App in der Leiste anzeigen lassen. Die Multi-Window-Leiste findet eure Activity über den Intent-Filter (welcher in der AndroidManifest.xml gesetzt wird). Dieser Filter enthält alle Elemente, die auch für den Launcher wichtig sind + eine weitere Kategory:<br />
<code=xml><br />
<activity<br />
android:name="de.jfruit.ssdk.MainActivity"<br />
android:label="@string/app_name" <br />
><br />
<intent-filter><br />
<action android:name="android.intent.action.MAIN" /> <br />
<br />
<category android:name="android.intent.category.LAUNCHER" /><br />
<category android:name="android.intent.category.MULTIWINDOW_LAUNCHER" /> <br />
</intent-filter> <br />
</activity> <br />
</code=xml><br />
<br />
Das bedeutet: die Activity die Ihr in der Leiste haben wollt ist zwingend auch im Launcher verfügbar. An dieser Stelle ist eure App allerdings erst zu 50% Multi-Window-Fähig! <br />
<br />
==Multi-Window-Ansicht==<br />
Damit eure App auch wirklich Multi-Window-Fähig ist bedarf es einer weiteren Anpassung eurer Manifest-Datei. Dazu müsst ihr zunächst angeben, dass eine weitere Library verwendet werden soll und einen entsprechenden Meta Eintrag:<br />
<code=xml><br />
<uses-library android:name="com.sec.android.app.multiwindow" android:required="false" /><br />
<meta-data android:name="com.sec.android.support.multiwindow" android:value="true"/><br />
</code=xml><br />
<br />
Diese beiden Zeilen müssen innerhalb des application-Tags eingetragen werden. Nach diesen Zeilen habt ihr die Unterstützung vollständig implementiert und der Anwender kann eure App in der Multi-Window-Ansicht verwenden. Hier nochmals ein komplettes Beispiel, wie eure AndroidMainfest.xml aussehen könnte:<br />
<code=xml><br />
<?xml version="1.0" encoding="utf-8"?><br />
<manifest xmlns:android="http://schemas.android.com/apk/res/android"<br />
package="de.jfruit.ssdk"<br />
android:versionCode="1"<br />
android:versionName="1.0" ><br />
<br />
<uses-sdk<br />
android:minSdkVersion="14"<br />
android:targetSdkVersion="18" /><br />
<br />
<application<br />
android:allowBackup="true"<br />
android:icon="@drawable/ic_launcher"<br />
android:label="@string/app_name"<br />
android:theme="@style/AppTheme"> <br />
<br />
<uses-library android:name="com.sec.android.app.multiwindow" android:required="false" /><br />
<meta-data android:name="com.sec.android.support.multiwindow" android:value="true"/><br />
<br />
<activity<br />
android:name="de.jfruit.ssdk.MainActivity"<br />
android:label="@string/app_name" <br />
><br />
<intent-filter><br />
<action android:name="android.intent.action.MAIN" /> <br />
<br />
<category android:name="android.intent.category.MULTIWINDOW_LAUNCHER" /><br />
<category android:name="android.intent.category.LAUNCHER" /><br />
<br />
</intent-filter> <br />
</activity> <br />
</application><br />
<br />
</manifest><br />
<br />
</code=xml><br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Styles_und_Themes&diff=5453Styles und Themes2013-08-21T09:04:39Z<p>Tomate Salat: /* Eigenschaft von Theme übernehmen */</p>
<hr />
<div>=Styles=<br />
Diese ermöglichen es uns beliebig viele Attribute zusammenzufassen. Wird ein solcher Style einem View zugewiesen, so übernimmt dieser die angegebenen Werte. Um Redundanzen zu vermeiden können Styles aufeinander aufbauen und Werte hinzufügen oder überschreiben.<br />
<br />
Somit helfen uns Styles den Code übersichtlich zu halten und nehmen uns Wartungsaufwand ab. Da ein Style mehreren Elementen zugewiesen werden kann, können wir an einer zentralen Stelle direkten Einfluss auf betroffene Elemente ausüben.<br />
<br />
==Das Grundgerüst==<br />
Styles werden in einer XML-Datei angelegt. Der Name der Datei kann dabei beliebig gewählt werden, oft wird diese aber einfach styles.xml genannt. Diese XML-Datei muss sich im Resourcen-Ordner values befinden. <br />
<br />
Eine einfache xml könnte dann z.B. so aussehen:<br />
<code=xml><br />
<resources><br />
<style name="NameDesStyles"><br />
<!-- Hier werden die Attribute angelegt --><br />
</style><br />
</resources><br />
</code=xml><br />
<br />
Der style-Tag kann beliebg viele item-Tags aufnehmen. Die items besitzen ein Attribut '''name''' welches das Zielattribut definiert. Der zugehörige Wert wird dann als Inhalt in den Tag geschrieben. Hier ein Beispiel wie man einen roten Hintergrund definieren kann:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">#FF0000</item><br />
</style><br />
</code=xml><br />
<br />
==Zuweisung==<br />
Ausgehend von dem obigen Beispiel wollen wir diesen Style nun einem TextView zuweisen. Dazu nutzen wir das Attribut '''style''' und geben dort folgendes an: '''@style/NameDesStyles'''. Nachfolgend ist ein Auszug einer möglichen Layout-Datei zu sehen, die diesen Style verwendet:<br />
<code=xml><br />
<TextView <br />
style="@style/NameDesStyles"<br />
android:layout_width="match_parent"<br />
android:layout_height="wrap_content"<br />
android:text="Foo Bar" /><br />
</code=xml><br />
Im Layout selber haben wir dann letztendlich noch die Möglichkeit die Werte des angegebenen Styles zu überschreiben. Wenn wir also folgendes Attribut setzen würden: '''android:background='#0000FF'''', so wäre der Hintergrund blau und nicht rot.<br />
<br />
==Vererbung==<br />
Dies wollen wir an einem Beispiel verdeutlichen. Angenommen wir haben einen Style welcher das Aussehen eines Eingabefeldes definiert. Zusätzlich brauchen wir ein definiertes Aussehen für das selbe Eingabefeld wenn es gesperrt ist - in diesem Fall soll einfach der Hintergrund Grau sein aber alles andere bleibt gleich. Ohne Vererbung müssten man dies mit zwei Style-Definitionen lösen:<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
Schon in diesem kurzen Beispiel haben wir einiges an Redundanzen. Zusätzlich wird so ein erhöhter Pflegeaufwand + eine potentielle Fehlerquelle geschaffen - denn Änderungen die den Style ''Eingabe'' betreffen, müssen auch im Style ''EingabeGesperrt'' nachgezogen werden. <br />
<br />
Deswegen gibt es eine elegantere Methode wie wir dieses Problem lösen können. Nämlich mithilfe von Vererbung. Dazu gibt es zwei Techniken wie man die Vererbung bewerkstelligen kann. <br />
<br />
===Vererbung: Parent===<br />
Die erste Möglichkeit wie man Vererbung angehen kann ist über das Attribut '''parent''' des style-Tags. Dort gibt man einfach den zu erbenden Style an und die Werte werden entsprechend übernommen. Als Angabe ist sowohl nur der Name des Stils (Eingabe) als auch die "Resourcenschreibweise" (@style/Eingabe) gültig.<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt" parent="Eingabe"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
===Vererbung: Punktnotation===<br />
Die zweite Möglichkeit wäre dann die Punktnotation. Dabei wird nicht das parent-Attribut genutzt, sondern eine spezielle Form der Namensgebung. Zuerst wird der Name des zu erbenden Stils angegeben, danach folgt ein Punkt. Als nächstes schreibt man den eigentlichen Namen des Stils direkt dahinter. In unserem Fall also ''Eingabe.Gesperrt'':<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="Eingabe.Gesperrt"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
Auch von diesem Stil (Eingabe.Gesperrt) kann dann wieder geerbt werden. Eine weitere Vererbung könnte dann z.B. so aussehen: ''Eingabe.Gesperrt.FooBar''.<br />
<br />
=Themes=<br />
Über das Theme kann die App den Bedürfnissen/Vorgaben angepasst werden. Ein Theme ist letztendlich nichts anderes wie ein Style der ganz vielen Eigenschaften vorgibt. Um ein eigenes Theme zu entwickeln bietet es sich an von einem bestehenden zu erben und anzupassen. Dabei sollte aber beachtet werden, dass der Style auch auf jeder Zielplattform verfügbar ist. Um verschiedene Android-Versionen zu unterstützen bietet sich folgende Struktur an:<br />
<br />
<br />
'''values/styles.xml'''<br />
<code=xml><br />
<resources><br />
<style name="AppBaseTheme" parent="android:Theme.Light"><br />
<!-- Für alle Geräte unter Api-11 --><br />
</style><br />
<br />
<!-- Application theme. --><br />
<style name="AppTheme" parent="AppBaseTheme"><br />
<!-- Alle API-Unabhängigen Eigenschaften --><br />
</style><br />
<br />
</resources><br />
</code=xml><br />
<br />
<br />
'''values-v11/styles.xml'''<br />
<code=xml><br />
<resources><br />
<br />
<style name="AppBaseTheme" parent="android:Theme.Holo.Light"><br />
<!-- API 11 theme anpassungen --><br />
</style><br />
<br />
</resources><br />
<br />
</code=xml><br />
<br />
Die App selber nutzt dann den Style '''AppTheme''' als eigentliches Theme und die Plattform entscheidet dann, welche Definition des Styles '''AppBaseTheme''' greift.<br />
<br />
Alternativ bieten Bibliotheken wie [http://actionbarsherlock.com/ ActionbarSherlock] oder das support-package-v7 Themes an, die Rückwärtskompatibel sind. Dann benötigt man keine Unterscheidung der Versionen.<br />
<br />
=Eigenschaft von Theme übernehmen=<br />
Auch hier zunächst ein Beispiel: wir haben einen View mit transparentem Hintergrund und schwarzer Schrift. Würden man nun ein Theme einstellen welches einen schwarzem Hintergrund definiert, dann könnte man den Text nicht mehr lesen. Aus diesem Grund ist es möglich Werte des Styles an Werte des Themes zu binden. Da ein Theme mit schwarzem Hintergrund keine schwarze Schriftfarbe verwenden würde, sollten wir die Textfarbe des Themes für unseren Style übernehmen. Dazu müssen wir einfach nur das gewünschte Attribut angeben und nutzen dazu folgendes Schema: '''?android:attr/[Name]'''. <br />
<br />
Nun wenden wir dies auf das obigen Style an und das ganze schaut dann wie folgt aus:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">?android:background</item><br />
</style><br />
</code=xml><br />
<br />
=Video-Tutorial=<br />
Zu diesem Thema habe ich auch ein Videotutorial gemacht. Dieses findet Ihr hier:[http://www.youtube.com/watch?v=yp1vb_w6LTs Android - Android XML Style + Theme]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Styles_und_Themes&diff=5452Styles und Themes2013-08-21T09:03:06Z<p>Tomate Salat: /* Themes */</p>
<hr />
<div>=Styles=<br />
Diese ermöglichen es uns beliebig viele Attribute zusammenzufassen. Wird ein solcher Style einem View zugewiesen, so übernimmt dieser die angegebenen Werte. Um Redundanzen zu vermeiden können Styles aufeinander aufbauen und Werte hinzufügen oder überschreiben.<br />
<br />
Somit helfen uns Styles den Code übersichtlich zu halten und nehmen uns Wartungsaufwand ab. Da ein Style mehreren Elementen zugewiesen werden kann, können wir an einer zentralen Stelle direkten Einfluss auf betroffene Elemente ausüben.<br />
<br />
==Das Grundgerüst==<br />
Styles werden in einer XML-Datei angelegt. Der Name der Datei kann dabei beliebig gewählt werden, oft wird diese aber einfach styles.xml genannt. Diese XML-Datei muss sich im Resourcen-Ordner values befinden. <br />
<br />
Eine einfache xml könnte dann z.B. so aussehen:<br />
<code=xml><br />
<resources><br />
<style name="NameDesStyles"><br />
<!-- Hier werden die Attribute angelegt --><br />
</style><br />
</resources><br />
</code=xml><br />
<br />
Der style-Tag kann beliebg viele item-Tags aufnehmen. Die items besitzen ein Attribut '''name''' welches das Zielattribut definiert. Der zugehörige Wert wird dann als Inhalt in den Tag geschrieben. Hier ein Beispiel wie man einen roten Hintergrund definieren kann:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">#FF0000</item><br />
</style><br />
</code=xml><br />
<br />
==Zuweisung==<br />
Ausgehend von dem obigen Beispiel wollen wir diesen Style nun einem TextView zuweisen. Dazu nutzen wir das Attribut '''style''' und geben dort folgendes an: '''@style/NameDesStyles'''. Nachfolgend ist ein Auszug einer möglichen Layout-Datei zu sehen, die diesen Style verwendet:<br />
<code=xml><br />
<TextView <br />
style="@style/NameDesStyles"<br />
android:layout_width="match_parent"<br />
android:layout_height="wrap_content"<br />
android:text="Foo Bar" /><br />
</code=xml><br />
Im Layout selber haben wir dann letztendlich noch die Möglichkeit die Werte des angegebenen Styles zu überschreiben. Wenn wir also folgendes Attribut setzen würden: '''android:background='#0000FF'''', so wäre der Hintergrund blau und nicht rot.<br />
<br />
==Vererbung==<br />
Dies wollen wir an einem Beispiel verdeutlichen. Angenommen wir haben einen Style welcher das Aussehen eines Eingabefeldes definiert. Zusätzlich brauchen wir ein definiertes Aussehen für das selbe Eingabefeld wenn es gesperrt ist - in diesem Fall soll einfach der Hintergrund Grau sein aber alles andere bleibt gleich. Ohne Vererbung müssten man dies mit zwei Style-Definitionen lösen:<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
Schon in diesem kurzen Beispiel haben wir einiges an Redundanzen. Zusätzlich wird so ein erhöhter Pflegeaufwand + eine potentielle Fehlerquelle geschaffen - denn Änderungen die den Style ''Eingabe'' betreffen, müssen auch im Style ''EingabeGesperrt'' nachgezogen werden. <br />
<br />
Deswegen gibt es eine elegantere Methode wie wir dieses Problem lösen können. Nämlich mithilfe von Vererbung. Dazu gibt es zwei Techniken wie man die Vererbung bewerkstelligen kann. <br />
<br />
===Vererbung: Parent===<br />
Die erste Möglichkeit wie man Vererbung angehen kann ist über das Attribut '''parent''' des style-Tags. Dort gibt man einfach den zu erbenden Style an und die Werte werden entsprechend übernommen. Als Angabe ist sowohl nur der Name des Stils (Eingabe) als auch die "Resourcenschreibweise" (@style/Eingabe) gültig.<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt" parent="Eingabe"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
===Vererbung: Punktnotation===<br />
Die zweite Möglichkeit wäre dann die Punktnotation. Dabei wird nicht das parent-Attribut genutzt, sondern eine spezielle Form der Namensgebung. Zuerst wird der Name des zu erbenden Stils angegeben, danach folgt ein Punkt. Als nächstes schreibt man den eigentlichen Namen des Stils direkt dahinter. In unserem Fall also ''Eingabe.Gesperrt'':<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="Eingabe.Gesperrt"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
Auch von diesem Stil (Eingabe.Gesperrt) kann dann wieder geerbt werden. Eine weitere Vererbung könnte dann z.B. so aussehen: ''Eingabe.Gesperrt.FooBar''.<br />
<br />
=Themes=<br />
Über das Theme kann die App den Bedürfnissen/Vorgaben angepasst werden. Ein Theme ist letztendlich nichts anderes wie ein Style der ganz vielen Eigenschaften vorgibt. Um ein eigenes Theme zu entwickeln bietet es sich an von einem bestehenden zu erben und anzupassen. Dabei sollte aber beachtet werden, dass der Style auch auf jeder Zielplattform verfügbar ist. Um verschiedene Android-Versionen zu unterstützen bietet sich folgende Struktur an:<br />
<br />
<br />
'''values/styles.xml'''<br />
<code=xml><br />
<resources><br />
<style name="AppBaseTheme" parent="android:Theme.Light"><br />
<!-- Für alle Geräte unter Api-11 --><br />
</style><br />
<br />
<!-- Application theme. --><br />
<style name="AppTheme" parent="AppBaseTheme"><br />
<!-- Alle API-Unabhängigen Eigenschaften --><br />
</style><br />
<br />
</resources><br />
</code=xml><br />
<br />
<br />
'''values-v11/styles.xml'''<br />
<code=xml><br />
<resources><br />
<br />
<style name="AppBaseTheme" parent="android:Theme.Holo.Light"><br />
<!-- API 11 theme anpassungen --><br />
</style><br />
<br />
</resources><br />
<br />
</code=xml><br />
<br />
Die App selber nutzt dann den Style '''AppTheme''' als eigentliches Theme und die Plattform entscheidet dann, welche Definition des Styles '''AppBaseTheme''' greift.<br />
<br />
Alternativ bieten Bibliotheken wie [http://actionbarsherlock.com/ ActionbarSherlock] oder das support-package-v7 Themes an, die Rückwärtskompatibel sind. Dann benötigt man keine Unterscheidung der Versionen.<br />
<br />
=Eigenschaft von Theme übernehmen=<br />
Auch hier zunächst ein Beispiel: wir haben einen View mit transparentem Hintergrund und schwarzer Schrift. Würden wir nun ein Theme einstellen mit schwarzem Hintergrund, dann könnte man den Text nicht mehr lesen. Aus diesem Grund ist es möglich Werte des Styles an Werte des Themes zu binden. Da ein Theme mit schwarzem Hintergrund keine schwarze Schriftfarbe verwenden würde, sollten wir die Textfarbe des Themes für unseren Style übernehmen. Dazu müssen wir einfach nur das gewünschte Attribut angeben und nutzen dazu folgendes Schema: '''?android:attr/[Name]'''. <br />
<br />
Nun wollen wir das mal auf unseren obigen Style anwenden und dieser schaut dann wie folgt aus:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">?android:background</item><br />
</style><br />
</code=xml><br />
<br />
=Video-Tutorial=<br />
Zu diesem Thema habe ich auch ein Videotutorial gemacht. Dieses findet Ihr hier:[http://www.youtube.com/watch?v=yp1vb_w6LTs Android - Android XML Style + Theme]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Styles_und_Themes&diff=5451Styles und Themes2013-08-21T09:00:25Z<p>Tomate Salat: /* Styles */</p>
<hr />
<div>=Styles=<br />
Diese ermöglichen es uns beliebig viele Attribute zusammenzufassen. Wird ein solcher Style einem View zugewiesen, so übernimmt dieser die angegebenen Werte. Um Redundanzen zu vermeiden können Styles aufeinander aufbauen und Werte hinzufügen oder überschreiben.<br />
<br />
Somit helfen uns Styles den Code übersichtlich zu halten und nehmen uns Wartungsaufwand ab. Da ein Style mehreren Elementen zugewiesen werden kann, können wir an einer zentralen Stelle direkten Einfluss auf betroffene Elemente ausüben.<br />
<br />
==Das Grundgerüst==<br />
Styles werden in einer XML-Datei angelegt. Der Name der Datei kann dabei beliebig gewählt werden, oft wird diese aber einfach styles.xml genannt. Diese XML-Datei muss sich im Resourcen-Ordner values befinden. <br />
<br />
Eine einfache xml könnte dann z.B. so aussehen:<br />
<code=xml><br />
<resources><br />
<style name="NameDesStyles"><br />
<!-- Hier werden die Attribute angelegt --><br />
</style><br />
</resources><br />
</code=xml><br />
<br />
Der style-Tag kann beliebg viele item-Tags aufnehmen. Die items besitzen ein Attribut '''name''' welches das Zielattribut definiert. Der zugehörige Wert wird dann als Inhalt in den Tag geschrieben. Hier ein Beispiel wie man einen roten Hintergrund definieren kann:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">#FF0000</item><br />
</style><br />
</code=xml><br />
<br />
==Zuweisung==<br />
Ausgehend von dem obigen Beispiel wollen wir diesen Style nun einem TextView zuweisen. Dazu nutzen wir das Attribut '''style''' und geben dort folgendes an: '''@style/NameDesStyles'''. Nachfolgend ist ein Auszug einer möglichen Layout-Datei zu sehen, die diesen Style verwendet:<br />
<code=xml><br />
<TextView <br />
style="@style/NameDesStyles"<br />
android:layout_width="match_parent"<br />
android:layout_height="wrap_content"<br />
android:text="Foo Bar" /><br />
</code=xml><br />
Im Layout selber haben wir dann letztendlich noch die Möglichkeit die Werte des angegebenen Styles zu überschreiben. Wenn wir also folgendes Attribut setzen würden: '''android:background='#0000FF'''', so wäre der Hintergrund blau und nicht rot.<br />
<br />
==Vererbung==<br />
Dies wollen wir an einem Beispiel verdeutlichen. Angenommen wir haben einen Style welcher das Aussehen eines Eingabefeldes definiert. Zusätzlich brauchen wir ein definiertes Aussehen für das selbe Eingabefeld wenn es gesperrt ist - in diesem Fall soll einfach der Hintergrund Grau sein aber alles andere bleibt gleich. Ohne Vererbung müssten man dies mit zwei Style-Definitionen lösen:<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
Schon in diesem kurzen Beispiel haben wir einiges an Redundanzen. Zusätzlich wird so ein erhöhter Pflegeaufwand + eine potentielle Fehlerquelle geschaffen - denn Änderungen die den Style ''Eingabe'' betreffen, müssen auch im Style ''EingabeGesperrt'' nachgezogen werden. <br />
<br />
Deswegen gibt es eine elegantere Methode wie wir dieses Problem lösen können. Nämlich mithilfe von Vererbung. Dazu gibt es zwei Techniken wie man die Vererbung bewerkstelligen kann. <br />
<br />
===Vererbung: Parent===<br />
Die erste Möglichkeit wie man Vererbung angehen kann ist über das Attribut '''parent''' des style-Tags. Dort gibt man einfach den zu erbenden Style an und die Werte werden entsprechend übernommen. Als Angabe ist sowohl nur der Name des Stils (Eingabe) als auch die "Resourcenschreibweise" (@style/Eingabe) gültig.<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt" parent="Eingabe"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
===Vererbung: Punktnotation===<br />
Die zweite Möglichkeit wäre dann die Punktnotation. Dabei wird nicht das parent-Attribut genutzt, sondern eine spezielle Form der Namensgebung. Zuerst wird der Name des zu erbenden Stils angegeben, danach folgt ein Punkt. Als nächstes schreibt man den eigentlichen Namen des Stils direkt dahinter. In unserem Fall also ''Eingabe.Gesperrt'':<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="Eingabe.Gesperrt"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
Auch von diesem Stil (Eingabe.Gesperrt) kann dann wieder geerbt werden. Eine weitere Vererbung könnte dann z.B. so aussehen: ''Eingabe.Gesperrt.FooBar''.<br />
<br />
=Themes=<br />
Über das Theme kann die eigene App den eigenen Bedürfnissen angepasst werden. Ein Theme ist letztendlich nichts anderes wie ein Styles mit ganz vielen Eigenschaften. Um ein eigenes Theme zu entwickeln bietet es sich demnach an von einem bestehenden zu erben und anzupassen. Dabei sollte aber beachtet werden, dass der Style auch auf jeder Zielplattform verfügbar ist. Um verschiedene Android-Versionen zu unterstützen bietet sich folgende Struktur an:<br />
<br />
<br />
'''values/styles.xml'''<br />
<code=xml><br />
<resources><br />
<style name="AppBaseTheme" parent="android:Theme.Light"><br />
<!-- Für alle Geräte unter Api-11 --><br />
</style><br />
<br />
<!-- Application theme. --><br />
<style name="AppTheme" parent="AppBaseTheme"><br />
<!-- Alle API-Unabhängigen Eigenschaften --><br />
</style><br />
<br />
</resources><br />
</code=xml><br />
<br />
<br />
'''values-v11/styles.xml'''<br />
<code=xml><br />
<resources><br />
<br />
<style name="AppBaseTheme" parent="android:Theme.Holo.Light"><br />
<!-- API 11 theme anpassungen --><br />
</style><br />
<br />
</resources><br />
<br />
</code=xml><br />
<br />
Die App selber nutzt dann den Style '''AppTheme''' als eigentliches Theme und die Plattform entscheidet dann, welche Definition des Styles '''AppBaseTheme''' greift.<br />
<br />
Alternativ bieten Bibliotheken wie [http://actionbarsherlock.com/ ActionbarSherlock] oder das support-package-v7 Themes an, die Rückwärtskompatibel sind. Dann benötigt man keine Unterscheidung der Versionen.<br />
<br />
=Eigenschaft von Theme übernehmen=<br />
Auch hier zunächst ein Beispiel: wir haben einen View mit transparentem Hintergrund und schwarzer Schrift. Würden wir nun ein Theme einstellen mit schwarzem Hintergrund, dann könnte man den Text nicht mehr lesen. Aus diesem Grund ist es möglich Werte des Styles an Werte des Themes zu binden. Da ein Theme mit schwarzem Hintergrund keine schwarze Schriftfarbe verwenden würde, sollten wir die Textfarbe des Themes für unseren Style übernehmen. Dazu müssen wir einfach nur das gewünschte Attribut angeben und nutzen dazu folgendes Schema: '''?android:attr/[Name]'''. <br />
<br />
Nun wollen wir das mal auf unseren obigen Style anwenden und dieser schaut dann wie folgt aus:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">?android:background</item><br />
</style><br />
</code=xml><br />
<br />
=Video-Tutorial=<br />
Zu diesem Thema habe ich auch ein Videotutorial gemacht. Dieses findet Ihr hier:[http://www.youtube.com/watch?v=yp1vb_w6LTs Android - Android XML Style + Theme]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Ftp-Client_Tutorial&diff=5439Ftp-Client Tutorial2013-08-17T20:43:33Z<p>Tomate Salat: </p>
<hr />
<div>= Java Ftp Client Tutorial =<br />
Mache mich mal dran ein Ftp Tutorial zu schreiben. In unserem Tutorial erstellen wir einen FTP Server. Wir verwenden für Das Tutorial die mitgelieferte Klasse aus der neusten Java Version. Für dieses Tutorial solltest du die Grundlagen von Java kennen. Auch empfehle ich eine IDE zu benutzen, die über einen Designer verfügt. <br />
<br />
== Importe ==<br />
<br />
<code=java><br />
import java.awt.List;<br />
import java.awt.event.ActionEvent;<br />
import java.awt.event.ActionListener;<br />
import java.io.File;<br />
import java.io.FileInputStream;<br />
import java.io.FileNotFoundException;<br />
import java.io.FileOutputStream;<br />
import java.io.IOException;<br />
import java.net.InetAddress;<br />
import java.net.InetSocketAddress;<br />
import java.net.SocketAddress;<br />
import java.net.UnknownHostException;<br />
import java.util.ArrayList;<br />
import java.util.Iterator;<br />
import java.util.logging.Level;<br />
import java.util.logging.Logger;<br />
import javax.swing.DefaultListModel;<br />
import javax.swing.JButton;<br />
import javax.swing.JCheckBox;<br />
import javax.swing.JDialog;<br />
import javax.swing.JFileChooser;<br />
import javax.swing.JTextField;<br />
import javax.swing.UIManager;<br />
import javax.swing.UnsupportedLookAndFeelException;<br />
import javax.swing.tree.DefaultTreeModel;<br />
import javax.swing.tree.MutableTreeNode;<br />
import sun.net.ftp.FtpClient;<br />
import sun.net.ftp.FtpDirEntry;<br />
import sun.net.ftp.FtpProtocolException;<br />
</code=java><br />
<br />
<br />
<br />
== Das Frame ==<br />
Ich habe bei mir das Frame mit einer IDE Geschrieben die einen Desingner Verwendet, aber erfahrene Java Programmierer Sollten dies<br />
auch in Wenigen Minuten mit einer IDE die Ohne Designer Arbeitet hinbekommen.<br />
In dem Bild seht Ihr wie ich das Frame Aufgebaut habe.<br />
<br />
<br />
[[Datei:Bild22.PNG|mini|hochkant=1.8|Das Frame]]<br />
<br />
<br />
<br />
<br />
Wie man Seht befinden sich auf dem Form 3 Listen und ein Menüstrip mit 2 Menüs, 3 textfelder, 1 Passwort Feld und ein Button. Ich habe folgende Listen Modelle den listen zugeordnet<br />
<br />
<br />
<br />
* Liste1 (DefaultListModel) mod (diese list zeigt die verzeichnisse an und Verfügt über ein Click ActionEvent<br />
* Liste2 (DefaultListModel) Fmod (diese liste zeigt die Dateien An, aus dem Aktuellen FTP Verzeichniss.<br />
* Liste3 (DefaultListModel) Cmod (diese liste dient als Interne Console)<br />
<br />
<br />
Die Textfelder Werden folgt Verwendet<br />
<br />
* TextFeld1 Hier wird der Server Angegeben<br />
* Textfeld2 Hier wird der Port Angegeben (Achtung der Port Muss Angegeben werden, bei vielen Servern ist der Standardt Port 21)<br />
* Textfeld3 Hier Kommt der Benutzername Rein<br />
* PasswordFeld1 Das Passwort.<br />
<br />
<br />
Das Menü ist Aufgebaut in<br />
<br />
<br />
* File<br />
<br />
** Verbinden<br />
** Trenen<br />
** Daten Uploaden<br />
** Daten Downloaden<br />
** Daten Löschen<br />
** Verzeichniss Löschen<br />
** Verzeichniss Erstellen<br />
<br />
* Edit<br />
** Übergeordneter Ordner<br />
<br />
== Die Codes ==<br />
<br />
=== Variabeln in der Klasse ===<br />
<br />
<code=java><br />
//Suchen nach<br />
public class main extends javax.swing.JFrame {<br />
//hier diese Einträge Darunter Setzen<br />
public DefaultListModel mod;<br />
public FtpClient ftp;<br />
public FtpDirEntry direlement;<br />
public DefaultListModel Fmod;<br />
public DefaultListModel Cmod;<br />
</code=java><br />
<br />
<br />
=== Listen Initialisieren ===<br />
Ich habe So die Listen Initalisiert<br />
<code=java><br />
public main() {<br />
initComponents();<br />
// Hinzufügen<br />
mod = new DefaultListModel();<br />
jList1.setModel(mod);<br />
Fmod = new DefaultListModel();<br />
jList2.setModel(Fmod);<br />
Cmod = new DefaultListModel();<br />
jList3.setModel(Cmod); <br />
}<br />
</code=java><br />
<br />
=== Das Verbinden Action Event ===<br />
<code=java><br />
// Elemente aus Modellen Löschen<br />
Fmod.removeAllElements();<br />
mod.removeAllElements();<br />
// deklariren<br />
// Deklarieren des List Models<br />
mod = (DefaultListModel) jList1.getModel();<br />
// holen des Inhaltes aus der Server Text Box<br />
String servUrl=jTextField1.getText();<br />
// holen des Inhaltes aus der Port Text Box<br />
int port=Integer.parseInt(jTextField2.getText());<br />
// Internet Adresse umwandln in IP<br />
String ipAdr = InetAddress.getByName(servUrl).getHostAddress();<br />
// Consolen Anzeige<br />
Cmod.addElement("Encode Adresse " + servUrl + " in IP Adresse " + ipAdr);<br />
System.out.println("Endode Addresse in IP: " + ipAdr); <br />
// Socket Addresse Deklarieren<br />
SocketAddress sAdr = new InetSocketAddress(ipAdr,port);<br />
// Deklarieren des ftpClients<br />
ftp = FtpClient.create();<br />
<br />
// Benutzername Festelgen<br />
String userName = jTextField3.getText();<br />
<br />
//Verbindung Aufbauen<br />
ftp.connect(sAdr);<br />
//Wen Verbindung Besteht, einlogen<br />
if(ftp.isConnected()==true){<br />
// Console giebt aus das wir uns erfolgreich verbunden haben<br />
Cmod.addElement("Erfolgreich mit Server " + ipAdr + " Verbunden");<br />
System.out.println("Erfolgreich mit Server " + ipAdr + " Verbunden");<br />
// Wir lassen Uns die Begrüßungsnachricht ausgeben<br />
System.out.print(ftp.getWelcomeMsg());<br />
Cmod.addElement(ftp.getWelcomeMsg());<br />
// Hier Loggen wir uns in den Server ein<br />
ftp.login(userName, jPasswordField1.getPassword());<br />
// Wenn wir Eingelogt Sind <br />
if(ftp.isLoggedIn()==true){<br />
// Wir Bekommen eine nachricht vom Server das wir uns Erfolgreich Eingelogt sind<br />
Cmod.addElement("User " + userName + " Access Garanted");<br />
System.out.println("User: " + userName + " ist erfolgreich im Server eingelogt");<br />
// Nun deklarieren wir unser Aktuelles Verzeichniss<br />
String dir = ftp.getWorkingDirectory();<br />
// Nun lesen wir die Verzeichnisse Aus<br />
Iterator<FtpDirEntry> dirlist = ftp.listFiles(dir);<br />
// Listview Model leeren<br />
mod.removeAllElements();<br />
// hinzufügen der neune Verzeichnisse<br />
while(dirlist.hasNext()){<br />
// elemnt in die DirEntry hinzufügen<br />
direlement = dirlist.next();<br />
// Prüfen ob es ein Verzeichniss ist<br />
if(direlement.getType()==FtpDirEntry.Type.DIR){<br />
// in Model Hinzufügen<br />
mod.addElement(direlement.getName());<br />
}<br />
if(direlement.getType()==FtpDirEntry.Type.FILE){<br />
Fmod.addElement(direlement.getName());<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
<br />
} catch (UnknownHostException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
</code=java><br />
<br />
=== Das Trennen Action Event ===<br />
<br />
<code=java><br />
try {<br />
// TODO add your handling code here:<br />
ftp.close();<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
</code=java><br />
<br />
=== Das listview ClickAction Event ===<br />
<code=java><br />
// List Model Deklarieren<br />
mod = (DefaultListModel) jList1.getModel();<br />
// Prüfen ob der Client noch Verbunden ist <br />
if(ftp.isConnected()==true){<br />
//prüfen ob wir noch eingelogt sind<br />
if(ftp.isLoggedIn()==true){<br />
try {<br />
//Verzeichniss Wechselen<br />
ftp.changeDirectory(jList1.getSelectedValue().toString());<br />
// System giebt aus das das Verzeichniss gewechselt wurde<br />
Cmod.addElement("Verzeichniss Gewechelt nach: " + ftp.getWorkingDirectory());<br />
System.out.print("Verzeichniss Gewechselt nach :" + ftp.getWorkingDirectory());<br />
// wir Listen die Files in dem Neune Verzeichniss<br />
Iterator<FtpDirEntry> dirs = ftp.listFiles(ftp.getWorkingDirectory());<br />
// wir Löschen die Alten List items<br />
mod.removeAllElements();<br />
Fmod.removeAllElements();<br />
// Wir Tragen die Verzeichniss ein<br />
while(dirs.hasNext()){<br />
// wir Deklarieren das Element<br />
direlement=dirs.next();<br />
// Wir Prüfen ob das Element ein Verzeichniss ist<br />
if(direlement.getType()==FtpDirEntry.Type.DIR){<br />
// wir fügen den Verzeichniss namen in die Liste ein<br />
mod.addElement(direlement.getName());<br />
}<br />
else if(direlement.getType()==FtpDirEntry.Type.FILE){<br />
Fmod.addElement(direlement.getName());<br />
}<br />
}<br />
<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
}<br />
}<br />
</code=java><br />
<br />
<br />
=== das Multi Download ActionEvent ===<br />
<br />
<code=java><br />
// Wir Deklarieren den FileChooser<br />
JFileChooser sfd = new JFileChooser();<br />
// Wir schreiben in das Datenfeld Bitte Wählen, da wir nur das Verzeichniss Benötigen<br />
sfd.setSelectedFile(new File("Bitte Wählen"));<br />
//Wenn Ok Gedrückt Wurde<br />
if(sfd.showSaveDialog(sfd) == JFileChooser.APPROVE_OPTION){<br />
// list erstellen mit Unseren Ausgewählten Daten<br />
Object[] flist = jList2.getSelectedValues();<br />
for(int i = 0; i < flist.length; i++){<br />
<br />
try {<br />
// wir geben Aus welche File wir Downloaden möchten<br />
Cmod.addElement("Get file " + flist[i] + " from Curent Directory " + ftp.getWorkingDirectory());<br />
System.out.println("Get file " + flist[i] + " from Curent Directory " + ftp.getWorkingDirectory());<br />
// neue File Erstellen<br />
File f = new File(sfd.getSelectedFile().getParent() + "/" + flist[i]);<br />
// Output Stream Erstellen<br />
FileOutputStream os = new FileOutputStream(f);<br />
// Datei Herunterladen<br />
ftp.getFile(ftp.getWorkingDirectory() + "/" +flist[i], os);<br />
// Server Antwortet auf unsere Anfrage<br />
Cmod.addElement("Server: " + ftp.getLastResponseString());<br />
System.out.println("Server: " + ftp.getLastResponseString());<br />
} catch (FileNotFoundException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
<br />
}<br />
// Ausgeben Das der Download Beendet wurde<br />
Cmod.addElement("Download Vorgang Beendet");<br />
System.out.println("Download Vorgang Beendet");<br />
}<br />
</code=java><br />
<br />
<br />
=== Das Multi Upload Action Event ===<br />
<br />
<code=java><br />
//Wir erstellen einen Filechooser zum Wählen der Daten<br />
JFileChooser ofd = new JFileChooser();<br />
//mehrfach auswahl Aktivieren<br />
ofd.setMultiSelectionEnabled(true);<br />
// Wenn im Filechooser auf Ok geklickt wird<br />
if(ofd.showOpenDialog(ofd)==JFileChooser.APPROVE_OPTION){<br />
// Wir Erstellen eine Filelist die unsere Gewählten files Beinhaltet<br />
File[] flist = ofd.getSelectedFiles();<br />
// Wir laden jede Einzelne File hoch<br />
for(int i = 0 ; i<flist.length;i++){<br />
try {<br />
// hiier Deklarieren wir die File<br />
File f = flist[i];<br />
// Info für Console<br />
Cmod.addElement("Put File " + f.getName() + " in to " + ftp.getWorkingDirectory() + " directory");<br />
System.out.println("Put File " + f.getName() + " in to " + ftp.getWorkingDirectory() + " directory");<br />
// Wir erstellen einen Fileinputstream zum Auslesen der Datei<br />
FileInputStream is = new FileInputStream(f);<br />
// Nun wird die Datei ochgeladen<br />
ftp.putFile(ftp.getWorkingDirectory() + "/" + f.getName(), is);<br />
// Console giebt server Nachricht aus<br />
Cmod.addElement("Server: " +ftp.getLastResponseString());<br />
System.out.println("Server: " +ftp.getLastResponseString());<br />
} catch (FileNotFoundException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
// Console giebt aus das Übertragung beendet Wurde<br />
Cmod.addElement("Übertragung der Files " + flist.toString() + " Beendet");<br />
System.out.println("Übertragung der Files " + flist.toString() + " Beendet");<br />
}<br />
</code=java><br />
<br />
<br />
=== Das Übergerordneter Ordner Event ===<br />
<code=java><br />
// Elemente Entfernen<br />
mod.removeAllElements();<br />
Fmod.removeAllElements();<br />
<br />
// FtpDirEntry Deklarieren<br />
FtpDirEntry dir; <br />
// Verzeichniss Wechseln<br />
ftp.changeToParentDirectory(); <br />
// Neues Verzeichniss in Console Ausgeben<br />
Cmod.addElement("Aktuelles Verzeichniss " + ftp.getWorkingDirectory());<br />
<br />
// Verzeichnisse in eine FtpDirEntry List hinzufügen<br />
Iterator<FtpDirEntry> dirlist = ftp.listFiles(ftp.getWorkingDirectory());<br />
<br />
// Jedes Verzeichniss Ausgeben<br />
while(dirlist.hasNext()){<br />
// dir elemnt Deklarieren<br />
dir=dirlist.next();<br />
<br />
// ist dir ein Ordner ?<br />
if(dir.getType()==FtpDirEntry.Type.DIR){<br />
// wenn ja dan in List 1<br />
mod.addElement(dir.getName());<br />
}<br />
// Ist dir eine Datei ?<br />
if(dir.getType()==FtpDirEntry.Type.FILE){<br />
// wenn ja dan in List 2<br />
Fmod.addElement(dir.getName());<br />
}<br />
}<br />
<br />
<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
</code=java><br />
<br />
<br />
=== Das Datei Löschen Event ===<br />
<br />
<code=java><br />
try {<br />
// TODO add your handling code here:<br />
<br />
// Wir Schreiben in die Console das Wir die Datei Löschen<br />
Cmod.addElement("Delete File " + ftp.getWorkingDirectory() + "/" + jList2.getSelectedValue().toString());<br />
System.out.println("Delete File " + ftp.getWorkingDirectory() + "/" + jList2.getSelectedValue().toString());<br />
<br />
// Wir Löschen die Datei<br />
ftp.deleteFile(ftp.getWorkingDirectory() + "/" + jList2.getSelectedValue().toString());<br />
<br />
// Wir Geben die Server Antwort aus<br />
Cmod.addElement("Server: "+ ftp.getLastResponseString());<br />
System.out.println("Server: "+ ftp.getLastResponseString());<br />
<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
</code=java><br />
<br />
=== Das Verzeichniss Löschen Event ===<br />
<br />
<code=java><br />
try {<br />
// TODO add your handling code here:<br />
// Wir Schreiben in die Console das Wir das Verzeichniss Löschen<br />
Cmod.addElement("Delete Directory " + ftp.getWorkingDirectory());<br />
System.out.println("Delete Directory " + ftp.getWorkingDirectory());<br />
<br />
// Wir Löschen Das Verzeichniss<br />
ftp.removeDirectory(ftp.getWorkingDirectory());<br />
<br />
// Wir Geben die Server Antwort aus<br />
Cmod.addElement("Server: "+ ftp.getLastResponseString());<br />
System.out.println("Server: "+ ftp.getLastResponseString());<br />
<br />
<br />
<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
</code=java><br />
<br />
<br />
=== Das Verzeichniss Erstellen Event ===<br />
<code=java><br />
// Deklarieren der Elemente<br />
JDialog dia = new JDialog();<br />
dia.setSize(375, 110);<br />
dia.setLayout(null);<br />
dia.setTitle("Neues Verzeichniss anlegen");<br />
JButton b = new JButton("Erstellen");<br />
final JTextField textfield = new JTextField();<br />
<br />
// Platzieren der Elemente<br />
textfield.setLocation(25, 25);<br />
textfield.setSize(200, 20);<br />
b.setLocation(235, 25);<br />
b.setSize(100,20);<br />
<br />
<br />
// Füge Controls Hinzu<br />
dia.add(textfield);<br />
dia.add(b);<br />
dia.setVisible(true);<br />
<br />
// Action Listner auf Button Legen<br />
b.addActionListener(new ActionListener(){<br />
public void actionPerformed(ActionEvent e){<br />
try {<br />
<br />
// Console Giebt aus das wir ein Verzeichniss Erstellen<br />
Cmod.addElement("Create Dir " + ftp.getWorkingDirectory() + "/" + textfield.getText());<br />
System.out.println("Create Dir " + ftp.getWorkingDirectory() + "/" + textfield.getText());<br />
<br />
// Wir Erstellen das Verzeichniss<br />
ftp.makeDirectory(ftp.getWorkingDirectory() + "/" + textfield.getText());<br />
<br />
// Wir Geben die System Nachricht aus <br />
Cmod.addElement("Server: "+ ftp.getLastResponseString());<br />
System.out.println("Server: "+ ftp.getLastResponseString());<br />
<br />
<br />
} catch (FtpProtocolException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
} catch (IOException ex) {<br />
Logger.getLogger(main.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
<br />
}<br />
});<br />
</code=java><br />
<br />
<br />
Das war der Letzte Teil des Toturials. Natürlich Könnte man noch X-Funktionen einfügen aber den Spaß überlasse ich euch. Auf Anfrage sende ich auch gerne Die Sourcecodes Zu, einfach im Forum eine PN an Andy16823.<br />
<br />
<br />
== Quellen - Mitwirkende ==<br />
<br />
* [http://www.das-java-forum.com/index.php?page=Thread&threadID=14 | Martin] - aus Anderem Forum - hat geholfen<br />
<br />
== Änderungen & Hystorie ==<br />
Ich würde mich freuen wenn man die Bearbeitung kennzeichnet also wie ich <br />
<br />
* 17.08.2013 - Bild hinzugefügt - Andy16823</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Styles_und_Themes&diff=5418Styles und Themes2013-08-14T19:36:46Z<p>Tomate Salat: Die Seite wurde neu angelegt: „=Styles= Diese ermöglichen es uns beliebig viele Attribute zusammenzufasse. Wird ein solcher Style einem View zugewiesen, so übernimmt dieser die angegebenen We…“</p>
<hr />
<div>=Styles=<br />
Diese ermöglichen es uns beliebig viele Attribute zusammenzufasse. Wird ein solcher Style einem View zugewiesen, so übernimmt dieser die angegebenen Werte. Um Redundanzen zu vermeiden, können Styles aufeinander aufbauen und somit Werte hinzufügen oder überschreiben.<br />
<br />
Somit helfen uns Styles den Code übersichtlich zu halten und nehmen uns Wartungsaufwand ab. Da ein Style mehreren Elementen zugewiesen werden kann, können wir somit an einer zentralen Stelle direkten Einfluss auf betroffene Elemente ausüben.<br />
<br />
==Das Grundgerüst==<br />
Styles werden in einer XML-Datei angelegt. Der Name der Datei kann dabei beliebig gewählt werden, oft wird diese aber einfach styles.xml genannt. Diese XML-Datei muss sich im Resourcen-Ordner values befinden. <br />
<br />
Eine einfache xml könnte z.B. so aussehen:<br />
<code=xml><br />
<resources><br />
<style name="NameDesStyles"><br />
<!-- Hier werden die Attribute angelegt --><br />
</style><br />
</resources><br />
</code=xml><br />
<br />
In diesem style-Tag können jetzt beliebig viele item-Tags verwendet werden. Diese besitzen ein Attribut '''name''', dort wird das Zielattribut angegeben. Den zugehörigen Wert schreibt man dann als Inhalt in den Tag. Hier ein Beispiel wie man einen roten Hintergrund definieren kann:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">#FF0000</item><br />
</style><br />
</code=xml><br />
<br />
==Zuweisung==<br />
Ausgehend von dem obigen Beispiel wollen wir diesen Style nun einem TextView zuweisen. Dazu nutzen wir das Attribut '''style''' und geben dort folgendes an '''@style/NameDesStyles'''. Nachfolgend ist ein Auszug einer möglichen Layout-Datei zu sehen, die diesen Style anwendet:<br />
<code=xml><br />
<TextView <br />
style="@style/NameDesStyles"<br />
android:layout_width="match_parent"<br />
android:layout_height="wrap_content"<br />
android:text="Foo Bar" /><br />
</code=xml><br />
Im Layout selber haben wir dann nochmals die Möglichkeit die Werte des Styles zu überschreiben. Wenn wir also folgendes Attribut setzen würden: '''android:background='#0000FF'''', so wäre der Hintergrund blau und nicht rot.<br />
<br />
==Vererbung==<br />
Dies wollen wir an einem Beispiel verdeutlichen. Angenommen wir haben einen Style der das Aussehen eines Eingabefeldes definiert. Zusätzlich brauchen wir ein definiertes Aussehen für das selbe Eingabefeld wenn es gesperrt ist - in diesem Fall soll einfach der Hintergrund Grau sein aber alles andere bleibt gleich. Angenommen wir lösen dies mit zwei Styles:<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
Schon in diesem kurzen Beispiel haben wir einiges an Redundanzen. Zusätzlich haben wir hier erhöhten Pflegeaufwand und eine potentielle Fehlerquelle - denn Änderungen die den Style ''Eingabe'' betreffen, müssen auch im Style ''EingabeGesperrt'' nachgezogen werden. <br />
<br />
Deswegen gibt es eine elegantere Methode wie wir dieses Problem lösen können. Nämlich mit der Vererbung. Dazu gibt es zwei Techniken, wie man die Vererbung bewerkstelligen kann. <br />
<br />
===Vererbung: Parent===<br />
Die erste Möglichkeit, wie man Vererbung angehen kann ist über das Attribut '''parent'''. Dazu gibt man dort einfach den zu erbenden Style an. Als Angabe ist sowohl nur der Name des Stils (Eingabe) als auch die "Resourcenschreibweise" (@style/Eingabe) gültig.<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="EingabeGesperrt" parent="Eingabe"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
===Vererbung: Punktnotation===<br />
Die zweite Möglichkeit wäre dann die Punktnotation. Dabei wird nicht das parent-Attribut genutzt, sondern eine spezielle Form der Namensgebung. Zuerst wird der Name des zu erbenden Stils angegeben, danach folgt ein Punkt. Als nächstes schreibt man den eigentlichen Namen des Stils direkt dahinter. In unserem Fall also ''Eingabe.Gesperrt'':<br />
<br />
<code=xml><br />
<style name="Eingabe"><br />
<item name="android:layout_width">match_parent</item><br />
<item name="android:layout_height">wrap_content</item><br />
<item name="android:background">#00FF00</item><br />
</style><br />
<br />
<style name="Eingabe.Gesperrt"><br />
<item name="android:background">#CCCCCC</item><br />
</style><br />
</code=xml><br />
<br />
Auch von diesem Stil (Eingabe.Gesperrt) kann dann wieder geerbt werden. Eine weitere Vererbung könnte dann z.B. so aussehen: ''Eingabe.Gesperrt.FooBar''<br />
<br />
=Themes=<br />
Über das Theme kann die eigene App den eigenen Bedürfnissen angepasst werden. Ein Theme ist letztendlich nichts anderes wie ein Styles mit ganz vielen Eigenschaften. Um ein eigenes Theme zu entwickeln bietet es sich demnach an von einem bestehenden zu erben und anzupassen. Dabei sollte aber beachtet werden, dass der Style auch auf jeder Zielplattform verfügbar ist. Um verschiedene Android-Versionen zu unterstützen bietet sich folgende Struktur an:<br />
<br />
<br />
'''values/styles.xml'''<br />
<code=xml><br />
<resources><br />
<style name="AppBaseTheme" parent="android:Theme.Light"><br />
<!-- Für alle Geräte unter Api-11 --><br />
</style><br />
<br />
<!-- Application theme. --><br />
<style name="AppTheme" parent="AppBaseTheme"><br />
<!-- Alle API-Unabhängigen Eigenschaften --><br />
</style><br />
<br />
</resources><br />
</code=xml><br />
<br />
<br />
'''values-v11/styles.xml'''<br />
<code=xml><br />
<resources><br />
<br />
<style name="AppBaseTheme" parent="android:Theme.Holo.Light"><br />
<!-- API 11 theme anpassungen --><br />
</style><br />
<br />
</resources><br />
<br />
</code=xml><br />
<br />
Die App selber nutzt dann den Style '''AppTheme''' als eigentliches Theme und die Plattform entscheidet dann, welche Definition des Styles '''AppBaseTheme''' greift.<br />
<br />
Alternativ bieten Bibliotheken wie [http://actionbarsherlock.com/ ActionbarSherlock] oder das support-package-v7 Themes an, die Rückwärtskompatibel sind. Dann benötigt man keine Unterscheidung der Versionen.<br />
<br />
=Eigenschaft von Theme übernehmen=<br />
Auch hier zunächst ein Beispiel: wir haben einen View mit transparentem Hintergrund und schwarzer Schrift. Würden wir nun ein Theme einstellen mit schwarzem Hintergrund, dann könnte man den Text nicht mehr lesen. Aus diesem Grund ist es möglich Werte des Styles an Werte des Themes zu binden. Da ein Theme mit schwarzem Hintergrund keine schwarze Schriftfarbe verwenden würde, sollten wir die Textfarbe des Themes für unseren Style übernehmen. Dazu müssen wir einfach nur das gewünschte Attribut angeben und nutzen dazu folgendes Schema: '''?android:attr/[Name]'''. <br />
<br />
Nun wollen wir das mal auf unseren obigen Style anwenden und dieser schaut dann wie folgt aus:<br />
<br />
<code=xml><br />
<style name="NameDesStyles"><br />
<item name="android:background">?android:background</item><br />
</style><br />
</code=xml><br />
<br />
=Video-Tutorial=<br />
Zu diesem Thema habe ich auch ein Videotutorial gemacht. Dieses findet Ihr hier:[http://www.youtube.com/watch?v=yp1vb_w6LTs Android - Android XML Style + Theme]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Eigene_View_mit_XML-Attributen&diff=5320Eigene View mit XML-Attributen2013-08-09T16:23:48Z<p>Tomate Salat: Die Seite wurde neu angelegt: „In diesem Artikel wird erklärt, wie ihr eine eigene View erstellen könnt, die durch XML-Attribute beeinflussbar ist. Mit dieser Technik können ähnliche Kompon…“</p>
<hr />
<div>In diesem Artikel wird erklärt, wie ihr eine eigene View erstellen könnt, die durch XML-Attribute beeinflussbar ist. Mit dieser Technik können ähnliche Komponenten zusammengefasst und als eine einzige gut wiederverwendet werden. <br />
<br />
=Eigenes XML-Attribut=<br />
Damit wir mit einem eigenen Attribut arbeiten können muss es zuerst angelegt werden. Das geschieht in einer Resourcen-xml-Datei die sich im Ordner values befindet. In selbigem Ordner findet man oft z.B. auch folgende Dateien: strings.xml, styles.xml. Um Ordnung im Projekt zu halten empfielt es sich hier eine neue XML anzulegen mit dem Namen: attrs.xml (dort kann man dann alle Attribute sammeln).<br />
<br />
<code=xml><br />
<!-- attrs.xml --><br />
<?xml version="1.0" encoding="utf-8"?><br />
<resources><br />
<declare-styleable name="TutorialView"><br />
<attr name="info" format="string" /><br />
</declare-styleable><br />
</resources><br />
</code=xml><br />
<br />
; declare-styleable <br />
: Mit diesem Tag können wir mehrer Attribute kapseln. Declare-styleable benötigt einen Namen und am besten nehmen wir hierzu den Namen der View (in unserem Fall: TutorialView)<br />
<br />
; attr<br />
: Mit diesem Tag definieren wir unser Attribut unter Angabe des Namens und Format. Welche Formate zur Verfügung stehen verratet euch die IDE. Ansonsten gibt es hier noch eine ausführlichere Erklärung dazu: [http://stackoverflow.com/questions/3441396/defining-custom-attrs stackoverflow - Defining custom attrs]<br />
<br />
=Die View-Klasse=<br />
Um eine eigene View zu erstellen, brauchen wir zunächst eine Klasse. Diese sollte mindestens von [http://developer.android.com/reference/android/view/View.html View] erben. In diesem Artikel werden wir von einem [http://developer.android.com/guide/topics/ui/layout/linear.html LinearLayout] ausgehen. Unser neuer View wird sich also aus bestehenden Views zusammensetzen. <br />
<br />
==Der Konstruktor==<br />
Damit der View in einer XML verwendet werden kann, benötigt er einen entsprechenden Konstruktor. Denn Android nutzt zum erstellen des View-Objektes immer folgenden Konstruktor:<br />
<br />
<code=java><br />
public <constructor>(Context context, AttributeSet attrs) {<br />
<br />
}<br />
</code=java><br />
<br />
Dabei stehen unsere XML-Daten in dem AttributeSet-Objekt. Da es sein kann, dass man direkt in Java mal ein Objekt von der View-Klasse erstellen möchten, sollten wir noch einen Konstruktor bereitstellen mit nur einem Parameter (Context).<br />
<br />
==XML-Attribut in View auswerten==<br />
Die Auswertung unseres XML-Attributes wird an folgendem Beispiel erklärt:<br />
<code=java><br />
public class TutorialView extends LinearLayout {<br />
<br />
public TutorialView(Context context) {<br />
this(context, null);<br />
}<br />
<br />
public TutorialView(Context context, AttributeSet attrs) {<br />
super(context, attrs);<br />
init(context, attrs);<br />
}<br />
<br />
private void init(Context context, AttributeSet attrs) { <br />
TextView textView = new TextView(context);<br />
textView.setText("Foo bar");<br />
addView(textView);<br />
}<br />
}<br />
</code=java><br />
<br />
Hier möchten wir das der TextView den Wert des Attributes übernimmt, welches wir zuvor im Abschnitt ''Eigenes XML-Attribut'' bereits angelegt haben. Um an eben diesen Wert zu kommen, müssen wir mit dem AttributeSet arbeiten. Mit einem [http://developer.android.com/reference/android/content/res/TypedArray.html TypedArray] können wir sehr elegant und einfach arbeiten. Deswegen erstellen wir uns eines mit folgendem Aufruf:<br />
<code=java><br />
TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.TutorialView);<br />
</code=java><br />
<br />
Der Methode obtainStyledAttributes übergeben wir zwei Werte. Zuerst die Informationen aus dem XML und danach was wir aus dem XML haben möchten (das R.styleable.TutorialView repräsentiert hier den XML-Tag "declared-styleable" und dessen Inhalt). <br />
<br />
Jetzt wo wir unser TypedArray haben sollten wir immer daran denken, dieses wieder frei zu geben. Dazu solltet Ihr die Methode recycle() aufrufen - sobald ihr das Objekt nicht mehr benötigt:<br />
<br />
<code=java><br />
typedArray.recycle();<br />
</code=java><br />
<br />
Der letzte Schritt ist dann, den Wert auslesen. Dies geht einfach mit folgender Codezeile:<br />
<code=java><br />
String infoText = typedArray.getString(R.styleable.TutorialView_info);<br />
</code=java><br />
<br />
getString sollte selbsterklärend sein, dennoch der Hinweis: wird im XML anstelle eines String eine Ressource (z.B.: @string/app_name) angegeben, so liefert getString den Inhalt der Ressource zurück.<br />
<br />
==Vollständige Klasse (Beispiel)==<br />
Zur Vollständigkeit ist hier nochmal die komplette Klasse:<br />
<code=java><br />
public class TutorialView extends LinearLayout {<br />
<br />
public TutorialView(Context context) {<br />
this(context, null);<br />
}<br />
<br />
public TutorialView(Context context, AttributeSet attrs) {<br />
super(context, attrs);<br />
init(context, attrs);<br />
}<br />
<br />
private void init(Context context, AttributeSet attrs) {<br />
TextView textView = new TextView(context);<br />
<br />
if(attrs != null) {<br />
TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.TutorialView);<br />
textView.setText(typedArray.getString(R.styleable.TutorialView_info));<br />
typedArray.recycle();<br />
}<br />
<br />
addView(textView);<br />
}<br />
}<br />
</code=java><br />
<br />
=Verwendung im Layout=<br />
Um den View im Layout nutzen zu können, reicht es bereits Ihn über seinen vollqualifizierten Namen anzusprechen:<br />
<code=xml><br />
<de.jfruit.tutorial.TutorialView<br />
android:layout_width="match_parent"<br />
android:layout_height="wrap_content"<br />
/><br />
</code=xml><br />
damit wir hier unser Attribut nutzen können, müssen wir zuerst noch einen weiteren XML-Namespace angeben. Dazu passen wir einfach das Root-Element an indem wir folgendes Attribut hinzufügen:<br />
<code=xml>xmlns:app="http://schemas.android.com/apk/res-auto"</code=xml><br />
Dabei kann der Name des Namespaces (hier: app) frei gewählt werden. Wichtig ist nur, dass wir diesen Namespacenamen immer vor unser eigenes Attribut (durch Doppelpunkt getrennt) schreiben. In unserem Falle sähe das dann wie folgt aus:<br />
<code=xml>app:info="@string/app_name"</code=xml><br />
<br />
==Vollständige Layout-XML (Beispiel)==<br />
Und hier seht Ihr das komplette Layout:<br />
<code=xml><br />
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"<br />
xmlns:app="http://schemas.android.com/apk/res-auto"<br />
android:layout_width="match_parent"<br />
android:layout_height="match_parent"><br />
<br />
<br />
<de.jfruit.tutorial.TutorialView<br />
app:info="@string/app_name"<br />
android:layout_width="match_parent"<br />
android:layout_height="wrap_content"<br />
/><br />
</LinearLayout><br />
</code=xml><br />
<br />
Damit sind wir fertig. Unser View kann in einer XML verwendet und angepasst werden. <br />
<br />
=Video-Tutorial=<br />
Zu diesem Thema habe ich auch ein Videotutorial gemacht. Dieses findet Ihr hier:[http://www.youtube.com/watch?v=9LnNKuBMrPc Android - Eigene View + XML]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Kategorie:Mobile_Development&diff=5291Kategorie:Mobile Development2013-08-07T08:47:02Z<p>Tomate Salat: </p>
<hr />
<div>Unter Mobile Development versteht man das Entwickeln für mobile Endgeräte (z.B. Tablets, Smartphones). Für eben diese Geräte gibt es eine breite Vielfalt an existierenden Betriebssystemen die alle Ihre eigenen Besonderheiten haben. Nachfolgend werden alle Plattformen gelistet, für die Artikel existieren.<br />
<br />
[[Kategorie:Byte-Welt]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Kategorie:Android&diff=5284Kategorie:Android2013-08-07T08:07:43Z<p>Tomate Salat: </p>
<hr />
<div>[[Kategorie:Mobile Development]] [[Kategorie:Java]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Benutzer:Tomate_Salat&diff=5283Benutzer:Tomate Salat2013-08-06T20:52:26Z<p>Tomate Salat: Die Seite wurde neu angelegt: „404 - Not Found“</p>
<hr />
<div>404 - Not Found</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=Emulatoren&diff=5282Emulatoren2013-08-06T19:48:14Z<p>Tomate Salat: Die Seite wurde neu angelegt: „Eine Liste von verfügbaren Emulatoren für das Android-OS. =Standard Emulator= Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfän…“</p>
<hr />
<div>Eine Liste von verfügbaren Emulatoren für das Android-OS.<br />
<br />
=Standard Emulator=<br />
Der Standard Emulator wird mit dem SDK ausgeliefert. Der Emulator ist für Anfänger ausreichend, kommt aber aufgrund seiner Trägheit schnell an seine Grenzen. <br />
<br />
=YouWave= <br />
[http://youwave.com/ YouWave] ist eher für Endanwender gedacht und unterstützt keine Tabletansicht. Zudem ist es nicht Möglich seine Apps zu deubggen (dies könnte sich in neueren/aktuellen Version geändert haben). Wer kein Android-Gerät besitzt kann diesen Emulator gut dazu verwenden um seine App in einer Umgebung zu testen, die Leistungstechnisch vergleichsweise besser an gängige Smartphones ran kommt als der Standardemulator.<br />
<br />
=Manymo=<br />
[https://www.manymo.com/ Manymo] ist ein kostenpflichtiger Cloudbasierter Service - die App muss also auf den Server des Dienstleisters hochgeladen werden. Einmal hochgeladen kann man seine App gegen verschiedene Android-Versionen und Displayauflösungen testen. <br />
<br />
=BlueStacks=<br />
[http://www.bluestacks.com/ BlueStacks] ist ein performanter Emulator für Tablets der auch bei der Entwicklung überzeugen kann. BlueStacks kann auch eine SD-Karte simulieren, das hochladen von eigenen Dateien darauf ist nur etwas versteckt. Einziges aufgefallenes Manko: es ist anscheinend nicht möglich die Google Play Services darauf zu installieren (dies könnte sich in neueren/aktuellen Version geändert haben).<br />
<br />
==Anleitung für die SD-Karte==<br />
Um Dateien auf der SD-Karte von BlueStacks ablegen zu können, müsst ihr die Daten unter folgendem Pfad ablegen:<br />
<br />
C:\ProgramData\BlueStacks\UserData\SharedFolder<br />
<br />
=Virtual Box=<br />
Eine sehr perfomante Möglichkeit Android zu emulieren ist das nutzen von Virtual Box. Eine ausführliche Beschreibung dazu finden Ihr hier: [http://blog.geniali.ch/post/2012/12/15/Android-Dev-%E2%80%93-Schneller-Android-Emulator.aspx http://blog.geniali.ch/post/2012/12/15/Android-Dev-%E2%80%93-Schneller-Android-Emulator.aspx]<br />
<br />
[[Kategorie:Android]]</div>Tomate Salathttps://wiki.byte-welt.net/index.php?title=IDE_Liste&diff=5281IDE Liste2013-08-06T17:55:32Z<p>Tomate Salat: /* Java */</p>
<hr />
<div>Eine Liste von verfügbaren IDEs, für die Entwicklung in verschiedenen Sprachen.<br />
=Gratis [[Integrierte_Entwicklungsumgebung|IDE]]=<br />
<br />
<br />
==C/C++==<br />
*Code::Blocks - [http://www.codeblocks.org/ codeblocks.org] (am besten die nightly builds nehmen)<br />
*NetBeans - [http://www.netbeans.org netbeans.org]<br />
*wxDev-C++ 6.10-1 - [http://wxdsgn.sourceforge.net sourceforge.net]<br />
*Dev C++ 5 - [http://www.bloodshed.net/devcpp.html bloodshed.net]<br />
*KDevelop (Linux) - [http://www.kdevelop.org kdevelop.org]<br />
*QtCreator (speziell für die Entwicklung mit Qt) - [http://www.qtsoftware.com/developer/qt-creator qtsoftware.com]<br />
*Eclipse CDT (Plugin für Eclipse) - [http://www.eclipse.org/cdt/ eclipse.org]<br />
<br />
==C#(Sharp)==<br />
*Visual Studio 2005 Express Editions - [http://www.microsoft.com/germany/msdn/vstudio/products/express/default.mspx microsoft.com]<br />
*Visual C# Express [http://www.microsoft.com/germany/msdn/vstudio/products/express/visualcsharp microsoft.com]<br />
*SharpDevelop - [http://www.icsharpcode.net/OpenSource/SD/ icsharpcode.net]<br />
*monodevelop (für Linux) - [http://www.monodevelop.com/Main_Page monodevelop.com]<br />
<br />
==Java==<br />
*NetBeans - [http://www.netbeans.org netbeans.org]<br />
*Eclipse - [http://www.eclipse.org eclipse.org]<br />
*IntelliJ IDEA (Community Edition) - [http://www.jetbrains.com/idea/ jetbrains.com]<br />
*JBuilder Foundation (Borland) - [http://jbuilder.softonic.de/ie/10351 softonic.de]<br />
<br />
== Android ==<br />
*Android Studio - [http://developer.android.com/sdk/installing/studio.html developer.android.com/sdk/installing/studio.html]<br />
*Eclipse ADT-Bundle - [http://developer.android.com/sdk/index.html developer.android.com/sdk/index.html]<br />
*IntelliJ IDEA (Community Edition) - [http://www.jetbrains.com/idea/ jetbrains.com]<br />
<br />
==LaTeX==<br />
*TexnicCenter - [http://www.texniccenter.org texniccenter.org]<br />
*WinTex - [http://www.tex-tools.de tex-tools.de]<br />
<br />
==Ruby==<br />
*Arachno Ruby IDE (30-Tage-Testversion) - [http://www.ruby-ide.com/ruby/ruby_ide_and_ruby_editor.php ruby-ide.com]<br />
<br />
==PHP==<br />
*NetBeans - [http://www.netbeans.org netbeans.org]<br />
*Eclipse mit [http://www.eclipse.org/pdt/ PDT PlugIn]<br />
*Aptana Studio [http://www.aptana.com/studio aptana.com]<br />
<br />
=Kostenpflichtige [[Integrierte_Entwicklungsumgebung|IDE]]=<br />
<br />
==Java==<br />
*IntelliJ IDEA - [http://www.jetbrains.com/idea/index.html jetbrains]<br />
<br />
<br />
==LaTeX==<br />
*WinEdt - [http://www.winedt.com winedt.com]<br />
[[Kategorie:IDE]]</div>Tomate Salat