एनीमेशन के साथ UIView छिपाएँ / दिखाएँ

Question

मेरा आसान लक्ष्य चेतन छिपना और कार्यों को दिखाना है।

Button.hidden = YES;

काफी सरल। हालाँकि, क्या यह संभव है कि यह केवल गायब होने के बजाय फीका हो? यह उस तरह से अव्यवसायिक दिखती है।

Answer 1

आईओएस 4 और बाद में, क्वार्ट्जकोर आयात करने की आवश्यकता के बिना यूआईईवाईवाई संक्रमण पद्धति का उपयोग करके ऐसा करने का एक तरीका है। आप बस कह सकते हैं:

उद्देश्य सी

[UIView transitionWithView:button
                  duration:0.4
                   options:UIViewAnimationOptionTransitionCrossDissolve
                animations:^{
                     button.hidden = YES;
                }
                completion:NULL];

तीव्र

UIView.transition(with: button, duration: 0.4, 
                  options: .transitionCrossDissolve, 
                  animations: {
                 button.hidden = false
              })

पिछला समाधान

मिखाइल का समाधान काम करेगा, लेकिन यह वास्तव में सबसे अच्छा तरीका नहीं है।

अल्फा लुप्त होती के साथ समस्या यह है कि कभी-कभी अलग-अलग अतिव्यापी दृश्य परतें अजीब लगती हैं जैसे वे बाहर निकलती हैं। कोर एनीमेशन का उपयोग करते हुए कुछ अन्य विकल्प हैं। सबसे पहले अपने ऐप में क्वार्ट्ज़कोर फ्रेमवर्क को शामिल करें और #import <QuartzCore/QuartzCore.h>अपने हेडर में जोड़ें । अब आप निम्न में से एक कर सकते हैं:

1) सेट करें button.layer.shouldRasterize = YES;और फिर अल्फा एनीमेशन कोड का उपयोग करें जिसे मिशैल ने अपने उत्तर में प्रदान किया। यह परतों को अजीब तरीके से सम्मिश्रण करने से रोकेगा, लेकिन इसमें थोड़ा सा प्रदर्शन दंड है, और यदि यह पिक्सेल सीमा पर बिल्कुल संरेखित नहीं है, तो बटन धुंधली दिख सकती है।

वैकल्पिक रूप से:

2) इसके बजाय फीका को चेतन करने के लिए निम्न कोड का उपयोग करें:

CATransition *animation = [CATransition animation];
animation.type = kCATransitionFade;
animation.duration = 0.4;
[button.layer addAnimation:animation forKey:nil];

button.hidden = YES;

इस दृष्टिकोण के बारे में अच्छी बात यह है कि आप बटन की किसी भी संपत्ति को पार कर सकते हैं, भले ही वे एनिमेटेबल न हों (जैसे टेक्स्ट या बटन की छवि), बस संक्रमण को सेट करें और फिर तुरंत बाद अपने गुणों को सेट करें।

Comments

@robmathers, मैं सिर्फ आपके कोड का परीक्षण करता हूं, दो कोड से ऊपर सिर्फ तभी काम करता है जब बटन। hidden = NO, for fade in situation; बटन खत्म होने पर फीका करने के लिए कोई एनीमेशन प्रभाव नहीं है। हां = हां;

— जेसन

IOS 12.0 में टूटने लगता है

— user3532505

आपको उस चीज़ के पर्यवेक्षक का उपयोग करना चाहिए जिसे आप transitionWithViewपैरामीटर के रूप में एनिमेट कर रहे हैं ताकि एक सफल फीका को सुनिश्चित किया जा सके।

— एलन

Answer 2

UIView एनिमेटेड गुण हैं:

- frame
- bounds
- center
- transform
- alpha
- backgroundColor
- contentStretch

इसमें वर्णन करें: एनिमेशन

isHidden उनमें से एक नहीं है, इसलिए जैसा कि मैंने देखा कि यह सबसे अच्छा तरीका है:

स्विफ्ट 4:

func setView(view: UIView, hidden: Bool) {
    UIView.transition(with: view, duration: 0.5, options: .transitionCrossDissolve, animations: {
        view.isHidden = hidden
    })
}

उद्देश्य सी:

- (void)setView:(UIView*)view hidden:(BOOL)hidden {
    [UIView transitionWithView:view duration:0.5 options:UIViewAnimationOptionTransitionCrossDissolve animations:^(void){
        [view setHidden:hidden];
    } completion:nil];
}

Comments

वास्तव में यह सरल और सबसे अच्छा उत्तर है

— इरशाद मोहम्मद

हालांकि यह सही ढंग से एनिमेट करता है, मैं जिस UISearchBar को प्रदर्शित करने की कोशिश कर रहा हूं वह तब तक गलत स्थान पर दिखाई देता है जब तक कि एनीमेशन पूरा नहीं हो जाता है और फिर तुरंत सही स्थिति में कूद जाता है। कोई उपाय? मैं इंटरफ़ेस बिल्डर और बाधाओं के साथ स्टोरीबोर्ड का उपयोग कर रहा हूं।

— ग्रेग हिल्स्टन

यह कोड काम नहीं करता है ... यह बिना एनिमेशन के राज्य को सीधे बदल देता है

— मिहिर मेहता

@ येया छिपाए जाने पर केवल फीका काम करते हैं = NO out फीका करने के लिए काम नहीं, छिपाया = YES

— जेसन

बहुत बढ़िया। 10x एक बहुत

— व्याचेस्लाव

Answer 3

फीका करने के लिए:

उद्देश्य सी

[UIView animateWithDuration:0.3 animations:^{
    button.alpha = 0;
} completion: ^(BOOL finished) {//creates a variable (BOOL) called "finished" that is set to *YES* when animation IS completed.
    button.hidden = finished;//if animation is finished ("finished" == *YES*), then hidden = "finished" ... (aka hidden = *YES*)
}];

स्विफ्ट 2

UIView.animateWithDuration(0.3, animations: {
    button.alpha = 0
}) { (finished) in
    button.hidden = finished
}

स्विफ्ट 3, 4, 5

UIView.animate(withDuration: 0.3, animations: {
    button.alpha = 0
}) { (finished) in
    button.isHidden = finished
}

में फीका करने के लिए:

उद्देश्य सी

button.alpha = 0;
button.hidden = NO;
[UIView animateWithDuration:0.3 animations:^{
    button.alpha = 1;
}];

स्विफ्ट 2

button.alpha = 0
button.hidden = false
UIView.animateWithDuration(0.3) {
    button.alpha = 1
}

स्विफ्ट 3, 4, 5

button.alpha = 0
button.isHidden = false
UIView.animate(withDuration: 0.3) {
    button.alpha = 1
}

Comments

छिपी हुई अवस्था के साथ / बाहर फीका का उपयोग करके मेरी समस्या हल हो गई

— एसीलिमा

किसी कारण से, छिपे हुए = YES के लिए एनिमेट करना मेरे लिए ठीक काम करता है, लेकिन छिपे हुए = NO के लिए एनिमेट करने से कुछ नहीं होता है, इसलिए अल्फा को ऐनिमेट करने और छिपी हुई संपत्ति को सेट करने का यह संयोजन सहायक था।

— अर्लोमेडिया

मैं सिर्फ एक डेमो लिखता हूं, लेकिन केवल छिपा हुआ = NO, कार्यों में फीका, अजीब

— जेसन

Answer 4

मैं इस 3 स्विफ्ट 3 एक्सटेंशन का उपयोग करता हूं :

extension UIView {

  func fadeIn(duration: TimeInterval = 0.5,
              delay: TimeInterval = 0.0,
              completion: @escaping ((Bool) -> Void) = {(finished: Bool) -> Void in }) {
    UIView.animate(withDuration: duration,
                   delay: delay,
                   options: UIViewAnimationOptions.curveEaseIn,
                   animations: {
      self.alpha = 1.0
    }, completion: completion)
  }

  func fadeOut(duration: TimeInterval = 0.5,
               delay: TimeInterval = 0.0,
               completion: @escaping (Bool) -> Void = {(finished: Bool) -> Void in }) {
    UIView.animate(withDuration: duration,
                   delay: delay,
                   options: UIViewAnimationOptions.curveEaseIn,
                   animations: {
      self.alpha = 0.0
    }, completion: completion)
  }
}

