Freigeben über

Einführung in iOS 7

  • Artikel

In diesem Artikel werden die wichtigsten neuen APIs behandelt, die in iOS 7 eingeführt wurden, einschließlich Ansichtscontrollerübergängen, Verbesserungen an UIView-Animationen, UIKit Dynamics und Text Kit. Außerdem werden einige der Änderungen an der Benutzeroberfläche sowie die neuen Multitaskingfunktionen behandelt.

iOS 7 ist ein wichtiges Update für iOS. Es führt ein völlig neues Benutzeroberflächendesign ein, das den Fokus auf Inhalte und nicht auf Anwendungschrom legt. Neben den visuellen Änderungen fügt iOS 7 eine Fülle neuer APIs hinzu, um umfassendere Interaktionen und Erfahrungen zu erstellen. Dieses Dokument untersucht die neuen Technologien, die mit iOS 7 eingeführt wurden, und dient als Ausgangspunkt für eine weitere Erkundung.

Verbesserungen der UIView-Animation

iOS 7 erweitert die Animationsunterstützung in UIKit, sodass Anwendungen Aufgaben ausführen können, die zuvor direkt in das Core Animation Framework fallen mussten. UIView Beispielsweise können jetzt Federanimationen sowie Keyframeanimationen ausgeführt werden, die zuvor CAKeyframeAnimation auf eine CALayerAnwendung angewendet wurden.

Federanimationen

UIView unterstützt jetzt das Animieren von Eigenschaftsänderungen mit einem Federeffekt. Um dies hinzuzufügen, rufen Sie entweder die Methode oder AnimateNotifyAsync die AnimateNotify Methode auf, und übergeben Sie Werte für das Federdämpfungsverhältnis und die anfängliche Federgeschwindigkeit, wie unten beschrieben:

  • springWithDampingRatio – Ein Wert zwischen 0 und 1, wobei die Schwingung für einen kleineren Wert steigt.
  • initialSpringVelocity – Die anfängliche Federgeschwindigkeit als Prozentsatz des gesamten Animationsabstands pro Sekunde.

Der folgende Code erzeugt einen Federeffekt, wenn sich die Mitte der Bildansicht ändert:

void AnimateWithSpring ()
{
    float springDampingRatio = 0.25f;
    float initialSpringVelocity = 1.0f;

    UIView.AnimateNotify (3.0, 0.0, springDampingRatio, initialSpringVelocity, 0, () => {

        imageView.Center = new CGPoint (imageView.Center.X, 400);

    }, null);
}

Dieser Federeffekt bewirkt, dass die Bildansicht scheinbar unzuspringen scheint, wenn sie ihre Animation an einer neuen Mittleren Position abschließt, wie unten dargestellt:

Dieser Frühlingseffekt bewirkt, dass die Bildansicht scheinbar unzuspringen scheint, wenn sie die Animation an einer neuen Mittleren Position abschließt.

Keyframeanimationen

Die UIView Klasse enthält nun die AnimateWithKeyframes Methode zum Erstellen von Keyframeanimationen in einem UIView. Diese Methode ähnelt anderen UIView Animationsmethoden, mit der Ausnahme, dass ein zusätzlicher NSAction Parameter übergeben wird, um die Keyframes einzuschließen. In den NSActionKeyframes werden durch Aufrufen UIView.AddKeyframeWithRelativeStartTimevon Keyframes hinzugefügt.

Der folgende Codeausschnitt erstellt beispielsweise eine Keyframeanimation, um die Mitte einer Ansicht zu animieren und die Ansicht zu drehen:

void AnimateViewWithKeyframes ()
{
    var initialTransform = imageView.Transform;
    var initialCeneter = imageView.Center;

    // can now use keyframes directly on UIView without needing to drop directly into Core Animation

    UIView.AnimateKeyframes (2.0, 0, UIViewKeyframeAnimationOptions.Autoreverse, () => {
        UIView.AddKeyframeWithRelativeStartTime (0.0, 0.5, () => {
            imageView.Center = new CGPoint (200, 200);
        });

        UIView.AddKeyframeWithRelativeStartTime (0.5, 0.5, () => {
            imageView.Transform = CGAffineTransform.MakeRotation ((float)Math.PI / 2);
        });
    }, (finished) => {
        imageView.Center = initialCeneter;
        imageView.Transform = initialTransform;

        AnimateWithSpring ();
    });
}

Die ersten beiden Parameter für die AddKeyframeWithRelativeStartTime Methode geben die Startzeit bzw. die Dauer des Keyframes als Prozentsatz der Gesamtlänge der Animation an. Das obige Beispiel führt dazu, dass die Bildansicht in der neuen Mitte über der ersten Sekunde animiert wird, gefolgt von einer Drehung von 90 Grad über die nächste Sekunde. Da die Animation als Option angibt UIViewKeyframeAnimationOptions.Autoreverse , werden auch beide Keyframes umgekehrt animiert. Schließlich werden die endgültigen Werte im Abschlusshandler auf den Anfangszustand festgelegt.

