I'm a noob and have been learning from Apple's Playgrounds and random books doing tutorials. I'm working on a tutorial where it deals with a closure. I've seen this 'finish in' before in another tutorial but I don't know what it means precisely in layman terms.
What is it finishing, what is being finished, and inside of what? Or is there an idea of order of operation?
Here is the function where it was used:
func playSequence(index: Int, highlightTime: Double){
currentPlayer = .Computer
if index == inputs.count{
currentPlayer = .Human
return
}
var button: UIButton = buttonByColor(color: inputs[index])
var originalColor: UIColor? = button.backgroundColor
var highlightColor: UIColor = UIColor.white
UIView.animate(withDuration: highlightTime, delay: 0.0, options: [.curveLinear, .allowUserInteraction, .beginFromCurrentState], animations: {
button.backgroundColor = highlightColor
}, completion: {
finished in button.backgroundColor = originalColor
var newIndex: Int = index + 1
self.playSequence(index: newIndex, highlightTime: highlightTime)
})
}
finished is the parameter to the completion closure. The in is simply part of Swift's closure syntax.
The full signature of the UIView animate method is:
class func animate(withDuration duration: TimeInterval, delay: TimeInterval, options: UIViewAnimationOptions = [], animations: #escaping () -> Void, completion: ((Bool) -> Void)? = nil)
Note the Bool parameter to the completion closure. The finished in your code is the name given to that parameter.
An excerpt from the documentation about the completion parameter states:
This block has no return value and takes a single Boolean argument that indicates whether or not the animations actually finished before the completion handler was called.
A more typical way to write the code is as:
UIView.animate(withDuration: highlightTime, delay: 0.0, options: [.curveLinear, .allowUserInteraction, .beginFromCurrentState], animations: {
// animation code
}) { (finished) in
// completion code
}
This syntax makes it clearer than the syntax you are using. This is also using the "trailing closure" syntax.
Another way, closer to your usage, would be:
UIView.animate(withDuration: highlightTime, delay: 0.0, options: [.curveLinear, .allowUserInteraction, .beginFromCurrentState], animations: {
// animation code
}, completion: { (finished) in
// completion code
})
Your usage simply omits the parentheses around the parameter and it leaves out a line break. Adding those back in makes the code clearer.
Related
I wanted to create a general function in another swift file for hiding and showing UI objects with an animation. Here are both codes:
func hide(object: /*My UI Object*/, duration: Double, delay: Double) {
UIView.animate(withDuration: duration, delay: delay, options: [], animations: {
object.alpha = 0
} ,
completion: nil
)
}
func show(object: /*My UI Object*/, duration: Double, delay: Double) {
UIView.animate(withDuration: duration, delay: delay, options: [], animations: {
object.alpha = 1
} ,
completion: nil
)
}
I want to use this function of objects like: UILabel, UIButton, UIView, UITextField and so on. I couldn't find any way allowing multiple types as the "object" parameter.
I also tried setting the type of "object" to Any but this result in the error of "object" not having the member "alpha".
Setting the type to AnyObject result in the error of not being able to assign to property because of "object" being a "let" constant.
Thank you for your help!
You could type the parameter as UIView, since all the mentioned controls inherit from it.
func hide(object: UIView, duration: Double, delay: Double) {
UIView.animate(withDuration: duration, delay: delay, options: [], animations: {
object.alpha = 0
} ,
completion: nil
)
}
func show(object: UIView, duration: Double, delay: Double) {
UIView.animate(withDuration: duration, delay: delay, options: [], animations: {
object.alpha = 1
} ,
completion: nil
)
}
As all of these objects inherit from UIView you can use the type UIView
I am new to programming and am trying to learn Swift and Xcode with the help of the book "Swift for Beginners: Develop and Design". The book has been helpful so far and I have learned a lot already, however, it seems that Swift and Xcode have been updated since the book came out and that has led to some changes.
I am currently trying to code the sample memory game in Chapter 9, and I've run into a problem. Up until now, any differences caused by an updated version of Swift I have been able to figure out on my own, but this one is stumping me.
The code causing the error is this:
UIView.animateWithDuration(highlightTime,
delay: 0.0,
options: [.CurveLinear, .AllowUserInteraction, .BeginFromCurrentState],
animations: {
button.backgroundColor = highlightColor
}, completion: { finished in
button.backgroundColor = originalColor
var newIndex : Int = index + 1
self.playSequence(newIndex, highlightTime: highlightTime)
})
The error message is this:
Cannot invoke 'animateWithDuration' with an argument list of type '(Double, delay: Double, options: UIViewAnimationOptions, UIViewAnimationOptions, UIViewAnimationOptions, animations: () -> (), completion: (_) -> _)'
And the suggestion is this:
Expected an argument list of type '(NSTimeInterval, delay: NSTimeInterval, options: UIViewAnimationOptions, animations: () -> Void, completion: ((Bool) -> Void)?)'
Any help or insight would be appreciated.
Swift is picky with casting, so wrap the numbers in NSTimeInterval
UIView.animateWithDuration(NSTimeInterval(highlightTime),
delay: NSTimeInterval(0.0),
options: [.CurveLinear, .AllowUserInteraction, .BeginFromCurrentState],
animations: {
button.backgroundColor = highlightColor
}, completion: { finished in
button.backgroundColor = originalColor
var newIndex : Int = index + 1
self.playSequence(newIndex, highlightTime: highlightTime)
})
It seems like your highlightTime is defined as some other type not as Double, while defining the variable, simply define its type as,
let highlightTime: Double = 1.0
And, that should fix it.
Thanks for the feedback, everyone.
After some time, I was able to figure it out.
I had previously declared the highlightTime variable as "highlightTime: Double", with no value assigned. I changed it to "highlightTime: NSTimeInterval" and it is working now.
In a ViewController in my app I call transitionFromViewController but always get the following error when passing in a closure to the completion: argument.
Type '() -> Void' does not conform to protocol 'NilLiteralConvertible'
Here's the function call:
self.transitionFromViewController(
self.currentVC,
toViewController: newController,
duration: 0.2,
options: UIViewAnimationOptions.TransitionCrossDissolve,
nil,
completion: { finished in
fromViewController.removeFromParentViewController()
toViewController.didMoveToParentViewController(containerViewController)
toViewController.view.frame = containerViewController.view.bounds
})
According to code completion the method signature is as follows:
transitionFromViewController(fromViewController: UIViewController, toViewController: UIViewController, duration: NSTimeInterval, options: UIViewAnimationOptions, animations: () -> Void(), completion: ((Bool) -> Void)?)
You cannot pass nil to animations paramere () -> Void() declared as not optional
Pass empty closure if you want
self.transitionFromViewController(
self.currentVC,
toViewController: newController,
duration: 0.2,
options: UIViewAnimationOptions.TransitionCrossDissolve,
animations: { () -> Void in
},
completion: { finished in
fromViewController.removeFromParentViewController()
toViewController.didMoveToParentViewController(containerViewController)
toViewController.view.frame = containerViewController.view.bounds
})
I think following code should help you :
self.transitionFromViewController(fromViewController, toViewController: toViewController, duration: 0.1, options: UIViewAnimationOptions.CurveEaseInOut, animations: { () -> Void in
// code for animations
}) { (value: Bool) -> Void in
// code after completion
}
Where, // code for animations - code you want to execute during the block.
And, // code after completion - code you want to execute after the completion of the block.
I am trying to use animateWithDuration closure in Swift. I have declared the arguments in the closure as mentioned in the Apple Book for Swift. However, I am still getting an error.
Below is the code snippet:
if(!isRotating){
isRotating = true
var myImageTemp :UIImageView = self.myImage
UIView.animateWithDuration(0.5, delay: 1, options: UIViewAnimationCurve.EaseOut, animations:
{
() in myImageTemp.transform = CGAffineTransformMakeRotation(angle + M_PI_2)
},
completion:
{
(Bool finished) in self.pathAnimation() })
}
It gives me an error:
Could find an overload that accepts the supplied arguments.
And also it tells me:
Implicit use of self in closure.
Can anybody help me with this?
Just try:
UIView.animateWithDuration(0.2,
animations:
{
// your code.
},
completion:
{
(completed: Bool) in
// your code.
})
The (completed: Bool) in part indicates that the closure takes a Bool parameter labeled completed. If you are not interested in accessing the completed parameter, you can ignore it using an underscore.
UIView.animateWithDuration(0.2,
animations:
{
// your code.
},
completion:
{ _ in
// your code.
})
I'm having trouble making the blocks work on Swift. Here's an example that worked (without completion block):
UIView.animateWithDuration(0.07) {
self.someButton.alpha = 1
}
or alternatively without the trailing closure:
UIView.animateWithDuration(0.2, animations: {
self.someButton.alpha = 1
})
but once I try to add the completion block it just won't work:
UIView.animateWithDuration(0.2, animations: {
self.blurBg.alpha = 1
}, completion: {
self.blurBg.hidden = true
})
The autocomplete gives me completion: ((Bool) -> Void)? but not sure how to make it work. Also tried with trailing closure but got the same error:
! Could not find an overload for 'animateWithDuration that accepts the supplied arguments
Update for Swift 3 / 4:
// This is how I do regular animation blocks
UIView.animate(withDuration: 0.2) {
<#code#>
}
// Or with a completion block
UIView.animate(withDuration: 0.2, animations: {
<#code#>
}, completion: { _ in
<#code#>
})
I don't use the trailing closure for the completion block because I think it lacks clarity, but if you like it then you can see Trevor's answer below.
The completion parameter in animateWithDuration takes a block which takes one boolean parameter. In Swift, like in Obj-C blocks, you must specify the parameters that a closure takes:
UIView.animateWithDuration(0.2, animations: {
self.blurBg.alpha = 1
}, completion: {
(value: Bool) in
self.blurBg.hidden = true
})
The important part here is the (value: Bool) in. That tells the compiler that this closure takes a Bool labeled 'value' and returns Void.
For reference, if you wanted to write a closure that returned a Bool, the syntax would be
{(value: Bool) -> bool in
//your stuff
}
The completion is correct, the closure must accept a Bool parameter: (Bool) -> (). Try
UIView.animate(withDuration: 0.2, animations: {
self.blurBg.alpha = 1
}, completion: { finished in
self.blurBg.hidden = true
})
Underscore by itself alongside the in keyword will ignore the input
Swift 2
UIView.animateWithDuration(0.2, animations: {
self.blurBg.alpha = 1
}, completion: { _ in
self.blurBg.hidden = true
})
Swift 3, 4, 5
UIView.animate(withDuration: 0.2, animations: {
self.blurBg.alpha = 1
}, completion: { _ in
self.blurBg.isHidden = true
})
There is my solution above based on accepted answer above. It fades out a view and hiddes it once almost invisible.
Swift 2
func animateOut(view:UIView) {
UIView.animateWithDuration (0.25, delay: 0.0, options: UIViewAnimationOptions.CurveLinear ,animations: {
view.layer.opacity = 0.1
}, completion: { _ in
view.hidden = true
})
}
Swift 3, 4, 5
func animateOut(view: UIView) {
UIView.animate(withDuration: 0.25, delay: 0.0, options: UIView.AnimationOptions.curveLinear ,animations: {
view.layer.opacity = 0.1
}, completion: { _ in
view.isHidden = true
})
}
Here you go, this will compile
Swift 2
UIView.animateWithDuration(0.3, animations: {
self.blurBg.alpha = 1
}, completion: {(_) -> Void in
self.blurBg.hidden = true
})
Swift 3, 4, 5
UIView.animate(withDuration: 0.3, animations: {
self.blurBg.alpha = 1
}, completion: {(_) -> Void in
self.blurBg.isHidden = true
})
The reason I made the Bool area an underscore is because you not using that value, if you need it you can replace the (_) with (value : Bool)
Sometimes you want to throw this in a variable to animate in different ways depending on the situation. For that you need
let completionBlock : (Bool) -> () = { _ in
}
Or you could use the equally verbose:
let completionBlock = { (_:Bool) in
}
But in any case, you have have to indicate the Bool somewhere.
SWIFT 3.x + 4.x
I'd like to make an update and simplify the things.
Example below is implemented in any view it is hiding slowly and when it is completely transparent; removes it self from parent view
ok variable will always returns true with animation termination.
alpha = 1
UIView.animate(withDuration: 0.5, animations: {
self.alpha = 0
}) { (ok) in
print("Ended \(ok)")
self.removeFromSuperview()
}