Answer 5

स्विफ्ट 3

func appearView() {
     self.myView.alpha = 0
     self.myView.isHidden = false

     UIView.animate(withDuration: 0.9, animations: {
         self.myView.alpha = 1
     }, completion: {
         finished in
         self.myView.isHidden = false
     })
}

Answer 6

तेजी से 4.2

विस्तार के साथ:

extension UIView {
func hideWithAnimation(hidden: Bool) {
        UIView.transition(with: self, duration: 0.5, options: .transitionCrossDissolve, animations: {
            self.isHidden = hidden
        })
    }
}

सरल विधि:

func setView(view: UIView, hidden: Bool) {
    UIView.transition(with: view, duration: 0.5, options: .transitionCrossDissolve, animations: {
        view.isHidden = hidden
    })
}

Comments

मैं इस एक के लिए देरी कैसे जोड़ सकता हूं?

— cvdogan

Answer 7

इस समाधान का उपयोग एक चिकनी फीडेओट और फीडेइन इफेक्ट्स के लिए करें

extension UIView {
    func fadeIn(duration: TimeInterval = 0.5, delay: TimeInterval = 0.0, completion: @escaping ((Bool) -> Void) = {(finished: Bool) -> Void in }) {
        self.alpha = 0.0

        UIView.animate(withDuration: duration, delay: delay, options: UIView.AnimationOptions.curveEaseIn, animations: {
            self.isHidden = false
            self.alpha = 1.0
        }, completion: completion)
    }

    func fadeOut(duration: TimeInterval = 0.5, delay: TimeInterval = 0.0, completion: @escaping (Bool) -> Void = {(finished: Bool) -> Void in }) {
        self.alpha = 1.0

        UIView.animate(withDuration: duration, delay: delay, options: UIView.AnimationOptions.curveEaseOut, animations: {
            self.isHidden = true
            self.alpha = 0.0
        }, completion: completion)
    }
}

उपयोग इस प्रकार है

uielement.fadeIn()
uielement.fadeOut()

धन्यवाद

Comments

fadeOutiOS 13 पर काम करता है केवल तभी जब मैं सेट की गई लाइनें हटाता हूं self.isHidden।

— माइक टवेर्न

Answer 8

मैंने UIViewइस उद्देश्य के लिए श्रेणी बनाई और विशेष रूप से थोड़ी अलग अवधारणा लागू की visibility:। मेरे समाधान का मुख्य अंतर यह है कि आप कॉल कर सकते हैं [view setVisible:NO animated:YES]और उसके ठीक बाद सिंक्रोनाइज़ कर सकते हैं[view visible] कर सही परिणाम प्राप्त कर सकते हैं। यह बहुत आसान है लेकिन बेहद उपयोगी है।

इसके अलावा, इसे "नकारात्मक बूलियन तर्क" का उपयोग करने से बचने की अनुमति है (देखें कोड पूरा, पृष्ठ 269, अधिक जानकारी के लिए सकारात्मक बूलियन चर नाम का उपयोग करें )।

तीव्र

UIView+Visibility.swift

import UIKit


private let UIViewVisibilityShowAnimationKey = "UIViewVisibilityShowAnimationKey"
private let UIViewVisibilityHideAnimationKey = "UIViewVisibilityHideAnimationKey"


private class UIViewAnimationDelegate: NSObject {
    weak var view: UIView?

    dynamic override func animationDidStop(animation: CAAnimation, finished: Bool) {
        guard let view = self.view where finished else {
            return
        }

        view.hidden = !view.visible
        view.removeVisibilityAnimations()
    }
}


extension UIView {

    private func removeVisibilityAnimations() {
        self.layer.removeAnimationForKey(UIViewVisibilityShowAnimationKey)
        self.layer.removeAnimationForKey(UIViewVisibilityHideAnimationKey)
    }