Die folgenden Screenshots veranschaulichen die kombinierte Animation durch die Keyframes:

Diese Screenshots veranschaulichen die kombinierte Animation durch die Keyframes

UIKit Dynamics

UIKit Dynamics ist ein neuer Satz von APIs in UIKit, mit dem Anwendungen animierte Interaktionen basierend auf der Physik erstellen können. UIKit Dynamics kapselt ein 2D-Physikmodul, um dies zu ermöglichen.

Die API ist in der Natur deklarativ. Sie deklarieren, wie sich die physikalischen Interaktionen verhalten, indem Sie Objekte – sogenannte Verhaltensweisen – erstellen, um physikalische Konzepte wie Schwerkraft, Kollisionen, Federn usw. auszudrücken. Anschließend fügen Sie das Verhalten(en) an ein anderes Objekt an, das als dynamischer Animator bezeichnet wird, der eine Ansicht kapselt. Der dynamische Animator kümmert sich um das Anwenden der deklarierten Physikalischen Verhaltensweisen auf dynamische Elemente – Elemente, die implementiert IUIDynamicItemwerden , z. B. eine UIView.

Es stehen mehrere verschiedene Grundtypenverhalten zur Verfügung, um komplexe Interaktionen auszulösen, darunter:

  • UIAttachmentBehavior – Fügt zwei dynamische Elemente an, sodass sie zusammen verschoben werden, oder fügt ein dynamisches Element an einen Anlagepunkt an.
  • UICollisionBehavior – Ermöglicht dynamischen Elementen die Teilnahme an Kollisionen.
  • UIDynamicItemBehavior – Gibt einen allgemeinen Satz von Eigenschaften an, die auf dynamische Elemente angewendet werden sollen, z. B. Flexibilität, Dichte und Reibung.
  • UIGravityBehavior - Wendet die Schwerkraft auf ein dynamisches Element an, wodurch Elemente in der Gravitationsrichtung beschleunigt werden.
  • UIPushBehavior – Wendet Kraft auf ein dynamisches Element an.
  • UISnapBehavior – Ermöglicht es einem dynamischen Element, eine Position mit einem Federeffekt anzudocken.

Obwohl es viele Grundtypen gibt, ist der allgemeine Prozess zum Hinzufügen physikalischer Interaktionen zu einer Ansicht mit UIKit Dynamics in allen Verhaltensweisen konsistent:

  1. Erstellen Sie einen dynamischen Animator.
  2. Verhalten(n) erstellen.
  3. Fügen Sie dem dynamischen Animator Verhaltensweisen hinzu.

Dynamics-Beispiel

Sehen wir uns ein Beispiel an, das die Schwerkraft und eine Kollisionsgrenze zu einer UIViewhinzufügt.

UIGravityBehavior

Das Hinzufügen der Schwerkraft zu einer Bildansicht folgt den oben beschriebenen 3 Schritten.

Wir arbeiten in der ViewDidLoad Methode für dieses Beispiel. Fügen Sie zunächst eine UIImageView Instanz wie folgt hinzu:

image = UIImage.FromFile ("monkeys.jpg");

imageView = new UIImageView (new CGRect (new CGPoint (View.Center.X - image.Size.Width / 2, 0), image.Size)) {
                    Image =  image
                }

View.AddSubview (imageView);

Dadurch wird eine Bildansicht zentriert am oberen Rand des Bildschirms erstellt. Um das Bild mit Schwerkraft zu "fallen" zu machen, erstellen Sie eine Instanz einer UIDynamicAnimator:

dynAnimator = new UIDynamicAnimator (this.View);

Dies UIDynamicAnimator übernimmt eine Instanz eines Verweises UIView oder einer UICollectionViewLayout, die die Elemente enthält, die pro angefügtem Verhalten(n) animiert werden.

Erstellen Sie als Nächstes eine UIGravityBehavior Instanz. Sie können ein oder mehrere Objekte übergeben, die die Implementierung von IUIDynamicItem:UIView

var gravity = new UIGravityBehavior (dynItems);

Das Verhalten wird an ein Array übergeben, das IUIDynamicItemin diesem Fall die einzelne UIImageView Instanz enthält, die wir animieren.

Fügen Sie schließlich dem dynamischen Animator das Verhalten hinzu:

dynAnimator.AddBehavior (gravity);

Dies führt dazu, dass das Bild mit der Schwerkraft nach unten animiert wird, wie unten dargestellt:

Die StartbildpositionDie Position des letzten Bilds

Da die Grenzen des Bildschirms nicht eingeschränkt werden, fällt die Bildansicht einfach vom unteren Rand ab. Um die Ansicht so einzuschränken, dass das Bild mit den Rändern des Bildschirms kollidiert, können wir eine UICollisionBehaviorhinzufügen. Dies wird im nächsten Abschnitt behandelt.

UICollisionBehavior

Wir beginnen mit dem Erstellen und UICollisionBehavior Hinzufügen eines Elements zum dynamischen Animator, genau wie für den UIGravityBehavior.

