Advertisement
  1. Code
  2. Xamarin

Erste Schritte mit Xamarin.Forms: Anpassen der Benutzeroberfläche

German (Deutsch) translation by Valentina (you can also view the original English article)

1. Bühne einstellen

Beim Erstellen von Anwendungen mit Xamarin.Forms werden Sie zweifellos die Einfachheit der Erstellung von Benutzeroberflächen mögen. Mit Xamarin.Forms können Sie dieselbe Terminologie für Steuerelemente auf mehreren Plattformen verwenden.

Obwohl dieses Konzept sehr mächtig sein kann, kann es als Designer oder Entwickler etwas einschränkend sein. Es mag den Anschein haben, als wären wir gezwungen, die nativen Bedienelemente der Benutzeroberfläche zu verwenden, die mit jeder der Plattformen geliefert werden, ohne die Möglichkeit, Anpassungen hinzuzufügen. Das ist nicht der Fall.

Um mit dem Anpassen der Benutzeroberfläche für bestimmte Plattformen zu beginnen, müssen Sie zunächst den Renderingprozess von Xamarin.Forms verstehen.

2. Rendering steuern

Bei der Verwendung von Xamarin.Forms zum Erstellen einer Benutzeroberfläche für Ihre plattformübergreifende mobile Anwendung gibt es zwei wichtige Puzzleteile, die Sie verstehen müssen.

Element

Das erste Puzzleteil ist das Element. Sie können sich ein Element als plattformunabhängige Definition eines Steuerelements in Xamarin.Forms vorstellen. Wenn Sie die Dokumentation überhaupt durchgelesen haben, wissen Sie, dass diese Controls auch als View-Objekte bezeichnet werden. Um noch genauer zu sein, wird jedes Element in Xamarin.Forms von der View-Klasse abgeleitet.

Diese Elemente werden verwendet, um ein visuelles Element zu beschreiben. Die Elemente bieten eine plattformunabhängige Definition von Merkmalen, wie das Steuerelement aussehen und sich verhalten soll. Ein Element allein kann kein Steuerelement erstellen, das dem Benutzer angezeigt wird. Es braucht etwas Hilfe. Hier kommt der zweite Teil des Rendering-Prozesses ins Spiel, ein Renderer.

Renderer

Ein Renderer kommt ins Spiel, wenn Sie Ihre Anwendung ausführen. Die Aufgabe des Renderers besteht darin, das plattformunabhängige Element in etwas Visuelles umzuwandeln, das dem Benutzer präsentiert wird.

Wenn Sie beispielsweise ein Label-Steuerelement in Ihrem freigegebenen Projekt verwenden, verwendet das Xamarin.Forms-Framework während der Ausführung Ihrer Anwendung eine Instanz der LabelRenderer-Klasse, um das systemeigene Steuerelement zu zeichnen. Wenn Sie sich fragen, wie dies bei einem Projekt mit gemeinsam genutztem Code geschieht, ist das eine sehr gute Frage. Die Antwort ist, das tut es nicht.

Lassen Sie uns dies an einem Beispiel veranschaulichen. Öffnen Sie zunächst entweder Xamarin Studio oder Visual Studio. Der Prozess und die Konzepte sind für beide gleich. Wenn Sie Xamarin Studio verwenden, gibt es keine Unterstützung für Windows Phone-Projekte, sodass Sie in Ihrer Projektmappe nur drei Projekte erstellen. Wenn Sie Visual Studio verwenden, erstellen Sie vier Projekte.

Erstellen Sie in Visual Studio ein neues Projekt, wählen Sie links die Projektfamilie Mobile Apps und rechts die Projektvorlage Leere App (Xamarin.Forms Portable) aus. Sie können Ihrem Projekt einen beliebigen Namen geben, aber wenn Sie mir folgen möchten, verwenden Sie den Namen Anpassung und klicken Sie auf OK.

Nun sollten Sie je nach IDE entweder drei oder vier Projekte in Ihrer Projektmappe sehen. Wenn Sie den Ordner References in Ihrem Customization (Portable)-Projekt erweitern, wird ein Assemblyverweis auf Xamarin.Forms.Core angezeigt. Hier werden all die verschiedenen Elemente definiert, die Sie in Ihrem Projekt mit gemeinsamer Benutzeroberfläche verwenden können. Da ist nichts Ungewöhnliches.