    var visible: Bool {
        get {
            return !self.hidden && self.layer.animationForKey(UIViewVisibilityHideAnimationKey) == nil
        }

        set {
            let visible = newValue

            guard self.visible != visible else {
                return
            }

            let animated = UIView.areAnimationsEnabled()

            self.removeVisibilityAnimations()

            guard animated else {
                self.hidden = !visible
                return
            }

            self.hidden = false

            let delegate = UIViewAnimationDelegate()
            delegate.view = self

            let animation = CABasicAnimation(keyPath: "opacity")
            animation.fromValue = visible ? 0.0 : 1.0
            animation.toValue = visible ? 1.0 : 0.0
            animation.fillMode = kCAFillModeForwards
            animation.removedOnCompletion = false
            animation.delegate = delegate

            self.layer.addAnimation(animation, forKey: visible ? UIViewVisibilityShowAnimationKey : UIViewVisibilityHideAnimationKey)
        }
    }

    func setVisible(visible: Bool, animated: Bool) {
        let wereAnimationsEnabled = UIView.areAnimationsEnabled()

        if wereAnimationsEnabled != animated {
            UIView.setAnimationsEnabled(animated)
            defer { UIView.setAnimationsEnabled(!animated) }
        }

        self.visible = visible
    }

}

उद्देश्य सी

UIView+Visibility.h

#import <UIKit/UIKit.h>

@interface UIView (Visibility)

- (BOOL)visible;
- (void)setVisible:(BOOL)visible;
- (void)setVisible:(BOOL)visible animated:(BOOL)animated;

@end

UIView+Visibility.m

#import "UIView+Visibility.h"

NSString *const UIViewVisibilityAnimationKeyShow = @"UIViewVisibilityAnimationKeyShow";
NSString *const UIViewVisibilityAnimationKeyHide = @"UIViewVisibilityAnimationKeyHide";

@implementation UIView (Visibility)

- (BOOL)visible
{
    if (self.hidden || [self.layer animationForKey:UIViewVisibilityAnimationKeyHide]) {
        return NO;
    }

    return YES;
}

- (void)setVisible:(BOOL)visible
{
    [self setVisible:visible animated:NO];
}

- (void)setVisible:(BOOL)visible animated:(BOOL)animated
{
    if (self.visible == visible) {
        return;
    }

    [self.layer removeAnimationForKey:UIViewVisibilityAnimationKeyShow];
    [self.layer removeAnimationForKey:UIViewVisibilityAnimationKeyHide];

    if (!animated) {
        self.alpha = 1.f;
        self.hidden = !visible;
        return;
    }

    self.hidden = NO;

    CGFloat fromAlpha = visible ? 0.f : 1.f;
    CGFloat toAlpha = visible ? 1.f : 0.f;
    NSString *animationKey = visible ? UIViewVisibilityAnimationKeyShow : UIViewVisibilityAnimationKeyHide;

    CABasicAnimation *animation = [CABasicAnimation animationWithKeyPath:@"opacity"];
    animation.duration = 0.25;
    animation.fromValue = @(fromAlpha);
    animation.toValue = @(toAlpha);
    animation.delegate = self;
    animation.removedOnCompletion = NO;
    animation.fillMode = kCAFillModeForwards;
    [self.layer addAnimation:animation forKey:animationKey];
}

#pragma mark - CAAnimationDelegate

- (void)animationDidStop:(CAAnimation *)animation finished:(BOOL)finished
{
    if ([[self.layer animationForKey:UIViewVisibilityAnimationKeyHide] isEqual:animation]) {
        self.hidden = YES;
    }
}

@end

Comments

@valentin शेरजिन स्विफ्ट संस्करण आ रहा है?

— जुआन बोरो

ज़रूर! मैंने स्विफ्ट संस्करण जोड़ा है।

— वैलेंटाइन शर्लिन

Answer 9

कुछ बदलावों के बाद स्विफ्ट 5 में @Umair अफ़ज़ल का काम ठीक है

 extension UIView {

func fadeIn(duration: TimeInterval = 0.5, delay: TimeInterval = 0.0, completion: @escaping ((Bool) -> Void) = {(finished: Bool) -> Void in }) {
    self.alpha = 0.0

    UIView.animate(withDuration: duration, delay: delay, options: UIView.AnimationOptions.curveEaseIn, animations: {
        self.isHidden = false
        self.alpha = 1.0
    }, completion: completion)
}

func fadeOut(duration: TimeInterval = 0.5, delay: TimeInterval = 0.0, completion: @escaping (Bool) -> Void = {(finished: Bool) -> Void in }) {
    self.alpha = 1.0

    UIView.animate(withDuration: duration, delay: delay, options: UIView.AnimationOptions.curveEaseIn, animations: {
        self.alpha = 0.0
    }) { (completed) in
        self.isHidden = true
        completion(true)
    }
  }
}