Ändern Sie den Code so, dass er folgendes UICollisionBehaviorenthält:

using (image = UIImage.FromFile ("monkeys.jpg")) {

    imageView = new UIImageView (new CGRect (new CGPoint (View.Center.X - image.Size.Width / 2, 0), image.Size)) {
        Image =  image
    };

    View.AddSubview (imageView);

    // 1. create the dynamic animator
    dynAnimator = new UIDynamicAnimator (this.View);

    // 2. create behavior(s)
    var gravity = new UIGravityBehavior (imageView);
    var collision = new UICollisionBehavior (imageView) {
        TranslatesReferenceBoundsIntoBoundary = true
    };

    // 3. add behaviors(s) to the dynamic animator
    dynAnimator.AddBehaviors (gravity, collision);
}

Die UICollisionBehavior Eigenschaft wird aufgerufen TranslatesReferenceBoundsIntoBoundry. Wenn Sie dies festlegen, true wird die Grenzen der Referenzansicht als Kollisionsgrenze verwendet.

Wenn das Bild nun mit Der Schwerkraft nach unten animiert, springt es etwas vom unteren Bildschirmrand ab, bevor es dort ruhen soll.

UIDynamicItemBehavior

Wir können das Verhalten der fallenden Bildansicht mit zusätzlichen Verhaltensweisen weiter steuern. Beispielsweise könnten wir einen UIDynamicItemBehavior hinzufügen, um die Flexibilität zu erhöhen, was dazu führt, dass die Bildansicht mehr springt, wenn sie mit dem unteren Bildschirmrand kollidiert.

Das Hinzufügen von a UIDynamicItemBehavior folgt den gleichen Schritten wie bei den anderen Verhaltensweisen. Erstellen Sie zuerst das Verhalten:

var dynBehavior = new UIDynamicItemBehavior (dynItems) {
    Elasticity = 0.7f
};

Fügen Sie dann dem dynamischen Animator das Verhalten hinzu:

dynAnimator.AddBehavior (dynBehavior);

Wenn dieses Verhalten vorhanden ist, springt die Bildansicht mehr, wenn sie mit der Grenze kollidiert.

Allgemeine Änderungen an der Benutzeroberfläche

Zusätzlich zu den neuen UIKit-APIs wie UIKit Dynamics, Controllerübergängen und erweiterten UIView-Animationen, die oben beschrieben werden, führt iOS 7 eine Vielzahl visueller Änderungen an der Benutzeroberfläche sowie zugehörige API-Änderungen für verschiedene Ansichten und Steuerelemente ein. Weitere Informationen finden Sie in der Übersicht über die iOS 7-Benutzeroberfläche.

Textkit

Text Kit ist eine neue API, die leistungsstarke Textlayout- und Renderingfunktionen bietet. Sie basiert auf dem Core Text-Framework auf niedriger Ebene, ist aber viel einfacher zu verwenden als Core Text.

Weitere Informationen finden Sie in unserem TextKit

Multitasking

iOS 7 ändert sich, wann und wie hintergrundarbeiten. Der Aufgabenabschluss in iOS 7 hält Anwendungen nicht mehr wach, wenn Aufgaben im Hintergrund ausgeführt werden, und Anwendungen werden für die Hintergrundverarbeitung auf nicht zusammenhängende Weise weckt. iOS 7 fügt außerdem drei neue APIs zum Aktualisieren von Anwendungen mit neuem Inhalt im Hintergrund hinzu:

  • Hintergrundabruf – Ermöglicht Anwendungen das Aktualisieren von Inhalten im Hintergrund in regelmäßigen Abständen.
  • Remotebenachrichtigungen – Ermöglicht Anwendungen das Aktualisieren von Inhalten beim Empfang einer Pushbenachrichtigung. Die Benachrichtigungen können entweder im Hintergrund angezeigt werden oder ein Banner auf dem Sperrbildschirm anzeigen.
  • Hintergrundübertragungsdienst – Ermöglicht das Hochladen und Herunterladen von Daten, z. B. große Dateien, ohne ein festes Zeitlimit.

Weitere Informationen zu den neuen Multitaskingfunktionen finden Sie in den iOS-Abschnitten des Xamarin Backgrounding Guide.

Zusammenfassung

In diesem Artikel werden mehrere wichtige Neueinfügungen zu iOS behandelt. Zunächst wird gezeigt, wie Sie benutzerdefinierte Übergänge zu Ansichtscontrollern hinzufügen. Anschließend wird gezeigt, wie Übergänge in Sammlungsansichten sowohl innerhalb eines Navigationscontrollers als auch interaktiv zwischen Sammlungsansichten verwendet werden. Als Nächstes werden mehrere Verbesserungen an UIView-Animationen eingeführt, die zeigen, wie Anwendungen UIKit für Dinge verwenden, die zuvor direkt für core Animation programmieren mussten. Schließlich wird die neue UIKit-Dynamics-API, die ein Physikmodul zu UIKit bringt, zusammen mit der Rich-Text-Unterstützung eingeführt, die jetzt im Text Kit-Framework verfügbar ist.