Wenn Sie jedes der plattformspezifischen Projekte öffnen und deren References-Ordner erweitern, sehen Sie, dass jedes eine plattformspezifische Implementierung dieser Xamarin.Forms-Bibliothek mit dem Namen Xamarin.Forms.Platform.Android, Xamarin.Forms.Platform.iOS enthält und   Xamarin.Forms.Platform.WP8.

In diesen Assemblys finden Sie die Renderer für jedes der Xamarin.Forms-Elemente. Jetzt beginnen Sie, das Layout des Prozesses zu sehen. Die plattformunabhängigen Elemente oder View-Objekte befinden sich im freigegebenen Codeprojekt, aber alle spezifischen Renderer für die Elemente befinden sich in den plattformspezifischen Projekten.

Dies bedeutet, dass für jedes der von Ihnen verwendeten Elemente zwei Renderer in Xamarin Studio und drei in Visual Studio erstellt werden. Nachdem Sie nun sehen, wie dies in Xamarin.Forms strukturiert ist, lautet die nächste logische Frage normalerweise: "Wann sollte ich Anpassungen verwenden?".

3. Wann anpassen

Es gibt definitiv eine gute Anzahl von Eigenschaften und Merkmalen, die in Xamarin.Forms-Elementen definiert sind, mit denen das endgültige Steuerelement auf jeder der Plattformen angepasst werden kann. Allerdings ist nicht jede Anpassung, die auf jeder der Plattformen verfügbar ist, in Xamarin.Forms vorhanden. In diesem Fall gibt es zwei Hauptszenarien, in denen Sie Anpassungen erstellen möchten.

Das erste Szenario, in dem Anpassungen erforderlich sind, ist das Erstellen eines vollständig benutzerdefinierten Steuerelements. Angenommen, Sie möchten ein Kalendersteuerelement oder vielleicht eine Art Grafiksteuerelement erstellen. Leider existiert heute in Xamarin.Forms nichts dergleichen, was nicht heißen soll, dass dies nie der Fall sein wird.

Dies ist definitiv eine Situation, in der Sie von Anfang an beginnen und alles von Grund auf neu erstellen müssen. Sie müssen das Element definieren, das Sie verwenden werden, um die Eigenschaften des Steuerelements plattformunabhängig zu beschreiben. Dann müssen Sie auch einen benutzerdefinierten Renderer für jede der Plattformen erstellen, die Sie unterstützen möchten.

Je nachdem, was Sie bauen, kann dies ein ziemlich umfangreiches Projekt sein. In diesem Fall werde ich das für ein weiteres Tutorial an und für sich aufheben. Stattdessen konzentrieren wir uns in diesem Tutorial auf das zweite Szenario, in dem Sie einige Anpassungen benötigen.

Die zweite Situation, in der Sie eine Anpassung benötigen, ist, wenn ein integriertes Element eine bestimmte Funktion einer Plattform, die Sie unterstützen möchten, nicht unterstützt. Ein Beispiel hierfür wäre das Label-Steuerelement. In Xamarin.Forms gibt es keinen Mechanismus oder keine Eigenschaft, mit der Sie auf jeder der Plattformen das Äquivalent erstellen können, um den Text fett oder kursiv zu machen. Dies mag wie ein sehr einfaches Szenario erscheinen, aber Sie werden feststellen, dass der grundlegende Prozess zum Bereitstellen dieser Änderung im Element und zum Verständnis des Renderers hier derselbe ist wie in einigen der komplexeren Szenarien.

Mit dem zweiten Szenario im Hinterkopf haben Sie zwei Möglichkeiten. Sie können entweder den vorhandenen Renderer für eine bestimmte Plattform (oder für alle Plattformen) ersetzen und Ihre eigene Funktionalität und Zeichenlogik für alle Funktionen des Elements erstellen. Alternativ können Sie Ihr eigenes Element erstellen, das von dem vorhandenen Element abgeleitet wird, und dieses neue Element einem benutzerdefinierten Renderer zuordnen. Auf diese Weise behalten Sie alle Standardlogik- und Rendering-Funktionen des Basiselements bei und können es nach Ihren Wünschen anpassen. Dies wird der Weg sein, den wir für dieses Beispiel nehmen. Sehen wir uns nun an, wie wir diese Funktionalität zu unserem eigenen Projekt hinzufügen.