उपयोग के लिए

yourView.fadeOut()
yourView.fadeIn()

Comments

फीका पड़ने पर कुछ कठिन प्रभाव देते हुए, यहां

— धनु के

Answer 10

स्विफ्ट 4

extension UIView {

func fadeIn(duration: TimeInterval = 0.5, delay: TimeInterval = 0.0, completion: @escaping ((Bool) -> Void) = {(finished: Bool) -> Void in }) {
    self.alpha = 0.0

    UIView.animate(withDuration: duration, delay: delay, options: UIViewAnimationOptions.curveEaseIn, animations: {
        self.isHidden = false
        self.alpha = 1.0
    }, completion: completion)
}

func fadeOut(duration: TimeInterval = 0.5, delay: TimeInterval = 0.0, completion: @escaping (Bool) -> Void = {(finished: Bool) -> Void in }) {
    self.alpha = 1.0

    UIView.animate(withDuration: duration, delay: delay, options: UIViewAnimationOptions.curveEaseIn, animations: {
        self.alpha = 0.0
    }) { (completed) in
        self.isHidden = true
        completion(true)
    }
}
}

और इसका उपयोग करने के लिए, इन कार्यों को सरल कॉल करें जैसे:

yourView.fadeOut() // this will hide your view with animation
yourView.fadeIn() /// this will show your view with animation

Comments

आपने अभी @ MarkMckelvie का जवाब कॉपी किया है

— एशले मिल्स

एक अंतर है, वह दृश्य नहीं छिपा रहा था। और मुझे दृश्य को भी छिपाने की जरूरत थी। तो यह किया और इसे साझा करें।

— उमर अफज़ल

इसे कॉपी करने और अपने खुद के रूप में पारित करने के बजाय सिर्फ दूसरे उत्तर पर टिप्पणी क्यों करें?

— एशले मिल्स

Answer 11

isHidden एक तात्कालिक मूल्य है और आप इस पर एक एनीमेशन को प्रभावित नहीं कर सकते हैं, इसके बजाय आप अपने दृश्य को छिपाने के लिए अल्फा का उपयोग कर सकते हैं

UIView.transition(with: view, duration: 0.5, options: .transitionCrossDissolve, animations: {
        view.alpha = 0
    })

और दिखाने के लिए:

UIView.transition(with: view, duration: 0.5, options: .transitionCrossDissolve, animations: {
      view.alpha = 1
})

Answer 12

आप एनिमेटिक्स लाइब्रेरी का उपयोग करके इसे बहुत आसानी से कर सकते हैं :

//To hide button:
AlphaAnimator(0) ~> button

//to show button
AlphaAnimator(1) ~> button

Answer 13

func flipViews(fromView: UIView, toView: UIView) {

    toView.frame.origin.y = 0

    self.view.isUserInteractionEnabled = false

    UIView.transition(from: fromView, to: toView, duration: 0.5, options: .transitionFlipFromLeft, completion: { finished in            

        fromView.frame.origin.y = -900

        self.view.isUserInteractionEnabled = true

    })


}

Answer 14

आप यह कोशिश कर सकते हैं।

 func showView(objView:UIView){

    objView.alpha = 0.0
    UIView.animate(withDuration: 0.5, animations: {
        objView.alpha = 0.0
    }, completion: { (completeFadein: Bool) -> Void in
        objView.alpha = 1.0
        let transition = CATransition()
        transition.duration = 0.5
        transition.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
        transition.type = kCATransitionFade
        objView.layer.add(transition, forKey: nil)
    })
}

