Share
Was Sie erstellen werdenRubyMotion ist ein fantastisches Framework zum Erstellen performanter iOS-Anwendungen mit der Sprache Ruby. Im ersten Teil dieses Tutorials haben Sie gelernt, wie Sie eine RubyMotion-Anwendung einrichten und implementieren. Sie haben mit Interface Builder an der Erstellung der Benutzeroberfläche der Anwendung gearbeitet, einen View-Controller implementiert und gelernt, wie Sie Tests für Ihre Anwendung schreiben.
In diesem Lernprogramm erfahren Sie mehr über das Model-View-Controller- oder MVC-Entwurfsmuster und wie Sie es zum Strukturieren Ihrer Anwendung verwenden können. Sie implementieren auch eine Malansicht und fügen eine Gestenerkennung hinzu, mit der der Benutzer auf dem Bildschirm zeichnen kann. Wenn Sie fertig sind, haben Sie eine vollständige, voll funktionsfähige Anwendung.
Apple empfiehlt iOS-Entwicklern, das Model-View-Controller-Entwurfsmuster auf ihre Anwendungen anzuwenden. Dieses Muster unterteilt Klassen in eine von drei Kategorien, Modelle, Ansichten und Controller.
Wie kann MVC auf Ihre Bewerbung angewendet werden? Sie haben bereits mit der Implementierung von PaintingController Klasse, die Ihre Modelle und Ansichten miteinander verbindet. Für die Modellebene fügen Sie zwei Klassen hinzu:
Accentsconagua
Schlaganfall Diese Klasse repräsentiert einen einzelnen Strich im Bild.Malerei Diese Klasse stellt das gesamte Gemälde dar und enthält einen oder mehrere Striche.Für die Ansichtsebene erstellen Sie eine PaintingView Klasse, die für die Anzeige von a verantwortlich ist Malerei dem Benutzer widersprechen. Sie werden auch eine hinzufügen StrokeGestureRecongizer das erfasst die Berührungseingaben des Benutzers.
Beginnen wir mit dem Schlaganfall Modell. Ein Strich besteht aus einer Farbe und mehreren Punkten, die den Strich darstellen. Erstellen Sie zunächst eine Datei für die Schlaganfall Klasse, App / Modelle / Schlaganfall.rb, und noch einer für seine Spezifikation, spec / models / stroke.rb.
Als Nächstes implementieren Sie das Skelett der Strichklasse und einen Konstruktor.
Klasse Stroke attr_reader: Punkte, Farbe Ende
Das Schlaganfall Klasse hat zwei Attribute, Punkte, eine Sammlung von Punkten und Farbe, die farbe der Schlaganfall Objekt. Als nächstes implementieren Sie einen Konstruktor.
Klasse Stroke attr_reader: Punkte, Farbe def initialisieren (Startpunkt, Farbe) @punkte = [startpunkt] @color = Ende der Farbe
Das sieht bisher gut aus. Der Konstruktor akzeptiert zwei Argumente, Startpunkt und Farbe. Es legt fest Punkte zu einem Array von Punkten, die enthalten Startpunkt und Farbe auf die bereitgestellte Farbe.
Wenn ein Benutzer mit dem Finger über den Bildschirm streicht, müssen Sie dem Punkt Punkte hinzufügen Schlaganfall Objekt. Ergänzen Sie die add_point Methode zu Schlaganfall.
def add_point (punkt) punkte << point end
Das war einfach. Fügen Sie der Einfachheit halber eine weitere Methode zum hinzu Schlaganfall Klasse, die den Startpunkt zurückgibt.
def start_point points.stes Ende
Natürlich ist kein Modell ohne eine Reihe von Spezifikationen vollständig.
Beschreibe Stroke do do @ start_point = CGPoint.new (0.0, 50.0) @middle_point = CGPoint.new (50.0, 100.0) @end_point = CGPoint.new (100.0, 0.0) @color = UIColor.blueColor @stroke = Stroke.new (@start_point, @color) @ stroke.add_point (@middle_point) @ stroke.add_point (@end_point) end Beschreiben Sie "#initialize", bevor do @stroke = Stroke.new (@start_point, @color) die Einstellung " color "do @ stroke.color.should == @color end end beschreiben" #start_point "do it" gibt den Startpunkt des Strichs zurück "do @ stroke.start_point.should == @start_point end end beschreiben" #add_point "do it" fügt die Punkte zum Strich hinzu "do @ stroke.points.should == [@start_point, @middle_point, @end_point] end end beschreiben" #start_point "do it" gibt den Startpunkt "do @ stroke.start_point.should == zurück @ start_point end end end
Das sollte sich vertraut anfühlen. Sie haben vier Beschreibungsblöcke hinzugefügt, die das testen initialisieren, Startpunkt, add_point, und Startpunkt Methoden. Es gibt auch ein Vor Block, der einige Instanzvariablen für die Spezifikationen festlegt. Beachten Sie die beschreiben Block für #initialisieren hat ein Vor Block, der das zurücksetzt @Schlaganfall Objekt. Das ist gut. Mit Spezifikationen müssen Sie sich nicht so sehr mit der Leistung befassen wie mit einer normalen Anwendung.
Es ist der Moment der Wahrheit, es ist Zeit, dass Ihre Anwendung etwas zeichnet. Erstellen Sie zunächst eine Datei für die PaintingView Klasse bei app / views / painting_view.rb. Weil wir ein spezielles Zeichnen machen, das PaintingView Klasse ist schwierig zu testen. Der Kürze halber werde ich die Spezifikationen vorerst überspringen.
Als nächstes implementieren Sie die PaintingView Klasse.
Klasse PaintingView < UIView attr_accessor :stroke def drawRect(rectangle) super # ensure the stroke is provided return if stroke.nil? # set up the drawing context context = UIGraphicsGetCurrentContext() CGContextSetStrokeColorWithColor(context, stroke.color.CGColor) CGContextSetLineWidth(context, 20.0) CGContextSetLineCap(context, KCGLineCapRound) CGContextSetLineJoin(context, KCGLineJoinRound) # move the line to the start point CGContextMoveToPoint(context, stroke.start_point.x, stroke.start_point.y) # add each line in the path stroke.points.drop(1).each do |point| CGContextAddLineToPoint(context, point.x, point.y) end # stroke the path CGContextStrokePath(context); end end
Puh, das ist viel Code. Lassen Sie uns das Stück für Stück abbauen. Das PaintingView Klasse erweitert die UIView Klasse. Dies erlaubt PaintingView als Unteransicht von PaintingControllerSicht. Das PaintingView Klasse hat ein Attribut, Schlaganfall, Das ist ein Beispiel für die Schlaganfall Modellklasse.
In Bezug auf das MVC-Muster ist es bei der Arbeit mit dem iOS-SDK akzeptabel, dass ein Modell über ein Modell informiert wird. Ein Modell kann jedoch nicht die Ansicht eines Modells kennen.
In dem PaintingView Klasse, wir haben außer Kraft gesetzt UIView's drawRect: Methode. Mit dieser Methode können Sie benutzerdefinierten Zeichnungscode implementieren. Die erste Zeile dieser Methode, Super, ruft die Methode in der Superklasse auf, UIView in diesem Beispiel mit den angegebenen Argumenten.
Im drawRect:, wir prüfen auch das Schlaganfall Attribut ist nicht Null. Dies verhindert Fehler, wenn Schlaganfall wurde noch nicht festgelegt. Wir rufen dann den aktuellen Zeichnungskontext durch Aufrufen ab UIGraphicsGetCurrentContext, Konfigurieren Sie den Strich, den Sie zeichnen möchten, und verschieben Sie den Zeichnungskontext in den Startpunkt des Strichs und fügt Linien für jeden Punkt im hinzu Schlaganfall Objekt. Zum Schluss rufen wir CGContextStrokePath um den Pfad zu streicheln und ihn in der Ansicht zu zeichnen.
Fügen Sie einen Auslass hinzu PaintingController für die Malansicht.
Steckdose: Anstrichansicht
Starten Sie den Interface Builder, indem Sie ihn ausführen Bündel Exec Rake ib: offen und fügen Sie ein UIView Einwände gegen die PaintingController's ansicht von der Ojbect-Bibliothek zur Rechten. Setzen Sie die Klasse der Ansicht auf PaintingView in dem Identitätsinspektor. Vergewissern Sie sich, dass sich die Malansicht unter den zuvor hinzugefügten Schaltflächen befindet. Sie können die Reihenfolge der Unteransichten anpassen, indem Sie die Positionen der Ansicht in der Ansichtshierarchie links ändern.
Steuern Sie und ziehen Sie vom Ansichts-Controller zum PaintingView und wähle das aus painting_view aus dem erscheinenden Menü.
Wählen Sie die Malansicht aus und stellen Sie die Hintergrundfarbe auf 250 rot, 250 grün und 250 Blau.
Vergiss nicht, eine Spezifikation hinzuzufügen spec / controller / painting_controller_spec.rb für die painting_view Auslauf.
beschreiben "#painting_view" do it "ist im Storyboard verbunden" do controller.painting_view.should.not.be.nil end end
Fügen Sie dem folgenden Code-Snippet hinzu, um sicherzustellen, dass Ihr Zeichencode ordnungsgemäß funktioniert PaintingController Klasse und führen Sie Ihre Anwendung aus. Sie können dieses Code-Snippet löschen, wenn Sie überprüft haben, dass alles wie erwartet funktioniert.
def viewDidLoad stroke = Stroke.new (CGPoint.new (80, 100), '# ac5160'.uicolor) stroke.add_point (CGPoint.new (240, 100)) stroke.add_point (CGPoint.new (240, 428)) stroke.add_point (CGPoint.new (80, 428)) stroke.add_point (CGPoint.new (80, 100)) painting_view.stroke = Strich painting_view.setNeedsDisplay end
Jetzt, da Sie einen Strich zeichnen können, ist es Zeit, das gesamte Bild zu erreichen. Beginnen wir mit dem Malerei Modell. Erstellen Sie eine Datei für die Klasse um app / models / painting.rb und implementieren die Malerei Klasse.
Klasse Painting attr_accessor: Striche def initialize @strokes = [] Ende def start_stroke (Punkt, Farbe) Striche << Stroke.new(point, color) end def continue_stroke(point) current_stroke.add_point(point) end def current_stroke strokes.last end end
Das Malerei Modell ähnelt dem Schlaganfall Klasse. Der Konstruktor wird initialisiert Schläge zu einem leeren Array. Wenn eine Person den Bildschirm berührt, startet die Anwendung durch Aufrufen einen neuen Strich start_stroke. Dann, wenn der Benutzer seinen Finger zieht, fügt er Punkte hinzu continue_stroke. Vergessen Sie nicht die Angaben für die Malerei Klasse.
beschreiben Malen vor do @ point1 = CGPoint.new (10, 60) @ point2 = CGPoint.new (20, 50) @ point3 = CGPoint.new (30, 40) @ point4 = CGPoint.new (40, 30) @ point5 = CGPoint.new (50, 20) @ point6 = CGPoint.new (60, 10) @painting = Painting.new ende beschreibe "#initialize" do do, bevor do @painting = Painting.new end es den Strich auf ein setzt leeres Array "do @ painting.strokes.should == [] Ende Ende beschreiben" #start_stroke ", bevor do @ painting.start_stroke (@ point1, UIColor.redColor) @ painting.start_stroke (@ point2, UIColor.blueColor) beendet wird "startet neue Striche" do @ painting.strokes.length.should == 2 @ painting.strokes [0] .points.should == [@ point1] @ painting.strokes [0] .color.should == UIColor.redColor @ painting.strokes [1] .points.should == [@ point2] @ painting.strokes [1] .color.should == UIColor.blueColor end end beschreibt "#continue_stroke" vor do @ painting.start_stroke (@ point1 , UIColor.redColor) @ painting.continue_stroke (@ point2) @ painting.start_stroke (@ point3, UIColor.blueColor) @ painting.con tinue_stroke (@ point4) ende fügt den aktuellen Strichen Punkte hinzu "do @ painting.strokes [0] .points.should == [@ point1, @ point2] @ painting.strokes [1] .points.should == [ @ point3, @ point4] end end end
Als nächstes ändern Sie die PaintingView Klasse zeichnen a Malerei Objekt statt eines Schlaganfall Objekt.
Klasse PaintingView < UIView attr_accessor :painting def drawRect(rectangle) super # ensure the painting is provided return if painting.nil? painting.strokes.each do |stroke| draw_stroke(stroke) end end def draw_stroke(stroke) # set up the drawing context context = UIGraphicsGetCurrentContext() CGContextSetStrokeColorWithColor(context, stroke.color.CGColor) CGContextSetLineWidth(context, 20.0) CGContextSetLineCap(context, KCGLineCapRound) CGContextSetLineJoin(context, KCGLineJoinRound) # move the line to the start point CGContextMoveToPoint(context, stroke.start_point.x, stroke.start_point.y) # add each line in the path stroke.points.drop(1).each do |point| CGContextAddLineToPoint(context, point.x, point.y) end # stroke the path CGContextStrokePath(context); end end
Du hast das geändert Schlaganfall zuschreiben Malerei. Das drawRect: Die Methode durchläuft nun alle Striche im Bild und zeichnet alle mit draw_stroke, enthält den Zeichnungscode, den Sie zuvor geschrieben haben.
Sie müssen auch den View-Controller so aktualisieren, dass er ein enthält Malerei Modell. An der Spitze der PaintingController Klasse hinzufügen attr_reader: malerei. Wie der Name schon sagt, die viewDidLoad Methode der UIViewController Klasse - die Oberklasse der PaintingController class-wird aufgerufen, wenn der View-Controller seine Ansicht vollständig geladen hat. Das viewDidLoad Methode ist daher ein guter Ort, um eine zu erstellen Malerei Instanz und setzen Sie die Malerei Attribut des PaintingView Objekt.
def viewDidLoad @painting = Painting.new painting_view.painting = Ende der Malerei
Vergessen Sie nicht, für immer Tests hinzuzufügen viewDidLoad zu spec / controller / painting_controller_spec.rb.
beschreiben "#viewDidLoad" do it "setzt das Bild" do controller.painting.should.be.instance_of Painting end it "setzt das Bildattribut der Malansicht" do controller.painting_view.painting.should == controller.painting end end
Ihre Anwendung wird ziemlich langweilig, wenn Sie nicht zulassen, dass Personen mit ihren Fingern auf dem Bildschirm zeichnen. Lassen Sie uns diese Funktion jetzt hinzufügen. Erstellen Sie eine Datei für die StrokeGestureRecognizer Klasse zusammen mit ihrer Spezifikation, indem Sie die folgenden Befehle von der Befehlszeile aus ausführen.
Berühren Sie app / views / stroke_gesture_recognizer.rb. berühren Sie spec / views / stroke_gesture_recognizer_spec.rb
Als Nächstes erstellen Sie das Skelett für die Klasse.
Klasse StrokeGestureRecognizer < UIGestureRecognizer attr_reader :position end
Das StrokeGestureRecognizer Klasse erweitert die UIGestureRecognizer Klasse, die die Berührungseingabe übernimmt. Es hat ein Position Attribut, dass die PaintingController Die Klasse verwendet die Position des Fingers des Benutzers.
Es gibt vier Methoden, die Sie in implementieren müssen StrokeGestureRecognizer Klasse, berührtBegan: withEvent:, touchesMoved: withEvent:, touchesEnded: withEvent:, und BerührtCancelled: withEvent:. Das berührtBegan: withEvent: Diese Methode wird aufgerufen, wenn der Benutzer den Bildschirm mit dem Finger berührt. Das touchesMoved: withEvent: Methode wird wiederholt aufgerufen, wenn der Benutzer den Finger bewegt und die touchesEnded: withEvent: Diese Methode wird aufgerufen, wenn der Benutzer den Finger vom Bildschirm nimmt. Endlich, das BerührtCancelled: withEvent: Die Methode wird aufgerufen, wenn die Geste vom Benutzer abgebrochen wird.
Ihr Gestenerkenner muss für jedes Ereignis zwei Aktionen ausführen. Aktualisieren Sie das Position Attribut und ändern Sie die Zustand Eigentum.
Klasse StrokeGestureRecognizer < UIGestureRecognizer attr_accessor :position def touchesBegan(touches, withEvent: event) super @position = touches.anyObject.locationInView(self.view) self.state = UIGestureRecognizerStateBegan end def touchesMoved(touches, withEvent: event) super @position = touches.anyObject.locationInView(self.view) self.state = UIGestureRecognizerStateChanged end def touchesEnded(touches, withEvent: event) super @position = touches.anyObject.locationInView(self.view) self.state = UIGestureRecognizerStateEnded end def touchesCancelled(touches, withEvent: event) super @position = touches.anyObject.locationInView(self.view) self.state = UIGestureRecognizerStateEnded end end
Beide touchesEnded: withEvent: und BerührtCancelled: withEvent: Methoden setzen den Status auf UIGestureRecognizerStateEnded. Dies ist darauf zurückzuführen, dass es egal ist, ob der Benutzer unterbrochen wird. Die Zeichnung sollte jedoch nicht berührt werden.
Um das zu testen StrokeGestureRecognizer Klasse müssen Sie eine Instanz von erstellen können UITouch. Leider gibt es keine öffentlich verfügbare API, um dies zu erreichen. Damit dies funktioniert, verwenden wir die Facon-Spottungsbibliothek.
Hinzufügen Juwel 'Bewegungs-Facon' zu deinem Gemfile und laufe Bundle installieren. Dann füge hinzu erfordern "Motion-Facon" unten benötigen "Zuckerwürfel-Farbe" im Rakefile des Projekts.
Als nächstes implementieren Sie die StrokeGestureRecognizer spez.
beschreiben StrokeGestureRecognizer. Erweitern Sie Facon :: SpecHelpers vor do @stroke_gesture_recognizer = StrokeGestureRecognizer.new @ touch1 = mock (UITouch,: "locationInView:" => CGPoint.new (100, 200)) @ touch2 = mock (UITouch,: "locationInView: "=> CGPoint.new (300, 400)) @ touches1 = NSSet.setWithArray [@ touch1] @ touches2 = NSSet.setWithArray [@ touch2] Ende beschreiben" #touchesBegan: withEvent: "do do do @ stroke_gesture_recognizer.touchesBegan (@ touches1, withEvent: nil) end it "setzt die Position auf die Position der Geste" do @ stroke_gesture_recognizer.position.should == CGPoint.new (100, 200) end it "setzt den Zustand der Gestenerkennung" do @ stroke_gesture_recognizer.state .should == UIGestureRecognizerStateBegan Ende Ende beschreiben "#touchesMoved: withEvent:" do @ doct_gesture_recognizer.touchesBegan (@ touches1, withEvent: nil) @ stroke_gesture_recognizer.touchesMoved (@ touches2, withEvent) Gestenposition "do @ stroke_gesture_recognizer.pos ition.should == CGPoint.new (300, 400) end it "setzt den Zustand der Gestenerkennung" do @ stroke_gesture_recognizer.state.should == UIGestureRecognizerStateChanged end end beschreiben "#touchesEnded: withEvent:" do do do do @stroke_gesture_recognizer. touchesBegan (@ touches1, withEvent: nil) @ stroke_gesture_recognizer.touchesEnded (@ touches2, withEvent: nil) ende "setzt die Position auf die Position der Geste" do @ stroke_gesture_recognizer.position.should == CGPoint.new (300, 400) end es "setzt den Zustand des Gestenerkenners" do @ stroke_gesture_recognizer.state.should == UIGestureRecognizerStateEnded end end beschreiben "#touchesCancelled: withEvent:" do before do @ stroke_gesture_recognizer.touchesBegan (@ touches1, withEvent: nil) @ touches2, withEvent: nil) end it "setzt die Position auf die Position der Geste" do @ stroke_gesture_recognizer.position.should == CGPoint.new (300, 400) end it "setzt den Zustand der Gestenerkennung" do @stroke_gesture_r ecognizer.state.should == Ende von UIGestureRecognizerStateEnded
erweitern Sie Facon :: SpecHelpers stellt verschiedene Methoden in Ihren Daten zur Verfügung, einschließlich spotten. spotten ist eine einfache Möglichkeit, Testobjekte zu erstellen, die genau so funktionieren, wie Sie es möchten. In dem Vor blockieren Sie am Anfang der Spezifikationen, Sie verspotten Instanzen von UITouch mit dem locationInView: Methode, die einen vordefinierten Punkt zurückgibt.
Als nächstes fügen Sie ein stroke_gesture_changed Methode zum PaintingController Klasse. Diese Methode erhält eine Instanz von StrokeGestureRecognizer Klasse, wenn die Geste aktualisiert wird.
def stroke_gesture_changed (stroke_gesture_recognizer) if stroke_gesture_recognizer.state == UIGestureRecognizerStateBegan painting.start_stroke (stroke_gesture_recognizer.position, selected_color) sonst painting.continue_stroke (stroke_gesture_recognizer.position)
Wenn der Status der Gestenerkennung ist UIGestureRecognizerStateBegan, Diese Methode startet einen neuen Strich im Malerei Objekt mit der StrokeGestureRecognizerPosition und selected_color. Andernfalls wird der aktuelle Hub fortgesetzt.
Fügen Sie die Spezifikationen für diese Methode hinzu.
Beschreiben Sie "#stroke_gesture_changed", bevor Sie ziehen (controller.painting_view,: points => [CGPoint.new (100, 100), CGPoint.new (150, 150), CGPoint.new (200, 200)]). fügt die Punkte zum Strich hinzu "do controller.painting.strokes.first.points [0] .should == CGPoint.new (100, 100) controller.painting.strokes.first.points [1] .should == CGPoint. new (150, 150) controller.painting.strokes.first.points [2] .should == CGPoint.new (200, 200) ende "setzt die Farbe des Strichs auf die ausgewählte Farbe" do controller.painting.strokes.first .color.should == Controller.selected_color end end
RubyMotion bietet verschiedene Hilfsmethoden, um Benutzerinteraktionen zu simulieren, einschließlich ziehen. Verwenden ziehen, Sie können die Interaktion eines Benutzers mit dem Bildschirm simulieren. Das Punkte Mit dieser Option können Sie ein Array mit Punkten zum Ziehen bereitstellen.
Wenn Sie die Spezifikationen jetzt ausführen würden, würden sie fehlschlagen. Das liegt daran, dass Sie die Gestenerkennung zum Storyboard hinzufügen müssen. Starten Sie den Interface Builder durch Ausführen Bündel Exec Rake ib: offen. Von dem Objektbibliothek, ziehen Sie ein Objekt in Ihre Szene und ändern Sie ihre Klasse in StrokeGestureRecognizer in dem Identitätsinspektor zur Rechten.
Steuern und ziehen Sie aus dem StrokeGestureRecognizer Einwände gegen die PaintingController und wähle das Wähle Farbe Methode aus dem erscheinenden Menü. Damit wird sichergestellt Wähle Farbe Die Methode wird aufgerufen, wenn der Gestenerkenner ausgelöst wird. Dann steuern und ziehen Sie aus dem PaintingView Einwände gegen die StrokeGestureRecognizer Objekt und auswählen gestureRecognizer aus dem erscheinenden Menü.
Fügen Sie eine Spezifikation für die Gestenerkennung zum hinzu PaintingController Angaben in der #painting_view beschreiben Block.
beschreiben "#painting_view" "do it" ist im Storyboard verbunden. "do controller.painting_view.should.not.be.n.nil ende es" hat eine Stroke-Gestenerkennung "do controller.painting_view.gestureRecognizers.length.should == 1 Controller. painting_view.gestureRecognizers [0] .should.be.instance_of StrokeGestureRecognizer end end
Das ist es. Mit diesen Änderungen sollte Ihre Anwendung nun einer Person ermöglichen, auf dem Bildschirm zu zeichnen. Starten Sie Ihre Anwendung und haben Sie Spaß.
Bevor Sie Ihre Bewerbung abschließen, müssen Sie noch ein paar letzte Änderungen hinzufügen. Da Ihre Anwendung immersiv ist, ist die Statusleiste etwas ablenkend. Sie können es entfernen, indem Sie die UIStatusBarHidden und UIViewControllerBasedStatusBarAppearance Werte in der Info.plist der Anwendung. Dies ist in RubyMotion einfach zu bewerkstelligen Konfiguration innerhalb des Rakefile des Projekts blockieren.
Motion :: Project :: App.setup do | app | app.name = 'Paint' app.info_plist ['UIStatusBarHidden'] = true app.info_plist ['UIViewControllerBasedStatusBarAppearance'] = falsches Ende
Die Symbole und Startbilder der Anwendung sind in den Quelldateien dieses Lernprogramms enthalten. Laden Sie die Bilder herunter und kopieren Sie sie in die Ressourcen Verzeichnis des Projekts. Legen Sie dann das Anwendungssymbol in der Rakefile-Konfiguration fest. Möglicherweise müssen Sie den Build bereinigen, indem Sie ihn ausführen Bündel Exec Rake Clean: Alle um das neue Startbild zu sehen.
Motion :: Project :: App.setup do | app | app.name = 'Paint' app.info_plist ['UIStatusBarHidden'] = true app.info_plist ['UIViewControllerBasedStatusBarAppearance'] = false app.icons = ["icon.png"] end
Das ist es. Sie haben jetzt eine vollständige App, die für eine Million Downloads im App Store bereit ist. Sie können die Quelle für diese Anwendung in GitHub anzeigen und herunterladen.
Obwohl Ihre App fertig ist, können Sie noch viel mehr hinzufügen. Sie können Kurven zwischen den Linien, mehr Farben, unterschiedliche Linienstärken, Speichern, Rückgängigmachen und Wiederherstellen sowie alles, was Sie sich vorstellen können, hinzufügen. Was werden Sie tun, um Ihre App zu verbessern? Lass es mich in den Kommentaren wissen.