4. Anpassung hinzufügen

Beginnen wir diesen Prozess, indem wir die Grundstruktur unserer Anwendung einrichten, damit wir unsere Baseline sehen und dann Änderungen vornehmen können. Öffnen Sie zunächst Ihre App.cs-Datei im Customization (Portable)-Projekt im Solution Explorer. Ändern Sie die GetMainPage-Methode wie folgt:

Wie Sie hier sehen können, haben wir drei einfache Label-Steuerelemente erstellt. Der eine will kursiv sein, der andere fett und der dritte ist gierig und will beides sein. Wenn Sie diese Anwendung auf iOS, Android und Windows Phone ausführen würden, würden sie in etwa so aussehen:

iOS

Android

Windows Phone

Wie Sie sehen, wollen sie nicht so langweilig sein. Nun, sitzen Sie nicht nur da, helfen Sie ihnen.

Schritt 1: Erstellen eines neuen Elements

Als erstes müssen wir ein neues Element erstellen, mit dem wir zusätzliche Anpassungen an das vorhandene Label-Steuerelement vornehmen können. Beginnen Sie damit, Ihrem Anpassungsprojekt (Portable) eine neue Klasse hinzuzufügen und sie StyledLabel zu nennen. Ersetzen Sie den Inhalt durch Folgendes:

Wir definieren eine sehr einfache Aufzählung und Klasse. Wir haben die Enumeration so definiert, dass sie kursiv, fett und fett plus kursive Werte zulässt. Anschließend erstellen wir eine Klasse StyledLabel, die von der Label-Basisklasse abgeleitet wird, und fügen eine neue Eigenschaft, Style, hinzu, um den entsprechenden Stil aufzunehmen, den wir auf das Steuerelement anwenden möchten.

Um sicherzustellen, dass alles noch funktioniert und es sollte, ändern wir die App.cs-Datei noch einmal und ersetzen die Label-Elemente in unserem ersten Beispiel durch unsere neuen StyledLabel-Elemente. Da die StyleLabel-Klasse von der Label-Klasse erbt, sollte alles weiterhin funktionieren.

Hier noch einmal die Ergebnisse dieser Änderung.

iOS

Android

Windows Phone

Wie Sie sehen, hat sich nichts geändert. Da wir nun ein neues benutzerdefiniertes Element haben, ist es an der Zeit, die benutzerdefinierten Renderer zu erstellen, die sich um die nativen Steuerelemente kümmern.

Schritt 2: Android-Renderer

Der erste Schritt zum Erstellen eines Renderers besteht darin, der Zielplattform eine neue Klasse hinzuzufügen. Wir beginnen mit dem Xamarin.Android-Projekt. Erstellen Sie in diesem Projekt eine neue Klassendatei, nennen Sie sie StyledLabelRenderer und ersetzen Sie ihren Inhalt durch Folgendes:

Schauen wir uns diesen Codeblock genauer an.

Wir beginnen mit einem speziellen assembly-Attribut, das Xamarin.Forms anweist, diese StyledLabelRenderer-Klasse jedes Mal als Renderer zu verwenden, wenn versucht wird, StyledLabel-Objekte zu rendern. Dies ist erforderlich, damit Ihre Anpassungen ordnungsgemäß funktionieren.

Genau wie beim Erstellen eines neuen StyledLabel-Elements, das wir von der Label-Klasse geerbt haben, wird unsere neue StyledLabelRenderer-Klasse von der LabelRenderer-Klasse erben. Auf diese Weise können wir die vorhandene Funktionalität beibehalten, sodass wir nur das überschreiben müssen, was wir ändern oder anpassen möchten.

Um unsere neue Formatierung anzuwenden, müssen wir in den Rendering-Prozess einsteigen und dies über die OnElementChanged-Methode tun. Bei dieser Methode können wir alle unsere Anpassungen vornehmen.

Wenn Sie Ihre Anpassungen vornehmen, werden Sie zwei sehr wichtige Eigenschaften verwenden. Zuerst benötigen Sie einen Verweis auf das ursprüngliche Element, das Sie erstellt haben und das in unserer benutzerdefinierten Renderer-Methode gerendert wird. Dazu verwenden Sie die Element-Eigenschaft. Dies ist ein generisches Objekt, daher müssen Sie es in den Typ umwandeln, den Sie rendern. In diesem Fall handelt es sich um ein StyledLabel.