func HideView(objView:UIView){

    UIView.animate(withDuration: 0.5, animations: {
        objView.alpha = 1.0
    }, completion: { (completeFadein: Bool) -> Void in
        objView.alpha = 0.0
        let transition = CATransition()
        transition.duration = 0.5
        transition.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
        transition.type = kCATransitionFade
        objView.layer.add(transition, forKey: nil)
    })
}

और अपना दृश्य नाम पास करें

        showView(objView: self.viewSaveCard)
        HideView(objView: self.viewSaveCard)

Answer 15

यदि आपका दृष्टिकोण डिफ़ॉल्ट रूप से छिपने के लिए सेट है या आप छिपे हुए राज्य को बदलते हैं जो मुझे लगता है कि आपको कई मामलों में चाहिए, तो इस पृष्ठ में कोई भी दृष्टिकोण आपको FadeIn / FadeOut एनीमेशन दोनों नहीं देगा, यह केवल इन राज्यों में से एक को चेतन करेगा, कारण यह है कि आप UIView.animate को कॉल करने से पहले छिपे हुए राज्य को गलत पर सेट कर रहे हैं तरीके को जो अचानक दृश्यता का कारण बनेगा और यदि आप केवल अल्फ़ा को चेतन करते हैं तो ऑब्जेक्ट स्पेस अभी भी है लेकिन यह दिखाई नहीं देता है जिसके परिणामस्वरूप कुछ UI समस्याएँ होंगी।

इसलिए सबसे अच्छा तरीका यह है कि पहले जांच करें कि क्या दृश्य छिपा हुआ है या अल्फा को 0.0 पर सेट करें, इस तरह जब आप छिपे हुए राज्य को झूठे पर सेट करते हैं तो आपको अचानक दृश्यता नहीं दिखाई देगी।

func hideViewWithFade(_ view: UIView) {
    if view.isHidden {
        view.alpha = 0.0
    }

    view.isHidden = false

    UIView.animate(withDuration: 0.3, delay: 0.0, options: .transitionCrossDissolve, animations: {
        view.alpha = view.alpha == 1.0 ? 0.0 : 1.0
    }, completion: { _ in
        view.isHidden = !Bool(truncating: view.alpha as NSNumber)
    })
}

Comments

यह इस समस्या को हल करता है कि दूसरों ने इस बारे में पूछा है कि फ़ेडिन काम नहीं कर रहे थे। चतुर दृष्टिकोण।

— BooTooMany

Answer 16

UIView.transition (साथ :) फ़ंक्शन अच्छा और साफ है।

कई लोगों ने इसे पोस्ट किया है, लेकिन किसी ने भी इस बात पर ध्यान नहीं दिया है कि जब आप इसे चलाएंगे तो केवल एक दोष दिखाई देगा।

आप छिपी हुई संपत्ति को पूरी तरह से सच करने के लिए संक्रमण कर सकते हैं, जबकि जब आप इसे झूठे में बदलने का प्रयास करते हैं, तो दृश्य बिना किसी एनीमेशन के अचानक गायब हो जाएगा।

ऐसा इसलिए है क्योंकि यह एपीआई केवल एक दृश्य के भीतर काम करता है , जिसका अर्थ है कि जब आप दिखाने के लिए एक दृश्य को परिवर्तित करते हैं, तो वास्तव में यह तुरंत दिखाता है, केवल इसकी सामग्री धीरे-धीरे एनिमेटेड होती है।

जब आप इस दृश्य को छुपाने की कोशिश करते हैं, तो तुरंत ही छिप जाता है, एनीमेशन को इसकी सामग्री के लिए अर्थहीन बना देता है।

इसे हल करने के लिए, जब किसी दृश्य को छिपाया जाता है, तो संक्रमण लक्ष्य उस अभिभावक दृश्य का होना चाहिए, जिस दृश्य को आप छिपाना चाहते हैं।

func transitionView(_ view: UIView?, show: Bool, completion: BoolFunc? = nil) {
    guard let view = view, view.isHidden == show, let parent = view.superview else { return }

    let target: UIView = show ? view : parent
    UIView.transition(with: target, duration: 0.4, options: [.transitionCrossDissolve], animations: {
        view.isHidden = !show
    }, completion: completion)
}

Answer 17

