Einführung in iOS 7

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

iOS 7 ist ein wichtiges Update für iOS. Es führt ein völlig neues Design der Benutzeroberfläche ein, das den Fokus auf Inhalte und nicht auf Anwendungschrom legt. Neben den visuellen Änderungen fügt iOS 7 eine Vielzahl neuer APIs hinzu, um vielfältigere Interaktionen und Erfahrungen zu schaffen. Dieses Dokument untersucht die mit iOS 7 eingeführten neuen Technologien und dient als Ausgangspunkt für weitere Untersuchungen.

Verbesserungen der UIView-Animation

iOS 7 erweitert die Animationsunterstützung in UIKit, sodass Anwendungen Dinge ausführen können, die zuvor direkt in das Core Animation Framework integriert werden mussten. UIView Beispielsweise können jetzt Springanimationen sowie Keyframeanimationen ausgeführt werden, die zuvor auf eine CAKeyframeAnimationCALayerangewendet wurden.

Frühlingsanimationen

UIView unterstützt jetzt das Animieren von Eigenschaftsänderungen mit einem Federeffekt. Um dies hinzuzufügen, rufen Sie entweder die AnimateNotify -Methode oder AnimateNotifyAsync 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, bei dem die Schwingung für einen kleineren Wert zunimmt.
• initialSpringVelocity – Die anfängliche Federgeschwindigkeit als Prozentsatz der gesamten Animationsdistanz 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 Springeffekt bewirkt, dass die Bildansicht wie folgt abspringt, wenn die Animation an einer neuen mittleren Position abgeschlossen wird, wie unten dargestellt:

Keyframeanimationen

Die UIView -Klasse enthält jetzt die AnimateWithKeyframes Methode zum Erstellen von Keyframeanimationen für eine UIView. Diese Methode ähnelt anderen UIView Animationsmethoden, mit der Ausnahme, dass ein zusätzliches NSAction als Parameter übergeben wird, um die Keyframes einzuschließen. Innerhalb von NSActionwerden Keyframes hinzugefügt, indem aufgerufen UIView.AddKeyframeWithRelativeStartTimewird.

Mit dem folgenden Codeausschnitt wird beispielsweise eine Keyframeanimation erstellt, um die Mitte einer Ansicht zu animieren und die Ansicht zu rotieren:

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 der AddKeyframeWithRelativeStartTime -Methode geben die Startzeit und Dauer des Keyframes als Prozentsatz der Gesamtlänge der Animation an. Im obigen Beispiel wird die Bildansicht in der ersten Sekunde animiert, gefolgt von einer Drehung um 90 Grad in der nächsten Sekunde. Da die Animation als Option angibt UIViewKeyframeAnimationOptions.Autoreverse , animieren beide Keyframes auch umgekehrt. Schließlich werden die endgültigen Werte im Vervollständigungshandler auf den Anfangszustand festgelegt.

Die folgenden Screenshots veranschaulichen die kombinierte Animation über die Keyframes:

UIKit Dynamics

UIKit Dynamics ist eine neue Gruppe von APIs in UIKit, die es Anwendungen ermöglichen, animierte Interaktionen basierend auf der Physik zu erstellen. UIKit Dynamics kapselt eine 2D-Physik-Engine, um dies zu ermöglichen.

Die API ist deklarativer Natur. 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 die Verhaltensweisen an ein anderes Objekt an, das als dynamischer Animator bezeichnet wird und eine Sicht kapselt. Der dynamische Animator kümmert sich um das Anwenden des deklarierten physikalischen Verhaltens auf dynamische Elemente – Elemente, die implementierenIUIDynamicItem, z. B. .UIView

Es stehen verschiedene primitive Verhaltensweisen zur Verfügung, um komplexe Interaktionen auszulösen, einschließlich:

• UIAttachmentBehavior – Fügt zwei dynamische Elemente so an, dass 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. Elastizitä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 einem dynamischen Element das Einrasten an einer Position mit einem Federeffekt.

Obwohl es viele Grundtypen gibt, ist der allgemeine Prozess zum Hinzufügen von physikbasierten Interaktionen zu einer Ansicht mithilfe von UIKit Dynamics verhaltensübergreifend konsistent:

1. Erstellen Sie einen dynamischen Animator.
2. Erstellen sie Verhalten(en).
3. Fügen Sie dem dynamischen Animator Verhalten hinzu.

Dynamics-Beispiel

Sehen wir uns ein Beispiel an, das eine Schwerkraft und eine Kollisionsgrenze hinzufügt UIView.