Die zweite wichtige Eigenschaft, die Sie benötigen, ist die Control-Eigenschaft. Diese Eigenschaft enthält einen typisierten Verweis auf das native Steuerelement auf der Plattform. Da Sie in diesem Fall von der LabelRenderer-Klasse geerbt haben, weiß der Code bereits, dass das Control in diesem Fall eine TextView ist.

Von diesem Punkt an verwenden Sie eine einfache Logik, um zu bestimmen, welche Anpassung durchgeführt werden soll, und wenden die entsprechenden nativen Anpassungen an. In diesem Fall verwenden Sie den Android-Mechanismus zum Ändern der Schriftart einer TextView mithilfe der SetTypeface-Methode.

Wenn Sie diese Anwendung jetzt ausführen, sollten Sie im Android-Emulator Folgendes sehen, was genau das ist, was wir angestrebt haben.

Schritt 3: iOS-Renderer

Der Vorgang zum Erstellen des iOS-Renderers ist bis zum Überschreiben der OnElementChanged-Methode identisch. Beginnen Sie mit dem Erstellen einer neuen Klasse in Ihrem Customization.iOS-Projekt. Nennen Sie es StyledLabelRenderer und ersetzen Sie den Inhalt durch Folgendes:

Wie Sie sehen, ist alles genau gleich. Sie haben dasselbe assembly-Attribut, Sie überschreiben dieselbe OnElementChanged-Methode, Sie wandeln die Element-Eigenschaft in ein StyledLabel um, und Sie haben dieselbe Shell einer switch-Anweisung, um die Style-Eigenschaft zu bearbeiten.

Der einzige Unterschied besteht darin, wo Sie das Styling auf das native UILabel-Steuerelement anwenden.

Sie können die Font-Eigenschaft eines UILabels in iOS entweder fett oder kursiv formatieren, indem Sie eine statische Hilfsmethode der UIFont-Klasse namens BoldSystemFontOfSize oder ItalicSystemFontOfSize verwenden. Das funktioniert entweder bei einer fetten oder einer kursiven Schriftart, aber nicht bei beiden. Wenn Sie versuchen, beides auf ein UILabel anzuwenden, wird nur das letzte gerendert.

Um beide Stile zu erhalten, werden wir ein wenig schummeln und eine in iOS integrierte Schriftart namens Helvetica-BoldOblique verwenden. Diese Schriftart ist sowohl fett als auch kursiv integriert, sodass wir sie nicht einzeln erstellen müssen.

Wenn Sie dies im iOS-Simulator ausführen, erhalten Sie das folgende Ergebnis:

Schritt 4: Windows Phone-Renderer

Schließlich kommen wir zu Windows Phone. Wie Sie vielleicht schon erraten haben, ist der Vorgang genau der gleiche. Erstellen Sie eine neue Klasse im Customization.WinPhone-Projekt, nennen Sie sie StyledLabelRenderer und ersetzen Sie den Inhalt durch Folgendes:

Auch hier ist bis auf die Logik alles gleich. Um den Text in diesem Fall kursiv zu machen, legen Sie die FontStyle-Eigenschaft des TextBlocks auf Italic fest. Um den Text fett zu machen, legen Sie die FontWeight-Eigenschaft auf Bold fest. Wenn Sie beide anwenden möchten, stellen Sie einfach beide ein.

Wenn Sie diese Anwendung im Windows Phone-Emulator ausführen, erhalten Sie das folgende Ergebnis:

Sie haben nun erfolgreich ein voll funktionsfähiges, maßgeschneidertes, plattformübergreifendes Element erstellt, das sich auf allen drei Plattformen perfekt darstellt. Sie sollten sich jetzt bereit fühlen, die Welt zu erobern. Naja fast.

Der Prozess, den wir in diesem Tutorial befolgt haben, ist vollständig gültig und wird in den meisten Fällen perfekt funktionieren. Es gibt jedoch einen sehr speziellen Fall, in dem wir einige Funktionen verpassen, wenn wir diesen Ansatz verwenden. Dieser Fall ist Datenbindung in XAML.

5. XAML und Datenbindung

