Swift Accelerometer keeps crashing with ScrollView

Question

EDIT: I have simplified the code and added calls to NSThread.isMainThread(), to see if this was the problem. See more extensive edit below

I'm working on a fairly simple app to assist a professor in research over the summer. The app intends to determine word difficulty in sentences based on the accelerometer in the iPad.

Essentially, the user will tilt the iPad, thus creating a non-zero acceleration, and the text, which is situated in a UILabel placed within a scrollView will scroll accordingly.

This works excellently 99% of the time. In almost all of our tests, it works perfectly, it goes through the entire text without issue, and nothing bad happens. Very rarely however, it just breaks, throwing an error of EXC_BAD_ACCESS. I want to stress that on the rare occasions it does break, there is no apparent pattern, it sometimes happens in the middle of scrolling, near the end, or at the start.

Obviously I would like the app to be bug free, and this is a fairly major one which I just can't figure out, so any help you can give would be greatly appreciated.

Here is the total code for my ScrollingLabel Class (the bug always happens at the end of the startScrolling class).

import Foundation
import UIKit
import QuartzCore
import CoreMotion


public class ScrollingLabel {

//Instantiation of scroll view and label
var baseTextLabel:UILabel!
var baseScrollView:UIScrollView!
var frame:CGRect!


//Instantiation of accelerometer materials
var motionManager=CMMotionManager()
var queue=NSOperationQueue()
//To rectify the issue, I have changed this to:
//var queue=NSOperationQueue.mainQueue(), SEE EDIT BELOW

init(frame:CGRect) {
    /*Initializes the object by calling 3 private setup functions,
    each dealing one with a specific feature of the final label, and
    finally calling the scroll function to activate the accelerometer
    control*/
    setupFrame(frame)
    setupLabel()
    setupScroll()
    startScrolling()
}



private func startScrolling() {
    //The main accelerometer control of the label
    println(NSThread.isMainQueue) //THIS RETURNS TRUE

    //Allows the start orientation to become default
    var firstOrientation:Bool
    var timeElapsed:Double=0
    if letUserCreateDefaultOrientation {firstOrientation=true}
    else {firstOrientation=false}
    var standardAccel:Double=0

    //Begins taking updates from the accelerometer
    if motionManager.accelerometerAvailable{
        motionManager.accelerometerUpdateInterval=updateTimeInterval
        motionManager.startAccelerometerUpdatesToQueue(self.queue, withHandler: { (accelerometerData, error:NSError!) -> Void in
            println(NSThread.isMainQueue) //THIS RETURNS FALSE
            //Changes the input of acceleration depending on constant control variables

            var accel:Double
            if self.timerStarted {
                timeElapsed+=Double(self.updateTimeInterval)
            }
            if !self.upDownTilt {
                if self.invertTextMotion {accel = -accelerometerData.acceleration.y}
                else {accel = accelerometerData.acceleration.y}
            }
            else {
                if self.invertTextMotion {accel = -accelerometerData.acceleration.x}
                else {accel = accelerometerData.acceleration.x}
            }

            //Changes default acceleration if allowed
            if firstOrientation {
                standardAccel=accel
                firstOrientation=false
            }
            accel=accel-standardAccel

            //Sets the bounds of the label to prevent nil unwrapping
            var minXOffset:CGFloat=0
            var maxXOffset=self.baseScrollView.contentSize.width-self.baseScrollView.frame.size.width

            //If accel is greater than minimum, and label is not paused begin updates
            if !self.pauseScrolling && fabs(accel)>=self.minTiltRequired {

                //If the timer has not started, and accel is positive, begin the timer
                if !self.timerStarted&&accel<0{
                    self.stopwatch.start()
                    self.timerStarted=true
                }

                //Stores the data, and moves the scrollview depending on acceleration and constant speed
                if self.collectData {self.storeIndexAccelValues(accel,timeElapsed: timeElapsed)}
                var targetX:CGFloat=self.baseScrollView.contentOffset.x-(CGFloat(accel) * self.speed)
                if targetX>maxXOffset {targetX=maxXOffset;self.stopwatch.stop();self.doneWithText=true}
                else if targetX<minXOffset {targetX=minXOffset}
                self.baseScrollView.setContentOffset(CGPointMake(targetX,0),animated:true)
                if self.baseScrollView.contentOffset.x>minXOffset&&self.baseScrollView.contentOffset.x<maxXOffset {
                    if self.PRIVATEDEBUG {
                        println(self.baseScrollView.contentOffset)
                    }
                }
            }
        })
    }
}

When it does crash, it happens at the end of the startScrolling, when I set the content Offset to target X. If you need more information I am happy to provide it, but as the bug happens so rarely I don't have anything to say about specifically when it occurs or anything like that... it just seems random.

EDIT: I have simplified the code to just the pertinent parts, and added the two locations where I called NSThread.isMainQueue(). When called on the first line of startScrolling, .isMainQueue() returns TRUE, but then when called inside motionManager.startAccelerometerUpdatesToQueue it returns FALSE.

To rectify this, I have changed self.queue from just a NSOperationQueue() to NSOperationQueue.mainQueue(), and after making this switch, the second .isMainThread() call (the one inside motionManager.startAccelerometerUpdatesToQueue) now returns TRUE as we hoped for.

Answer 1

That's a lot of code. I don't see anything in the line that sets your content offset based on targetX.

A couple of possibilities are

baseScrollView is getting deallocated and is a zombie (unlikely since it looks like you have it defined as a regular (strong) instance variable.)

You're calling startScrolling from a background thread. All bets are off if you update UI objects from a background thread. You can check for that using NSThread.isMainThread(). Put that code in your startScrolling method, and if it returns false, that is your problem.

EDIT:

Based on your comments below in response to my answer you are calling startScrolling from a background thread.

That is indeed very likely the problem. Edit your post to show the code that is being called from a background thread, including the context. (Your "accelerometer update cycle" code).

You can't manipulate UIKit objects from a background thread, so you likely need to wrap the UIKit changes in your "accelerometer update cycle" code in a call to dispatch_async that runs on the main thread.

EDIT #2:

You've finally posted enough information so that we can help you. Your original code had you receiving acellerometer updates on a background queue. You were doing UIKit calls from that code. That is a no-no, and the results of doing it are undefined. They can range from updates taking forever, to not happening at all, to crashing.

Changing your code to use NSOperationQueue.mainQueue() as the queue that processes updates should fix the problem.

If you need to do time-consuming processing in your handler for accelerometer updates then you could continue to use the background queue you were using before, but wrap your UIKit calls in a dispatch_async:

dispatch_async(dispatch_get_main_queue())
{
  //UIKit code here
}

That way your time-consuming accelerometer update code doesn't bog down the main thread but UI updates are still done on the main thread.