स्विफ्ट 3 के लिए मेरा समाधान । इसलिए, मैंने फ़ंक्शन बनाया, जो सही क्रम में / अनहाइड दृश्य को छिपाता है (जब छुपाता है - अल्फ़ा को 0 पर सेट करता है और फिर सत्य पर निर्भर होता है; अनहाइडिंग - पहले दृश्य को प्रकट करें और फिर इसे 1 पर अल्फ़ा सेट करें):

func hide(_ hide: Bool) {
    let animations = hide ? { self.alpha = 0 } :
                            { self.isHidden = false }
    let completion: (Bool) -> Void = hide ? { _ in self.isHidden = true } :
                                            { _ in UIView.animate(withDuration: duration, animations: { self.alpha = 1 }) }
    UIView.animate(withDuration: duration, animations: animations, completion: completion)
}

Comments

completionब्लॉक में एक और एनीमेशन क्यों है जब hideझूठ है?

— जियोर्जियो

Answer 18

स्विफ्ट 4 संक्रमण

    UIView.transition(with: view, duration: 3, options: .transitionCurlDown,
                      animations: {
                        // Animations
                        view.isHidden = hidden
    },
                      completion: { finished in
                        // Compeleted
    })

यदि आप पुराने स्विफ्ट संस्करणों के लिए दृष्टिकोण का उपयोग करते हैं, तो आपको एक त्रुटि मिलेगी:

Cannot convert value of type '(_) -> ()' to expected argument type '(() -> Void)?'

उपयोगी संदर्भ ।

Comments

क्या यह ऑटोलॉययट के साथ काम करता है? समान कोड एनिमेट नहीं कर रहा है। isHiddenमूल्य तुरन्त प्रदान की गई है (यानी, तुरन्त छुपा / दृश्य दिखा रहा है)।

— क्रैशलॉट

Answer 19

यह कोड uinavigation कंट्रोलर में viewController को धक्का देने जैसा एक एनीमेशन देता है ...

CATransition *animation = [CATransition animation];
 animation.type = kCATransitionPush;
 animation.subtype = kCATransitionFromRight;
 animation.duration = 0.3;
 [_viewAccountName.layer addAnimation:animation forKey:nil];

 _viewAccountName.hidden = true;

पॉप एनीमेशन के लिए इसका इस्तेमाल किया ...

 CATransition *animation = [CATransition animation];
 animation.type = kCATransitionPush;
 animation.subtype = kCATransitionFromLeft;
 animation.duration = 0.3;
 [_viewAccountName.layer addAnimation:animation forKey:nil];

 _viewAccountName.hidden = false;

Answer 20

बाहर निकाले गए कुछ उत्तरों की कोशिश की, कुछ केवल एक स्थिति के लिए काम करते हैं, उनमें से कुछ को दो कार्यों को जोड़ने की आवश्यकता है।

विकल्प 1

कुछ नहीं करना है view.isHidden।

extension UIView {
    func animate(fadeIn: Bool, withDuration: TimeInterval = 1.0) {
        UIView.animate(withDuration: withDuration, delay: 0.0, options: .curveEaseInOut, animations: {
            self.alpha = fadeIn ? 1.0 : 0.0
        })
    }
}

फिर पास isFadeIn( trueया false)

view.animate(fadeIn: isFadeIn) 

विकल्प 2

किसी भी पैरामीटर को पास न करें। यह अंदर या बाहर के अनुसार लुप्त होती है isUserInteractionEnabled। यह स्थिति को आगे और पीछे बहुत अच्छी तरह से दिखाता है।

func animateFadeInOut(withDuration: TimeInterval = 1.0) {
    self.isUserInteractionEnabled = !self.isUserInteractionEnabled
    UIView.animate(withDuration: withDuration, delay: 0.0, options: .curveEaseInOut, animations: {
        self.alpha = self.isUserInteractionEnabled ? 1.0 : 0.0
    })
}

फिर तुम बुलाओ

yourView.animateFadeInOut()

क्यों self.isUserInteractionEnabled?

बदलने के लिए कोशिश की self.isUserInteractionEnabledद्वारा self.isHiddenसब पर, कोई भाग्य।

बस। मुझे कुछ समय लागत, आशा है कि यह किसी की मदद करता है।