Eine der sehr coolen Funktionen von Xamarin.Forms ist die Tatsache, dass Sie XAML und die Datenbindung genauso verwenden können, als würden Sie eine Windows Phone-, WPF- oder Silverlight-Anwendung erstellen. Leider gehen Datenbindung und XAML über den Rahmen dieses Tutorials hinaus, aber ich empfehle Ihnen, mehr zu diesem Thema auf der Seite XAML für Xamarin.Forms zu lesen.

Schritt 1: Erstellen der XAML-Seite

Beginnen wir mit dem Erstellen einer einfachen XAML-Seite, die die zuvor im Code erstellte Benutzeroberfläche dupliziert. Fügen Sie zunächst eine neue Datei zu Ihrem Customizations (Portable)-Projekt hinzu, wählen Sie den Dateityp Forms XAML Page aus und geben Sie ihm den Namen StyledLabelPage.

Sobald die Datei erstellt wurde, ersetzen Sie den Inhalt durch Folgendes:

Dieses XAML erstellt genau dieselbe Seite, mit der wir zuvor gearbeitet haben. Beachten Sie das Hinzufügen der Namespace-Deklaration xmlns:local am Anfang der Datei sowie das Präfix local: vor jedem Verweis auf die StyledLabel-Objekte. Ohne diese weiß der XAML-Parser nicht, was ein StyledLabel ist und kann letztendlich nicht ausgeführt werden.

Um dies auszuführen, müssen Sie zwei kleine Änderungen vornehmen. Öffnen Sie zunächst die Datei App.cs und ändern Sie die GetMainPage-Methode so, dass sie wie folgt aussieht:

Öffnen Sie anschließend die Datei StyledLabelPage.xaml.cs und ändern Sie sie wie folgt:

Wenn Sie nun Ihre Anwendungen ausführen, sollten Sie auf allen drei Plattformen dieselben Ergebnisse erzielen. Ziemlich ordentlich, oder?

iOS

Android

Windows Phone

Schritt 2: Datenbindung hinzufügen

Wenn Sie mit dem Konzept des Model View View-Model Pattern (MVVM) vertraut sind, wissen Sie, dass eines seiner Hauptmerkmale die Datenbindung ist. Tatsächlich wurde dieses Muster um die Verwendung von XAML herum entwickelt.

Datenbindung ist der Prozess, bei dem die Eigenschaften zweier Objekte miteinander verknüpft werden können, sodass eine Änderung des einen Objekts eine Änderung des anderen bewirkt. Der Prozess der Datenbindung in XAML wird durch die Verwendung der Binding Markup Extension erreicht.

Markuperweiterungen sind kein Feature von Xamarin.Forms oder sogar von XAML. Es ist eigentlich eine Funktion von XML, die es ermöglicht, zusätzliche Funktionen auf den Prozess des Festlegens des Werts eines Attributs in einem Element anzuwenden.

Sehen wir uns zum Beispiel das erste StyledLabel-Element im obigen Beispiel genauer an.

Das Problem bei diesem Markup besteht darin, dass alle Eigenschaften (Attribute) explizit zugewiesen werden. Dadurch entsteht ein eher unflexibles Design. Was passiert also, wenn wir aus irgendeinem Grund während der Ausführung unserer Anwendung das Style-Attribut auf den Bold-Wert  ändern möchten? Nun, in unserer Code-Behind-Datei müssten wir nach einem Ereignis Ausschau halten, dieses Ereignis abfangen, diese Instanz des StyledLabel-Elements abrufen und diesen Attributwert ändern. Das klingt nach viel Arbeit. Wäre es nicht schön, wenn wir diesen Prozess vereinfachen könnten? Nun, wir können.

Bindende Markup-Erweiterung

Sie können dieses Design flexibler für Änderungen machen, indem Sie die Binding-Markup-Erweiterung verwenden. Sie verwenden diese Erweiterung, indem Sie das Markup so ändern, dass es wie folgt aussieht:

Wie Sie sehen, haben wir den Wert der Style-Eigenschaft in {Binding FirstStyle} geändert. Die Verwendung einer Markup-Erweiterung wird normalerweise durch die Verwendung von geschweiften Klammern {} angezeigt. Dies bedeutet, dass alles, was in den geschweiften Klammern enthalten ist, eine Markup-Erweiterung ist.