UIGravityBehavior

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

Wir arbeiten in der ViewDidLoad -Methode für dieses Beispiel. Fügen Sie zunächst wie folgt eine UIImageView instance 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 erstellt, die am oberen Bildschirmrand zentriert ist. Um das Bild mit der Schwerkraft "fallen" zu lassen, erstellen Sie eine instance eines UIDynamicAnimator:

dynAnimator = new UIDynamicAnimator (this.View);

Nimmt UIDynamicAnimator eine instance eines Verweises UIView oder eines UICollectionViewLayoutan, das die Elemente enthält, die gemäß dem angefügten Verhalten(en) animiert werden.

Erstellen Sie als Nächstes eine UIGravityBehavior instance. Sie können ein oder mehrere Objekte übergeben, die implementierenIUIDynamicItem, z. B. :UIView

var gravity = new UIGravityBehavior (dynItems);

Das Verhalten wird ein Array von IUIDynamicItemübergeben, das in diesem Fall die einzelne UIImageView instance enthält, die wir animieren.

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

dynAnimator.AddBehavior (gravity);

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

Da die Grenzen des Bildschirms durch nichts eingeschränkt werden, fällt die Bildansicht einfach vom unteren Rand ab. Um die Ansicht so einzuschränken, dass das Bild mit den Bildschirmrändern kollidiert, können wir einen UICollisionBehaviorhinzufügen. Wir behandeln dies im nächsten Abschnitt.

UICollisionBehavior

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

Ändern Sie den Code, um folgendes einzuschließen UICollisionBehavior:

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);
}

Verfügt UICollisionBehavior über eine Eigenschaft namens TranslatesReferenceBoundsIntoBoundry. Wenn Sie dies auf festlegen, true werden die Grenzen der Verweisansicht als Kollisionsgrenze verwendet.

Wenn das Bild nun mit der Schwerkraft nach unten animiert, prallt es leicht vom unteren Bildschirmrand ab, bevor es sich dort zur Ruhe befindet.

UIDynamicItemBehavior

Wir können das Verhalten der fallenden Bildansicht mit zusätzlichen Verhaltensweisen weiter steuern. Beispielsweise könnten wir ein UIDynamicItemBehavior hinzufügen, um die Elastizität zu erhöhen, wodurch die Bildansicht stärker abspringt, wenn sie mit dem unteren Bildschirmrand kollidiert.

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

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

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

dynAnimator.AddBehavior (dynBehavior);

Wenn dieses Verhalten vorhanden ist, wird die Bildansicht mehr abprallen, 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 wurden, führt iOS 7 eine Vielzahl von visuellen Änderungen an der Benutzeroberfläche und 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. Es basiert auf dem Low-Level Core Text-Framework, ist aber viel einfacher zu verwenden als Core Text.

Weitere Informationen finden Sie in unserem TextKit.

Multitasking

iOS 7 ändert, wann und wie Hintergrundarbeiten ausgeführt werden. Aufgabenvervollständigung in iOS 7 hält Anwendungen nicht mehr wach, wenn Aufgaben im Hintergrund ausgeführt werden, und Anwendungen werden nicht zusammenhängend für die Hintergrundverarbeitung aktiviert. iOS 7 fügt außerdem drei neue APIs zum Aktualisieren von Anwendungen mit neuen Inhalten im Hintergrund hinzu:

• Hintergrundabruf: Anwendungen können Inhalte in regelmäßigen Abständen im Hintergrund aktualisieren.
• Remotebenachrichtigungen: Ermöglicht Anwendungen das Aktualisieren von Inhalten beim Empfang einer Pushbenachrichtigung. Die Benachrichtigungen können entweder unbeaufsichtigt sein 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 Leitfadens zur Xamarin-Hintergrundverwaltung.

Zusammenfassung

In diesem Artikel werden mehrere wichtige Neuerungen 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 verwendet werden, sowohl innerhalb eines Navigationscontrollers als auch interaktiv zwischen Sammlungsansichten. 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 programmiert werden mussten. Schließlich wird die neue UIKit Dynamics-API, die eine Physik-Engine in UIKit bringt, zusammen mit der Rich-Text-Unterstützung eingeführt, die jetzt im Text Kit-Framework verfügbar ist.

Ähnliche Themen

• Einführung in iOS 7 (Beispiel)
• Übersicht über die iOS 7-Benutzeroberfläche
• Hintergrundverarbeitung