JSON data contains arrays and dictionaries, much the same as you know from iOS, each of which contains further arrays and dictionaries, or strings, numbers and Boolean values, collectively referred to as objects.

One of the first things you need to do when you have obtained JSON data and converted it to a Dictionary, is print that dictionary using print(yourDictionary). You can then see, in the console, all the data that is available, and the structure in which it is stored. With a little familiarity with such data, you will soon be able to quickly inspect the dictionaries and arrays, in order to find the information you need.

With deeply nested arrays of dictionaries that contain dictionaries of arrays and yet more dictionaries, we run the danger of getting lost within the data. We will tidy up, and make safer, the code we will be writing, by creating a couple of typealias, which will also get Swift's type-checking magic working for us, ensuring that the data objects we pass around are really the objects we think they are.

Create a new Swift file, and call it SharedConstants.swift. Again, select both the phone and the WatchKit Extension targets. Now add the following code below the import statement:

typealias jsonDict  = [String: AnyObject]
typealias jsonArray = [AnyObject]

All we are doing here is adding two typealias declarations; jsonArray is an array of AnyObject, since we have no way of knowing in advance what exactly it will contain, and the jsonDict is a Dictionary of String keys and AnyObject values, which can also contain values of whatever type JSON throws at us.

Remember, although JSON has a limited number of types, it is still easy to make mistakes when handling JSON data—Swift considers a dictionary of [String: String] key-value pairs an entirely different creature to a dictionary of, say, [String: [String] key-value pairs. Using typealias gets type-checking working in our favor.

In iOS 9, Apple introduced App Transport Security (ATS), which helps and encourages developers to use secure Internet Protocols whenever possible. Unfortunately, at the time of writing, http://openweathermap.org/ does not offer secure https URL's, so we'll need to get around ATS, otherwise the web requests will be refused by the operating system.

To do this, perform the following steps:

Although it is possible to disable ATS on a per-domain basis, our app only uses the one server, and for the sake of simplicity we simply allow all non-secure http traffic, by adding this entry to the watch app target's property list.

So let's write some code that will download the data, using whatever connection the watchOS deems appropriate:

Create a new Swift file, call it SessionManager, and tick both the watch app and the phone app targets, then add the following code below the import statement:

let baseUrl = "http://api.openweathermap.org/data/2.5/group?units=metric" //1
let APIKey = "78c75588dfe58276a694af9c660edxxx" //2
let faveCity = 2643741 //3
let cities = [faveCity, 2193733, 1273294, 5128581, 2950159, 3435910] //4

These are the strings we will need to construct the URL of the data request. The comments in the code are as follows:

Now we'll create the actual SessionManager class that will be available from elsewhere in the app. Add the following code to SessionManager.swift:

class WeatherSessionManager {

    static let sharedInstance = WeatherSessionManager() //5
    private init() {}

    var lastRequestDate: NSDate? //6
}

The comments in the code are as follows:

We'll now write the method that will create the full request URL string from the baseURL, APIKey, and cities strings. Add the following method to the SessionManager class:

    func urlForCities(cityCodes: [Int]) -> String {
        var urlStr = baseUrl + "&APPID=" + APIKey + "&id=" //7
        for cityCode in cityCodes { //8
            urlStr += "(cityCode),"
        }
        return urlStr //9
    }

You will likely have many methods like this one in a larger, more complex app, so it is worth making doubly sure you understand what is going on. The comments in the code are as follows:

Now we get to the magic stuff. We will create and configure NSURLSession, and then call its session.dataTaskWithURL(url, completionHandler) method. This takes two arguments. The first is a straightforward NSURL, and the second is a function in the form of a closure.

Passing a function as an argument to another function may be new to you, and if it is, you're going to love it, I promise you. Being able to pass a function directly to another function means not having to maintain a direct relationship (such as a delegate) between two objects or not needing to bother with setting up notifications between them. Passing functions means, in effect:

doSomething(withSomeArg: ArgType, whenFinishedCallThisFunction: FunctionType)

dataTaskWithURL stipulates that the function it is to call, once it is finished, must have the type (NSData?, NSURLResponse?, NSError?) -> Void, and so we'll create a typealias for this first, which will make the code look less intimidating. Add the following declaration to SessionManager:

typealias DataTaskCompletionHandler =
    (NSData?, NSURLResponse?, NSError?) -> Void

Now we can write a fetchWeatherData method. This will in turn call session.dataTaskWithURL method from NSURL class, but where do we get the DataTaskCompletionHandler?

That will be passed by the calling method to fetchWeatherData as its single argument.
Add the following method to the SessionManager class:

    func fetchWeatherData(completionHandler: DataTaskCompletionHandler) {

}

If we had not created the type alias, this method signature would have looked like this:

    func fetchWeatherData(completionHandler: (NSData?, NSURLResponse?, NSError?) -> Void) {

}

This is a little harder to read, though it is a pattern you'll quickly get used to.

Now add the following code to the fetchWeatherData method:

    func fetchWeatherData(completionHandler: DataTaskCompletionHandler) {
        let sessionConfig = NSURLSessionConfiguration.defaultSessionConfiguration() //10
        if let date = lastRequestDate
            where NSDate().timeIntervalSinceDate(date)  < 10.0 {
            sessionConfig.requestCachePolicy = .ReturnCacheDataElseLoad
        } else {
            sessionConfig.requestCachePolicy = .UseProtocolCachePolicy
        }
        lastRequestDate = NSDate() //11
        let session = NSURLSession(configuration: sessionConfig) //12
        let apiCall = urlForCities(cities) //13
        if let url = NSURL(string: apiCall) {
            let task = session.dataTaskWithURL(url, completionHandler: completionHandler) //14
            task.resume() //15
        }
    }

The comments in the code are as follows: