Share
Im ersten Tutorial dieser kurzen Serie zu UIKit Dynamics haben wir die Grundlagen der API durch Erstellen einer animierten Menükomponente gelernt. In diesem Lernprogramm arbeiten wir weiter an unserem Projekt und implementieren eine weitere animierte Komponente, eine benutzerdefinierte Warnansicht.
Die Standard-Warnansicht für iOS ist großartig, kann jedoch hinsichtlich Aussehen und Verhalten nicht sehr anpassbar sein. Wenn Sie eine anpassbare Warnmeldungsansicht benötigen, müssen Sie Ihre eigene Lösung erstellen. Dies tun wir in diesem Lernprogramm. Der Schwerpunkt dieses Tutorials liegt auf dem Verhalten der Warnmeldungsansicht und nicht so sehr auf der Funktionalität. Mal sehen, was das Ergebnis ist, wonach wir streben
Die Alarmansicht wird a UIView Instanz, zu der wir die folgenden Unteransichten hinzufügen:
Accentsconagua
UILabel Objekt zur Anzeige des Titels der WarnansichtUILabel Objekt zur Anzeige der Meldung der WarnansichtUIButton Instanzen, damit der Benutzer mit der Warnungsansicht interagieren kannWir werden die verwenden UISnapBehavior Klasse, um die Alertansicht anzuzeigen. Wie der Name schon sagt, dies UIDynamicBehavior Die Unterklasse zwingt ein dynamisches Element, an einem Punkt zu schnappen, als wäre es magnetisch angezogen.
Das UISnapBehavior Klasse definiert eine zusätzliche Eigenschaft, Dämpfung, definiert den Schwingungsbetrag, wenn das dynamische Element den Punkt erreicht hat, zu dem es angezogen wird.
Wir verwenden ein Schwerkraftverhalten in Kombination mit einem Kollisions- und Push-Verhalten, um die Alarmansicht zu schließen. Denken Sie daran, dass wir dieses Verhalten bereits im vorherigen Tutorial verwendet haben.
Die Warnansicht wird vom oberen Bildschirmrand aus animiert. Wenn die Warnmeldungsansicht kurz vor dem Erscheinen angezeigt wird, wird sie durch das Fangverhalten in den Sichtbereich fallen und in der Mitte des Bildschirms einrasten. Um die Alarmansicht zu schließen, drückt ein Push-Verhalten kurz auf den unteren Rand des Bildschirms. Ein Schwerkraft-Verhalten zieht es dann an den oberen Rand des Bildschirms und animiert es außerhalb des Bildschirms.
Wir erstellen eine benutzerdefinierte Initialisierungsmethode für die Komponente der Alertansicht, die den Titel, die Nachricht, die Schaltflächentitel und die übergeordnete Ansicht der Alerts akzeptiert. Wir implementieren kein Delegatenprotokoll für die Alertansicht. Stattdessen verwenden wir Blöcke, wodurch eine elegantere und modernere Lösung entsteht. Der Block oder Handler akzeptiert zwei Parameter, den Index und den Titel der Schaltfläche, auf die der Benutzer geklickt hat.
Hinter der Warnungsansicht wird auch eine halbtransparente Ansicht angezeigt, um zu verhindern, dass der Benutzer mit seiner übergeordneten Ansicht interagiert, solange die Warnungsansicht sichtbar ist. Beginnen wir mit einem Blick auf die Eigenschaften der Warnansicht und den benutzerdefinierten Initialisierer.
Drücken Sie Befehl-N Auf Ihrer Tastatur können Sie eine neue Datei erstellen und auswählen Ziel-C-Klasse aus der Liste von iOS Vorlagen. Mach eine Unterklasse von NSObject und nennen Sie es AlertComponent.
Im nächsten Schritt müssen Sie einige private Eigenschaften angeben. Öffnen AlertComponent.m, Fügen Sie oben eine Klassenerweiterung hinzu und deklarieren Sie die folgenden Eigenschaften:
@interface AlertComponent () @property (nicht atomar, stark) UIView * alertView; @ property (nichtatomisch, stark) UIView * backgroundView; @ property (nichtatomisch, stark) UIView * targetView; @ property (nichtatomisch, stark) UILabel * titleLabel; @ property (nichtatomisch, stark) UILabel * messageLabel; @ property (nonatomic, strong) UIDynamicAnimator * -Animateur; @ property (nichtatomisch, stark) NSString * title; @ property (nonatomic, strong) NSString * Nachricht; @ property (nonatomic, strong) NSArray * buttonTitles; @ property (nonatomic) CGRect initialAlertViewFrame; @Ende
Die Funktion jeder Eigenschaft wird klar, wenn wir die Alertkomponente implementieren. Es ist Zeit, den benutzerdefinierten Initialisierer der Komponente zu erstellen.
Wie bereits erwähnt, verwenden wir einen benutzerdefinierten Initialisierer, um die Arbeit mit der Alarmkomponente so einfach wie möglich zu gestalten. Der Initialisierer akzeptiert vier Parameter, den Alert-Titel, die Nachricht, die Schaltflächentitel und die Ansicht, zu der die Alert-Komponente hinzugefügt wird, die übergeordnete Ansicht. Öffnen AlertComponent.h und füge folgende Erklärung hinzu:
@interface AlertComponent: NSObject - (id) initAlertWithTitle: (NSString *) title andMessage: (NSString *) - Nachricht andButtonTitles: (NSArray *) buttonTitles andTargetView: (UIView *) targetView; @Ende
In diesem Teil wird die Alarmansicht eingerichtet und alle ihre Unteransichten werden hinzugefügt. Auch die Hintergrundansicht sowie der dynamische Animator werden eingerichtet.
Öffnen AlertComponent.m und deklarieren Sie die folgenden privaten Methoden in der privaten Klassenerweiterung:
@interface AlertComponent ()… - (void) setupBackgroundView; - (void) setupAlertView; @Ende
Die Methodennamen sind selbsterklärend. Beginnen wir mit der Implementierung von setupAlertView Methode zuerst, da der größte Teil der Einrichtung der Warnung in dieser Methode erfolgt.
Im setupAlertView, Wir machen drei Dinge:
Beginnen wir mit der Berechnung der Größe und Position der Warnungsansicht, wie im nachstehenden Code-Snippet gezeigt.
- (void) setupAlertView // Legt die Größe der Warnungsansicht fest. CGSize alertViewSize = CGSizeMake (250.0, 130.0 + 50.0 * self.buttonTitles.count); // Legen Sie den anfänglichen Ursprungspunkt in Abhängigkeit von der Richtung der Warnmeldungsansicht fest. CGPoint initialOriginPoint = CGPointMake (self.targetView.center.x, self.targetView.frame.origin.y - alertViewSize.height);
Wir beginnen mit der Einstellung der Größe der Warnansicht. Um die Alarmansicht dynamisch zu machen, fügen wir hinzu 50,0 zeigt für jede Taste auf die Höhe. Beachten Sie auch, dass der ursprüngliche Ursprung der Warnmeldungsansicht außerhalb des Bildschirms liegt. Der nächste Schritt ist das Initialisieren und Einrichten der Warnmeldungsansicht:
self.alertView = [[UIView-Zuordnung] initWithFrame: CGRectMake (initialOriginPoint.x, initialOriginPoint.y, alertViewSize.width, alertViewSize.height)]; // Hintergrundfarbe. [self.alertView setBackgroundColor: [UIColor colorWithRed: 0,94 grün: 0,94 blau: 0,94 alpha: 1,0]]; // Die Alarmansicht mit abgerundeten Ecken erstellen. [self.alertView.layer setCornerRadius: 10.0]; // Einen Rahmen für die Alarmansicht setzen. [self.alertView.layer setBorderWidth: 1.0]; [self.alertView.layer setBorderColor: [UIColor blackColor] .CGColor]; // Weisen Sie den ersten Alert-View-Frame der jeweiligen Eigenschaft zu. self.initialAlertViewFrame = self.alertView.frame;
Verwenden alertViewSize und initialOriginPoint, wir initialisieren das alertView Objekt und legen Sie die Hintergrundfarbe fest. Wir runden die Ecken der Warnungsansicht ab, indem wir die Einstellung festlegen Schicht's Eckenradius zu 10,0, es ist Rahmenbreite zu 1,0, und sein Randfarbe schwärzen. Wir speichern auch den Anfangsrahmen der Alarmansicht in seinem initialAlertViewFrame Eigentum, da wir es später brauchen werden.
Wenn Xcode Ihnen mitteilt, weiß er nichts davon alertView's Schicht fügen Sie dann die folgende Importanweisung oben in der Implementierungsdatei hinzu:
#einführen
Es ist Zeit, die Etiketten hinzuzufügen. Beginnen wir mit dem Titeletikett.
// Richten Sie das Titeletikett ein. self.titleLabel = [[UILabel zuteilen] initWithFrame: CGRectMake (0.0, 10.0, self.alertView.frame.size.width, 40.0)]; [self.titleLabel setText: self.title]; [self.titleLabel setTextAlignment: NSTextAlignmentCenter]; [self.titleLabel setFont: [UIFont fontWithName: @ "Avenir-Heavy" Größe: 14.0]]; // Fügen Sie der Alertansicht die Titelbezeichnung hinzu. [self.alertView addSubview: self.titleLabel];
Das Einrichten der Nachrichtenbeschriftung ist ziemlich ähnlich.
// Richten Sie die Nachrichtenbezeichnung ein. self.messageLabel = [[UILabel zuweisen] initWithFrame: CGRectMake (0.0, self.titleLabel.frame.origin.y + self.titleLabel.frame.size.height, self.alertView.frame.size.width, 80.0)]; [self.messageLabel setText: self.message]; [self.messageLabel setTextAlignment: NSTextAlignmentCenter]; [self.messageLabel setFont: [UIFont fontWithName: @ "Avenir" Größe: 14.0]]; [self.messageLabel setNumberOfLines: 3]; [self.messageLabel setLineBreakMode: NSLineBreakByWordWrapping]; // Fügen Sie die Meldungsbezeichnung zur Warnmeldungsansicht hinzu. [self.alertView addSubview: self.messageLabel];
Notiere dass der anzahl der Zeilen Eigenschaft ist auf gesetzt 3 und lineBreakMode ist eingestellt auf NSLineBreakByWordWrapping.
Das letzte, was wir einrichten müssen, sind die Schaltflächen der Alarmansicht. Obwohl die Anzahl der Tasten variieren kann, ist das Einrichten und Positionieren der Tasten ziemlich einfach. Wir trennen die Knöpfe durch 5 Punkte und verwenden Sie eine zum Schleife, um sie zu initialisieren.
CGFloat lastSubviewBottomY = self.messageLabel.frame.origin.y + self.messageLabel.frame.size.height; für (int i = 0; i<[self.buttonTitles count]; i++) UIButton *button = [[UIButton alloc] initWithFrame:CGRectMake(10.0, lastSubviewBottomY + 5.0, self.alertView.frame.size.width - 20.0, 40.0)]; [button setTitle:[self.buttonTitles objectAtIndex:i] forState:UIControlStateNormal]; [button.titleLabel setFont:[UIFont fontWithName:@"Avenir" size:13.0]]; [button setTitleColor:[UIColor whiteColor] forState:UIControlStateNormal]; [button setTitleColor:[UIColor yellowColor] forState:UIControlStateHighlighted]; [button setBackgroundColor:[UIColor colorWithRed:0.0 green:0.47 blue:0.39 alpha:1.0]]; [button addTarget:self action:@selector(handleButtonTap:) forControlEvents:UIControlEventTouchUpInside]; [button setTag:i + 1]; [self.alertView addSubview:button]; lastSubviewBottomY = button.frame.origin.y + button.frame.size.height;
Beachten Sie, dass jede Schaltfläche die handleButtonTap: Methode, wenn es angezapft wird. Wir können feststellen, welche Taste der Benutzer angetippt hat, indem wir die Tasten prüfen Etikett Eigentum.
Fügen Sie schließlich die Warnungsansicht der Ziel- oder der übergeordneten Ansicht hinzu, indem Sie die folgende Zeile am unteren Rand der setupAlertView-Methode hinzufügen:
// Füge die Warnansicht der übergeordneten Ansicht hinzu. [self.targetView addSubview: self.alertView];
Die zweite Methode, die wir implementieren müssen, ist setupBackgroundView. Die Hintergrundansicht verhindert, dass der Benutzer mit der übergeordneten Ansicht der Warnmeldungsansicht interagiert, solange die Warnmeldungsansicht angezeigt wird. Wir haben uns zunächst gesetzt Alpha Eigentum an 0,0, was bedeutet, dass es transparent ist.
- (void) setupBackgroundView self.backgroundView = [[UIView-Zuordnung] initWithFrame: self.targetView.frame]; [self.backgroundView setBackgroundColor: [UIColor grayColor]]; [self.backgroundView setAlpha: 0.0]; [self.targetView addSubview: self.backgroundView];
Mit setupAlertView und setupBackgroundView Jetzt können Sie den zuvor deklarierten benutzerdefinierten Initialisierer implementieren.
- (id) initAlertWithTitle: (NSString *) title undMessage: (NSString *) -Meldung undButtonTitles: (NSArray *) buttonTitles undTargetView: (UIView *) targetView if (self = [super init]) Weisen Sie die Parameterwerte local zu Eigenschaften. self.title = Titel; self.message = Nachricht; self.targetView = targetView; self.buttonTitles = buttonTitles; // Die Hintergrundansicht einrichten. [self setupBackgroundView]; // Richten Sie die Alertansicht ein. [self setupAlertView]; // Den Animator einrichten. self.animator = [[UIDynamicAnimator-Zuordnung] initWithReferenceView: self.targetView]; return self;
Wir setzen die Titel, Botschaft, targetView, und buttonTitles Eigenschaften, aufrufen setupBackgroundView und setupAlertView, und initialisieren Sie den dynamischen Animator, indem Sie ihn übergeben self.targetView als Referenzansicht.
Um die Warnmeldungsansicht anzuzeigen, nachdem sie initialisiert wurde, müssen Sie eine öffentliche Methode deklarieren und implementieren, die beispielsweise vom View Controller, der die Warnmeldungsansicht hostet, aufgerufen werden kann. Öffnen AlertComponent.h und fügen Sie die folgende Methodendeklaration hinzu:
- (void) showAlertView;
Geh zurück zu AlertComponent.m implementieren showAlertView. Wie ich bereits in diesem Tutorial erwähnt habe, verwenden wir ein neues UIDynamicBehavior Unterklasse, um die Alarmansicht anzuzeigen, UISnapBehavior. Mal sehen, wie wir diese Klasse in verwenden showAlertView.
- (void) showAlertView [self.animator removeAllBehaviors]; UISnapBehavior * snapBehavior = [[UISnapBehavior-Zuordnung] initWithItem: self.alertView snapToPoint: self.targetView.center]; snapBehavior.damping = 0,8; [self.animator addBehavior: snapBehavior]; [UIView animateWithDuration: 0.75 Animationen: ^ [self.backgroundView setAlpha: 0.5]; ];
Wir entfernen zunächst vorhandene dynamische Verhaltensweisen aus dem dynamischen Animator, um sicherzustellen, dass keine Konflikte auftreten. Denken Sie daran, dass einige dynamische Verhaltensweisen nur einmal zum dynamischen Animator hinzugefügt werden können, beispielsweise ein Verhalten der Schwerkraft. Außerdem fügen wir weitere dynamische Verhaltensweisen hinzu, um die Warnmeldungsansicht zu schließen.
Wie Sie sehen können, ist die Verwendung eines Fangverhaltens nicht schwierig. Wir legen fest, auf welches dynamische Element das Verhalten angewendet werden soll, und legen den Punkt fest, an dem das dynamische Element einrasten soll. Wir legen auch das Verhalten fest Dämpfung Eigentum, wie wir zuvor besprochen haben. Beachten Sie auch, dass wir das animieren Alpha Eigenschaft der Hintergrundansicht.
Um die Warnmeldungsansicht zu testen, müssen wir einige Änderungen an der Warnungsansicht vornehmen ViewController Klasse. Beginnen wir mit dem Hinzufügen von a UIButton Instanz in die Ansicht des View-Controllers ein, um die Alarmansicht anzuzeigen. Öffnen Hauptplatine und ziehen Sie ein UIButton Beispiel aus dem Objektbibliothek zur Ansicht des View-Controllers. Positionieren Sie den Button am unteren Rand der Ansicht und geben Sie ihm den Titel Warnungsansicht anzeigen. Fügen Sie eine Aktion zu hinzu ViewController.h Wie nachfolgend dargestellt.
@Interface ViewController: UIViewController - (IBAction) showAlertView: (ID) Absender; @Ende
Gehen Sie zurück zum Storyboard und verbinden Sie die Aktion des View-Controllers mit der Schaltfläche. Öffnen ViewController.m und importieren Sie die Header-Datei des AlertComponent Klasse.
#import "AlertComponent.h"
Als Nächstes deklarieren Sie eine Eigenschaft in der privaten Klassenerweiterung von type AlertComponent und nennen Sie es alertComponent.
@Interface ViewController () @Eigenschaft (nicht atomar, stark) MenuComponent * menuComponent; @ property (nonatomic, strong) AlertComponent * alertComponent; - (void) showMenu: (UIGestureRecognizer *) GestureRecognizer; @Ende
Anschließend initialisieren wir die Alert-Komponente in den View-Controllern viewDidLoad Methode.
- (void) viewDidLoad … // Initialisieren der Alert-Komponente self.alertComponent = [[AlertComponent-Zuordnung] initAlertWithTitle: @ "Custom Alert" andMessage: @ "Sie haben eine neue E-Mail-Nachricht, aber ich weiß nicht, von wem." andButtonTitles: @ [@ "Zeig es mir", @ "Ich interessiere mich nicht", @ "Für mich wirklich?"] undTargetView: self.view];
Rufen Sie zum Anzeigen der Alarmkomponente auf showAlertView: in der Aktion, die wir gerade erstellt haben, showAlertView:.
- (IBAction) showAlertView: (id) Sender [self.alertComponent showAlertView];
Führen Sie Ihre Anwendung aus und tippen Sie auf die Schaltfläche, um die Warnansicht anzuzeigen. Das Ergebnis sollte ähnlich wie das folgende aussehen.
Wie wir zuvor gesehen haben, die handleButtonTap: Die Methode wird aufgerufen, wenn der Benutzer auf eine Schaltfläche der Warnmeldungsansicht tippt. Die Warnmeldungsansicht sollte ausgeblendet werden, wenn eine der Schaltflächen betätigt wird. Mal sehen, wie das funktioniert.
Erneut besuchen AlertComponent.m und deklarieren Sie in der privaten Klassenerweiterung das handleButtonTap: Methode.
@interface AlertComponent ()… - (void) handleButtonTap: (UIButton *) -Sender; @Ende
In dieser Methode erstellen wir eine Reihe dynamischer Verhaltensweisen und fügen sie dem dynamischen Animatorobjekt hinzu. Das dynamische Verhalten, das wir brauchen, ist:
Nachdem Sie die vorhandenen Verhalten aus dem dynamischen Animator entfernt haben, und initialisieren Sie das Push-Verhalten wie unten gezeigt.
- (void) handleButtonTap: (UIButton *) sender // Entfernen Sie alle Verhalten aus dem Animator. [self.animator removeAllBehaviors]; UIPushBehavior * pushBehavior = [[UIPushBehavior-Zuordnung] initWithItems: @ [self.alertView] -Modus: UIPushBehaviorModeInstantaneous]; [pushBehavior setAngle: M_PI_2 Magnitude: 20.0]; [self.animator addBehavior: pushBehavior];
Das Winkel Die Eigenschaft des Push-Verhaltens definiert die Richtung des Pushs. Durch Einstellen des Winkels auf M_PI_2, Die Kraft des Schubverhaltens ist auf den unteren Rand des Bildschirms gerichtet.
Der nächste Schritt ist das Hinzufügen des Schwerkraftverhaltens. Der Vektor, den wir übergeben setGravityDirection Dies führt zu einer Kraft in Richtung des oberen Bildschirmrandes, wodurch die Alarmansicht nach oben gezogen wird.
UIGravityBehavior * gravityBehavior = [[UIGravityBehavior-Zuordnung] initWithItems: @ [self.alertView]]; [gravityBehavior setGravityDirection: CGVectorMake (0.0, -1.0)]; [self.animator addBehavior: gravityBehavior];
Interessant an dem Kollisionsverhalten ist, dass wir eine Grenze definieren, die außerhalb des Bildschirms liegt.
UICollisionBehavior * collisionBehavior = [[UICollisionBehavior-Zuordnung] initWithItems: @ [self.alertView]]; [collisionBehavior addBoundaryWithIdentifier: @ "alertCollisionBoundary" fromPoint: CGPointMake (self.initialAlertViewFrame.origin.x, self.initialAlertViewFrame.origin.y - 10.0) anPoint: CGPointMake (self.initialAlertViewFrame.origin.x. self.initialAlertViewFrame.origin.y - 10.0)]; [self.animator addBehavior: collisionBehavior];
Wir benötigen auch ein dynamisches Elementverhalten, um die Elastizität der Kollision einzustellen. Das Ergebnis ist, dass die Warnmeldungsansicht ein wenig abprallt, wenn sie mit der Off-Screen-Grenze kollidiert.
UIDynamicItemBehavior * itemBehavior = [[UIDynamicItemBehavior-Zuordnung] initWithItems: @ [self.alertView]]; itemBehavior.elasticity = 0,4; [self.animator addBehavior: itemBehavior];
Wir müssen auch die Hintergrundansicht wieder transparent machen. Wir tun dies, indem wir die Hintergrundansicht einstellen Alpha Eigentum an 0,0 in einem Animationsblock.
[UIView animateWithDuration: 2.0 Animationen: ^ [self.backgroundView setAlpha: 0.0]; ];
Führen Sie Ihre Anwendung erneut aus, um das Ergebnis anzuzeigen.
Obwohl die Warnmeldungsansicht auf Benutzerinteraktion reagiert, wissen wir derzeit nicht, welche Schaltfläche der Benutzer betätigt hat. Darauf werden wir uns in diesem Abschnitt konzentrieren.
Wie bei der Menükomponente werden wir Blöcke verwenden, um dieses Problem zu lösen. Blöcke bieten eine elegante Lösung und sind oft einfacher zu verwenden als ein Delegatenprotokoll.
Wir beginnen mit der Aktualisierung der Öffentlichkeit showAlertView Methode. Die Methode muss einen Beendigungshandler akzeptieren, den die Warnmeldungsansicht aufruft, wenn der Benutzer auf eine der Schaltflächen tippt. Im AlertComponent.h, Aktualisieren Sie die Erklärung der showAlertView Methode von:
- (void) showAlertView;
zu:
- (void) showAlertViewWithSelectionHandler: (void (^) (NSInteger buttonIndex, NSString * buttonTitle)) -Handler;
Der Completion-Handler akzeptiert zwei Parameter, den Typ index NSInteger, und den Titel des Typs NSString, der Schaltfläche, die der Benutzer angetippt hat. Wenn wir den Beendigungshandler aufrufen möchten, wenn der Benutzer auf eine Schaltfläche der Warnmeldungsansicht tippt, müssen wir einen Verweis auf den Beendigungshandler behalten. Dies bedeutet, dass wir eine Eigenschaft für den Completion-Handler deklarieren müssen. Wir machen das in der privaten Klassenerweiterung in AlertComponent.m.
@Interface AlertComponent ()… @Eigenschaft (nicht atomar, stark) void (^ selectionHandler) (NSInteger, NSString *);… @end
Immer noch in AlertComponent.m, Aktualisieren Sie die Methodenbeschreibung wie in der Header-Datei vor einem Moment und speichern Sie den Completion-Handler im selectionHandler Eigentum, das wir gerade deklariert haben.
- (void) showAlertViewWithSelectionHandler: (void (^) (NSInteger, NSString *)) Handler self.selectionHandler = Handler;…
Das letzte Teil des Puzzles ruft den Completion-Handler in auf handleButtonTap:, Tag und Titel der Schaltfläche übergeben.
- (void) handleButtonTap: (UIButton *) Sender // Ruft den Auswahlhandler auf. self.selectionHandler (sender.tag, sender.titleLabel.text);…
Die AlertComponent ist abgeschlossen. Es ist Zeit alles zu testen. Geh zurück zu ViewController.m und aktualisieren Sie die Aktion showAlertView: wie unten gezeigt. Wie Sie sehen, rufen wir das Neue auf showAlertViewWithSelectionHandler: Methode und übergeben Sie einen Block, der aufgerufen wird, wenn der Benutzer eine Schaltfläche in der Alert-Ansicht antippt.
- (IBAction) showAlertView: (id) Sender [self.alertComponent showAlertViewWithSelectionHandler: ^ (NSInteger buttonIndex, NSString * buttonTitle) NSLog (@ "% ld,% @", (long) buttonIndex, buttonTitle); ];
Das ist es. Führen Sie Ihre Anwendung erneut aus und überprüfen Sie die Xcode-Konsole, um das Ergebnis unserer Arbeit zu sehen.
UIKit Dynamics wurde erstmals in iOS 7 eingeführt und kann Ihnen helfen, realistische Animationen schnell zu erstellen. Diese kurze Serie hat gezeigt, dass die Nutzung von UIKit Dynamics in Ihren Projekten nicht schwierig ist und Sie kein Experte für Mathematik oder Physik sein müssen.
Beachten Sie, dass UIKit Dynamics hauptsächlich für die Verwendung in auf Ansichten basierenden Anwendungen vorgesehen ist. Wenn Sie nach einer ähnlichen Lösung für Spiele suchen, empfehle ich einen Blick auf das Sprite Kit von Apple, das auf die Spieleentwicklung abzielt.