In diesem Fall verwenden wir die Binding-Erweiterung. Der zweite Teil dieser Erweiterung ist der Name einer Eigenschaft, die wir an diese Eigenschaft (Attribut) binden möchten. In diesem Fall nennen wir es FirstStyle. Das gibt es noch nicht, aber darum kümmern wir uns gleich. Lassen Sie uns zunächst diese Datei vollständig aktualisieren, um die Vorteile der Datenbindung zu nutzen.

BindingContext 

Da wir eine Bindung erstellen, versuchen wir per Definition, dieses XAML-Attribut mit etwas anderem zu verknüpfen, das es diesen beiden Eigenschaften ermöglicht, ihre Daten gemeinsam zu nutzen. Dazu müssen Sie zunächst eine Klasse erstellen, die Eigenschaften mit denselben Namen enthält, die wir im obigen XAML-Beispiel verwenden.

Erstellen Sie eine neue Klasse im Projekt Customizations (Portable) und nennen Sie sie SampleStyles und ersetzen Sie den Inhalt durch Folgendes:

Dies ist eine sehr einfache Klasse, die drei Eigenschaften vom Typ StyleType mit denselben Namen enthält, die wir in unserer Binding der Attribute verwendet haben. Wir haben jetzt das XAML mit der Binding-Markuperweiterung und einer Klasse, die Eigenschaften mit demselben Namen enthält, wie wir ihn in den Bindungen in XAML sehen. Wir brauchen nur Kleber, um sie zusammenzusetzen. Dieser Kleber ist der BindingContext.

Um die Eigenschaften dieser Objekte miteinander zu verknüpfen, müssen wir der BindingContext-Eigenschaft von StyledLabelPage eine Instanz der SampleStyles-Klasse zuweisen. Öffnen Sie die Datei StyledLabelPage.xaml.cs und ändern Sie den Konstruktor so, dass er wie folgt aussieht:

Theoretisch würde die XAML-Datei beim Ausführen Ihrer Anwendung mit den Werten aus unseren SampleStyles-Eigenschaften gefüllt und alles würde wie zuvor auf dem Bildschirm gerendert. Leider ist das nicht der Fall. Sie erhalten zur Laufzeit eine Ausnahme, die wie folgt aussieht:

Wenn Sie sich Zusätzliche Informationen ansehen, sehen Sie das Problem, dass keine Eigenschaft des Namensstils gefunden wurde. Dies ist ein Ergebnis der Art und Weise, wie wir das StyledLabel am Anfang erstellt haben. Um die Datenbindung nutzen zu können, müssen Ihre Eigenschaften vom Typ BindableProperty sein. Dazu müssen wir eine kleine Änderung an unserer StyledLabel-Klasse vornehmen.

Wie Sie sehen, haben wir eine statische Eigenschaft namens StyleProperty vom Typ BindableProperty hinzugefügt. Wir haben ihm dann das Ergebnis einer CreateMethod zugewiesen, die den Eigentümer der Eigenschaft definiert, mit der wir arbeiten.

Die Eigenschaft ist Style, aber der Besitzer ist StyledLabel. Der zweite generische Parameter ist der Rückgabetyp der Eigenschaft, der ein StyleType ist. Dann ist das einzige Argument, das wir an die Methode liefern, ein Ausdruck, der definiert, was zurückgegeben wird, und ein Standardwert. In unserem Fall geben wir den Wert der Style-Instanzeigenschaft zurück und der Standardwert ist None oder kein Styling.

Anschließend müssen wir die Implementierung der Style-Eigenschaft ändern, um die Abruf- und Einstellungsfunktionalität auf die Basisklasse zu verschieben, damit die BindingProperty ordnungsgemäß aktualisiert wird, wenn sich der Wert der Style-Eigenschaft ändert.

Wenn Sie Ihre Anwendung jetzt erneut ausführen, sollten Sie sehen, dass alles wie erwartet funktioniert.

iOS

Android

Windows Phone

Abschluss

In diesem Tutorial haben Sie ein sehr wichtiges Konzept in der Welt von Xamarin.Forms kennengelernt, die Anpassung. Die Anpassung ist eine der wichtigsten Funktionen, die es ihnen ermöglichen, sich von der Konkurrenz abzuheben.

Zu wissen, wie, wann und wo angepasst werden muss, ist eine sehr wichtige Fähigkeit, die man als mobiler Entwickler haben sollte. Ich hoffe, Sie finden diese Fähigkeiten nützlich und können sie in Ihrem nächsten Projekt sinnvoll einsetzen.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.