Persisting application data - ios

Question

I'm fairly new to programming but at the moment. I can view my calculations in my stack on the second screen. Once the application project resets the stack is clear. My question is how I can keep the stack in the second view once the application has exited.
class ViewController: UIViewController {
var name = Array<String>()
#IBOutlet weak var labelDisplay: UILabel!
var calcEngine : CalculatorEngine?
override func prepareForSegue(segue: UIStoryboardSegue,
sender: AnyObject?) {
if segue.identifier == "pushToNextView"
{
let secondVC: SecondVCViewController = segue.destinationViewController as! SecondVCViewController
secondVC.data = self.name
}
}
second view
class SecondVCViewController: UIViewController {
#IBOutlet weak var textData: UITextView!
var data = Array <String>()
override func viewDidLoad() {
super.viewDidLoad()
for(var i = 0; i < self.data.endIndex; i++ ){
self.textData.text = self.textData.text! + self.data[i] + "\n"
}
// Do any additional setup after loading the view.
}

Answer 1

There are many tools available to you to persist data from an app. Choosing an appropriate one requires some understanding of your needs, or at least making a guess. Here's where I would start but keep an eye out in case my assumptions don't match your needs.
What type of data do you want to persist?
Presumably you want to store the array of Strings seen in var name = Array<String>() but maybe you have some other data type in mind.
When do you need to read/write it (do you need to worry about multiple systems trying to write at the same time, is loading the data going to be very expensive because it is very large, do you only need to load a small piece at a time, ...)?
Sounds like you're fine reading/writing all the data at once and only on app launch/termination. There could be a reasonable maximum size to this calculation history to total storage size is probably fairly small.
How long does it need to be persisted?
Calculation histories are usually nice to have but not a catastrophic loss if they go missing. It would be nice to keep this data around but the app will work without it. Depending on use it may or may not cost the user time and frustration if the data is deleted unexpectedly.
Who needs access to it (is it also show on a web site, should it sync to all of a user's devices, ...)?
It's probably enough to keep this history just on the local device.
So what should we do?
For a small amount of data loaded all at once and only used locally I would write this data to a file.
Since you're just working with an array of strings we can use a plist (https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/PropertyLists/AboutPropertyLists/AboutPropertyLists.html)
NSArray (note: not a Swift array) has arrayWithContentsOfURL: and writeToURL:atomically: which can be a convenient way to read and write plist compatible data.
Using a file means we need to decide where to store this file. Take a look at Where You Should Put Your App’s Files. In this case it seems reasonable to write this data to either Documents or Library/Caches depending on how you plan to use it.
With all that covered we could save this stack something like:
let array = names as NSArray
guard let cachesURL = NSFileManager.defaultManager().URLsForDirectory(.CachesDirectory, inDomains: .UserDomainMask).first else {
print("Unable to find Caches directory, cannot save file.")
return
}
let fileURL = cachesURL.URLByAppendingPathComponent("history.plist")
array.writeToURL(fileURL, atomically: false)
Reading the file is similar. You'll need the same URL so decide which component is responsible for deciding where to save/load this data and let it supply the URL to use. You'll also need to check if any saved history exists or not (note that arrayWithContentsOfURL: can return nil).
At some point you might find it useful to model this data as a more specific data type, perhaps defining your own struct to capture these operations. A custom type can't be automatically written to or read from a file so you'll need to do a little more work. Apple has a nice example of how you might use NSCoding to do that in their tutorials: https://developer.apple.com/library/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/Lesson10.html

Answer 2

Preserving and Restoring State
Feature you are looking for is called State Restoration. From the docs:
State preservation records the configuration of your app before it is
suspended so that the configuration can be restored on a subsequent
app launch.
How to tackle it:
Tag your view controllers for preservation. Assign restoration identifiers.
Restore view controllers at launch time. Encode and decode their state.
Topic is very broad but the docs explain it very well.

Answer 3

What you're trying to do is keep persistent data between launches of your application, right?
For that you should use core data, there are many useful recourses on the web to help you with that, heres a few helpful ones.
https://developer.apple.com/library/watchos/documentation/Cocoa/Conceptual/CoreData/index.html
https://www.raywenderlich.com/934/core-data-tutorial-for-ios-getting-started