I'm a beginner in Swift and have a task to change the bottom sheet message when the process of the app doesn't work in three minutes. So, the message will change from "available" to "not available" if the process does not work.
I found code syntax like:
Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(fireTimer), userInfo: nil, repeats: true)
What I think:
var waktu = 0
Timer.scheduledTimer(withTimeInterval: 180.0, repeats: false) {
if waktu == 180 {
timer.invalidate()
//run the change message function
}
}
You can add observer on your property, so it will invalidate the timer when condition met, like so:
var waktu = 0 {
didSet {
if waktu == 180 {
timer.invalidate()
}
}
}
Your code creates a timer that will fire once in 3 minutes.
You’re using a variation on the timer method you list, scheduledTimer(withTimeInterval:repeats:block:)
That variant takes a closure instead of a selector. Then you’re using “trailing closure syntax” to provide that closure in braces outside the closing paren for the function call. That’s all good.
However, you define a variable waktu And give it a starting value of 0. You don’t show any code that will change that value, so your if statement if waktu == 180 will never evaluate to true and run your change message function. You need to update that if statement to determine if “the process of the app works”, whatever that means. (Presumably you have some definition of what your app working/not working means, and can update that if statement accordingly.)
Related
I have the following function setPath() which is called whenever the user taps on a button:
var loadSuccessfulTimer: Timer? = nil
func setPath(index: Int) {
self.loadSuccessfulTimer?.invalidate()
self.loadSuccessfulTimer = nil
print("setting path")
self.pause(releaseAudioSession: false)
self.reset(index: index)
let song = DataManager.getInstance().getQueueSong(index: index)
superpowered.setPath(song.url, true)
self.loadSuccessfulTimer = Timer.scheduledTimer(timeInterval: 0.2, target: self, selector: #selector(checkLoadSucess), userInfo: nil, repeats: true)
self.loadSuccessfulTimer!.fire()
}
#objc func checkLoadSucess() {
let status = self.superpowered.getLoadSuccessful()
print(status)
if(status != -1) {
self.loadSuccessfulTimer?.invalidate()
self.loadSuccessfulTimer = nil
if(status == 1){
print("success")
} else if(status == 2){
print("failed")
}
}
}
So whenever the setPath() function gets called, I want the timer to trigger every 0.2 seconds to check on a the value of status = self.superpowered.getLoadSuccessful(). The variable status would have values -1, 1, 2 I want to stop the timer when it's either 1 or 2. However, the following scenario is happening:
On the first tap it is working as expected and printing the following:
setting path
-1
-1
-1
-1
-1
-1
1
success
On the second tap the timer is only triggered one time (I guess it is from the .fire()) and the following is being printed:
setting path
-1
I tried to look up what might be going wrong, but all I could see was this is the recommended way of using a Timer.
Update
The second time setPath() is being called from DispatchQueue.global(), maybe this is related to the issue.
NSTimer requires run loop to work properly. The main queue has a run loop for free, for other queues you need to make sure run loop is available.
Make sure you read the documentation: https://developer.apple.com/documentation/foundation/nstimer
Also, remember to invalidate NSTimer object from the same run loop (thread) is has been created (scheduled) from.
In my main ViewController ViewDidLoad, I have the following code that calls the "tick" method every second.
self.timerTick = NSTimer.scheduledTimerWithTimeInterval(1.0, target: self, selector: #selector(ViewController.tick), userInfo: nil, repeats: true)
In the "tick" method, I check if a boolean value is true every second, and if true, I need to call a second method called SpeakText(), but I want to call the SpeakText() only once every 10 seconds. How do I do this?
Create a class property to keep track of the time since the last SpeakText. Update it each time tick is called, and reset it to 0 when SpeakText is called:
var secondsSinceSpeakText = 10
func tick() {
secondsSinceSpeakText += 1
if boolFlag && secondsSinceSpeakText >= 10 {
SpeakText()
secondsSinceSpeakText = 0
}
}
Note: Starting secondsSinceSpeakText with an initial value of 10 will allow the first SpeakText to happen immediately.
Just create another timer for speaktext when and when you call your speak text function fire it. If its under 10 seconds return false
I am trying to build a simple single view app which runs an infinite slide show of a selection of images with a time delay between each image change.
The code I wrote for this is below. I tried to put this into viewDidLoad and viewDidAppear but the screen remained blank which I guess is because the function never finishes due to the infinite loop.
I learnt a bit of Python before iOS and with tkinter, your code would go into the mainloop. But I am not quite sure how to do the equivalent in Swift
Could someone please explain why I am having this problem and how to do this in Swift. Thanks.
var arrayimages: [UIImage] = [UIImage(named: "charizard")!,UIImage(named:"Flying_Iron_Man")!]
var x: Int = 0
var images: UIImage
let arraycount = arrayimages.count
repeat{
images = arrayimages[(x % arraycount)]
sleep(1)
slideshow.image = images
x++
} while true
NB: slideshow is an image view outlet.
You're looking for NSTimer
let timer = NSTimer.scheduledTimerWithTimeInterval(
1.0, target: self, selector: Selector("doYourTask"),
userInfo: nil, repeats: true)
The first argument is how frequently you want the timer to fire, the second is what object is going to have the selector that gets called, the third is the selector name, the fourth is any extra information you want to pass as a parameter on the timer object, and the fifth is whether this should repeat.
If you want to stop the code at any future point:
timer.invalidate()
Create a repeating NSTimer:
var timer = NSTimer.scheduledTimerWithTimeInterval(2.0,
target: self,
selector: "animateFunction:",
userInfo: nil,
repeats: true)
Then write a function animateFunction:
func animateFunction(timer: NSTimer)
{
//Display the next image in your array, or loop back to the beginning
}
Edit: Updated for modern Swift versions: (>= Swift 5)
This has changed a lot since I posted this answer. NSTimer is now called Timer in Swift, and the syntax of the scheduledTimer() method has changed. The method signature is now scheduledTimer(timeInterval:target:selector:userInfo:repeats:)
Also, the way you create a selector has changed
So the call would be
var timer = Timer.scheduledTimer(timeInterval: 2.0,
target: self,
selector: #selector(animateFunction(_:)),
userInfo: nil,
repeats: true)
And the animateFunction might look like this:
func animateFunction(timer: Timer)
{
//Display the next image in your array, or loop back to the beginning
}
I recently took it upon myself to learn the Swift programming language and I love it. To help me learn, I have been working on a couple of simple apps using XCode 7. One of those apps is a flashlight and one of the features is a strobe light. I decided on using the NSTimer class to schedule the flashlight toggle functionality to be called at a set time interval, thus giving a nice strobe effect. My first crack at the timer code is as follows :-
NSTimer.scheduledTimerWithTimeInterval(0.5, target: self.torch, selector: "toggleTorch:", userInfo: false, repeats: true)
As you can see here, I am using my own custom made Torch object to handle the flash toggle functionality. I pass the torch object I have specified as an instance variable as the target param and then I call the following function in the Torch class, which I pass as selector :-
func toggleTorch(adjustingBrightness: Bool) -> Bool {
let device = AVCaptureDevice.defaultDeviceWithMediaType(AVMediaTypeVideo)
defer {
device.unlockForConfiguration()
}
guard device.hasTorch else {
return false
}
do {
try device.lockForConfiguration()
if !adjustingBrightness && device.torchMode == AVCaptureTorchMode.On {
device.torchMode = AVCaptureTorchMode.Off
}
else if !adjustingBrightness && device.torchMode == AVCaptureTorchMode.Off {
try device.setTorchModeOnWithLevel(brightnessLevel)
}
else if adjustingBrightness && device.torchMode == AVCaptureTorchMode.On {
try device.setTorchModeOnWithLevel(brightnessLevel)
}
} catch {
return false
}
return true
}
The problem I am encountering is that when the timer calls the toggleTorch method, it is passing the value of true as the parameter even though I have specifically passed false to the timer as the userInfo param.
So I scratch my head and think "Ah" let's try using a default value of false in the selector/method parameter and pass nil in the timer userInfo param. That way I can rely on the default value of false being invoked every time. So my new selector signature looks as follows:-
func toggleTorch(adjustingBrightness: Bool = false) -> Bool
And the timer that now calls it has changed to:-
NSTimer.scheduledTimerWithTimeInterval(0.5, target: self.torch, selector: "toggleTorch:", userInfo: nil, repeats: true)
However, despite the default parameter and no parameter passing going on via the timer, the value being passed through is still true. So I tinker some more and decide to see if using my ViewController as the target object will make a difference. I place a new selector in my ViewController like so:-
func toggleTorch() {
torch.toggleTorch(false)
}
I then update my timer to call this new method within the ViewController :-
NSTimer.scheduledTimerWithTimeInterval(0.5, target: self, selector: "toggleTorch", userInfo: nil, repeats: true)
'Hey Presto' it now works fine and the correct boolean value of false is being passed because I have passed the value myself. Why is this happening? For info, I'v been learning Swift for about three wks so am no expert
NSTimer does not pass the userInfo information as the parameter to the selector. It passes itself as the parameter so that you know which timer was called.
You should set it up as follows:
NSTimer.scheduledTimerWithTimeInterval(0.5, target: self.torch, selector: "strobeTimerFired:", userInfo: nil, repeats: true)
And have a method as follows in your Torch object:
func strobeTimerFired(timer: NSTimer) {
toggleTorch(false)
}
In this case you don't need to access the timer object in the strobeTimerFired method, but it's good practise to include it anyway (it can be skipped). You could add additional checking to ensure the timer that triggered the method is the one you expected for example.
If you did need to use the userInfo for something, (don't think you'd need it in this case), you could pass an object in the original scheduledTimerWithTimeInterval call as the userInfo parameter, and then you would access that in the strobeTimerFired method by accessing: timer.userInfo.
Newbie to IOS programming - learning through Swift. I'm writing a simple "slot machine / dice game".
I'm trying to show the user a flashing sequence of rolls before the "actual" roll appears.
func doFancyDiceRoll() {
for x in 1...100 {
Die1.image = PipsImg[RollOne()]
Die2.image = PipsImg[RollOne()]
Die3.image = PipsImg[RollOne()]
}
}
Die1, etc., are defined as generic UIImage views.
In any case, I'm not seeing the 100x iterations, just the images at the end of the loop. I'm assuming that either it redraws "too fast" or that IOS is trying to be smart, and only draws the last images so as to conserve resources.
I'll wildly guess that I need to either implement some kind of delay here, or, IOS needs to be told to explicitly draw out my images, and not try to outthink my intent.
For the delay, I've seen something about NSTimer, but nothing I saw seems to simply say something like "pause for .05" second, and the whole construct was unclear as they were ObjC examples/conversions.
(Note: I've simplified things here --- normally, I would store the value of RollOne() so I can use it later. I also would like to make an array (or collection?) like Die[1].image, but that is another question.)
========== Edit =======
OK, so I'm following up with more of my original code, merged in with that of #doctordoder so we can discuss a bit better. Hopefully that is kosher. (If this appended question is too long, please advise me on the best way to post a lengthy follow-up directly.)
import UIKit
class ViewController: UIViewController {
//( stripping out stuff unneeded for discussion )
// refers to same label below - works but kosher??
#IBOutlet var btnRoll_x: UIView
#IBAction func btnRoll(sender: AnyObject) {
triggerRoll()
}
var timer : NSTimer? = nil
var rolls : Int = 0
func triggerRoll() {
//hiding is bad UI, but until i know how to "disable & dim"
btnRoll_x.hidden = true
timer = NSTimer.scheduledTimerWithTimeInterval(0.10, target: self, selector: "doFancyDiceRoll", userInfo: nil, repeats: true);
}
func doFancyDiceRoll() {
Die1.image = PipsImg[randomInt(6)]
Die2.image = PipsImg[randomInt(6)]
Die3.image = PipsImg[randomInt(6)]
if (++rolls > 10)
{
timer?.invalidate()
timer = nil
rolls = 0 // DCB added this presumed missing line
btnRoll_x.hidden = false //again, need to do this better
}
}
}
Hopefully, my implementation of the code is what would have been intended. I made some minor adjustments for (hopeful) clarity.
Good news is I have working code. I have just enough understanding to get in place, but I'm fuzzy on some details.
Here is what I (think I) know...
We declare an NSTImer object, and a roll counter at the main level of the class. I note that in my original version, I had the roll counter scoped within the rolling function itself. Took me a while to understand why it could not live in the DiceRoll loop itself, but now I do. I'm going to express it poorly, but since the timer is going to call DiceRoll multiple instances, it needs to live outside the function.
The button btnRoll gets touched, and invokes triggerRoll().
To prevent the user from touching the button while we are in progress, which put us into a state where the roll counter never got to zero, I hide the button. (I'll figure how to properly put in in disabled state later.)
The timer is set. It fires every .1 second (within limits), and is set to repeat. (until .invalidate ). And it "calls" the function doFancyDiceRoll via the selector: attribute.
So, the big change as previously noted is that doFancy..Roll() no longer loops. It excites a single instance up updating the images. It checks the counter, and if we reach the limit, we kill the timer, which stops the timer (invalidate). (And I unhide the button, making it available again.)
So, a few things I am concerned/wondering about: I get the value of timers for other things that need to happen periodically (take health away every second, check a GPS position every 10 seconds, etc.). It's seems a odd construct to force a screen refresh.
Frankly, I would have expected to see see something like this:
func doFancyDiceRoll() {
for x in 1...100 {
Die1.image = PipsImg[RollOne()] // and 2 and 3 of course.....
VIewController.forceRedraw <<=== something like this, or maybe
ViewController.wait(.05) <<== this?? I dunno ;-)
}
}
instead we end up with about 20 extra lines or so. I'd be interested in knowing if there other approaches that could work keeping the loop intact.
Anyway, assuming this is the one true way to go, I guess my followup to this is how do I pass parameters, since this is not a "real" function call. Trying
selector: "doFancyDiceRoll(40)"
was not objected to by the IDE, but failed in execution.
I had exactly same problem back in days, entire loop is finished before the view is refreshed as #doctordoder mentioned. Solved with using NSTimer
var rollCount = 0
let arrayOfImages = ["image01", "image02", "image03"]
var timer = NSTimer.scheduledTimerWithTimeInterval(0.1, target: self, selector: Selector("doFancyDiceRoll"), userInfo: nil, repeats: true)
func doFancyDiceRoll() {
if rollCount == 100 {
timer.invalidate
rollCount = 0
{
else {
//get images from array arrayOfImages[rollCount]
rollCount++
}
}
there could be typos, since I have no Xcode right now.
I have basically the same answer as above :(, but I thought I'd post it anyway.
var timer : NSTimer? = nil
var rolls : Int = 0
func doFancyDiceRoll() {
timer = NSTimer.scheduledTimerWithTimeInterval(0.10, target: self, selector: "roll", userInfo: nil, repeats: true);
}
func roll() {
println("rolling")
Die1.image = PipsImg[RollOne()]
Die2.image = PipsImg[RollOne()]
Die3.image = PipsImg[RollOne()]
if (++rolls > 100)
{
timer?.invalidate()
timer = nil
}
}
Rather than NSTimer and invalidating, you can use dispatch_after to do the work for you.
func rollDice(howManyTimes: Int) {
die1.image = PipsImg[RollOne()]
die2.image = PipsImg[RollOne()]
die3.image = PipsImg[RollOne()]
if howManyTimes > 0 {
let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(Double(NSEC_PER_SEC) / 10.0))
dispatch_after(delayTime, dispatch_get_main_queue()) {
self.rollDice(howManyTimes - 1)
}
}
}
This will run the code for the number of times specified, delaying each time by 0.1 seconds. It works like this: First it sets the images on each die, then, if there are more iterations, it does a dispatch_after to call itself with rollDice(howManyTimes - 1)
With this, you don't need to maintain a NSTimer and it is pretty self contained.