Added first basic implementation of nutella.location

Author: gianluca-venturini

Common/NutellaConfigDelegate.swift

@@ -0,0 +1,17 @@
+//
+//  NutellaConfigDelegate.swift
+//  
+//
+//  Created by Gianluca Venturini on 24/01/15.
+//
+//
+
+import Foundation
+
+@objc protocol NutellaConfigDelegate {
+    var runId: String { get }
+    var componentId: String { get }
+    var resourceId: String? { get }
+}
+
+

Common/NutellaDelegate.swift

@@ -12,30 +12,4 @@ import Foundation
     This protocol allows client to control the asynchronous callbacks.
 */
 @objc public protocol NutellaDelegate {
-    
-    /**
-        Called when a message is received and is not part of publish/subscriber communication.
-    
-        :param: channel The name of the Nutella chennal on which the message is received.
-        :param: message The message.
-        :param: from The actor name of the client that sent the message.
-    */
-    optional func messageReceived(channel: String, message: AnyObject, from: String)
-    
-    /**
-        A response to a previos request is received.
-    
-        :param: channelName The Nutella channel on which the message is received.
-        :param: requestName The optional name of request.
-        :param: response The dictionary/array/string containing the JSON representation.
-    */
-    optional func responseReceived(channelName: String, requestName: String?, response: AnyObject)
-    
-    /**
-        A request is received on a Nutella channel that was previously handled (with the handleRequest).
-    
-        :param: channelName The name of the Nutella chennal on which the request is received.
-        :param: request The dictionary/array/string containing the JSON representation of the request.
-    */
-    optional func requestReceived(channelName: String, request: AnyObject) -> AnyObject?
 }

Common/NutellaLocation.swift

@@ -0,0 +1,139 @@
+//
+//  NutellaLocation.swift
+//  
+//
+//  Created by Gianluca Venturini on 24/01/15.
+//
+//
+
+import Foundation
+import CoreLocation
+
+public class NutellaLocation: NSObject, NutellaNetDelegate, CLLocationManagerDelegate {
+    
+    var _configDelegate: NutellaConfigDelegate?
+    var configDelegate: NutellaConfigDelegate? {
+        get {
+            return _configDelegate
+        }
+        
+        set(delegate) {
+            _configDelegate = delegate
+            self.net.configDelegate = delegate
+        }
+    }
+    
+    var regions = [CLBeaconRegion]()
+    
+    let locationManager = CLLocationManager()
+    
+    let net: NutellaNet
+    
+    init(locationServer: String) {
+        
+        // Initialize nutella net instance
+        net = NutellaNet(host: locationServer, clientId: nil)
+        
+        super.init()
+        
+        println("Location initialization")
+        
+        net.delegate = self
+        
+        // Request the authorization to access the user location in every moment
+        locationManager.requestAlwaysAuthorization()
+        
+        locationManager.delegate = self
+    }
+    
+    public func startMonitoringRegions(uuids: [String]) {
+        for uuid in uuids {
+            var region: CLBeaconRegion = CLBeaconRegion(proximityUUID: NSUUID(UUIDString: uuid), identifier: uuid)
+            self.locationManager.startRangingBeaconsInRegion(region)
+            self.regions.append(region)
+        }
+    }
+    
+    public func startMonitorning() {
+        // Request the beacon cloud service for the uuids list
+        
+        self.net.asyncRequest("beacon/beacons/uuids", message: [], requestName: "uuids")
+    }
+    
+    public func stopMonitoring() {
+        for region in self.regions {
+            self.locationManager.stopMonitoringForRegion(region)
+        }
+    }
+    
+    public func locationManager(manager: CLLocationManager, didRangeBeacons: [AnyObject], inRegion: CLBeaconRegion) {
+        println("Monitor region")
+        for beacon in didRangeBeacons {
+            println(beacon.proximityUUID);
+            println(beacon.major);
+            println(beacon.minor);
+            println(beacon.proximity);
+        }
+    }
+    
+    
+    
+    // MARK: NutellaNetDelegate
+    
+    /*
+    public func messageReceived(channel: String, message: AnyObject, from: String) {
+        
+    }
+    */
+    
+    public func responseReceived(channelName: String, requestName: String?, response: AnyObject) {
+        if requestName == "uuids" {
+            if let r = response as? Dictionary<String, [String]> {
+                if let uuids = response["uuids"] as? [String] {
+                    self.startMonitoringRegions(uuids)
+                }
+            }
+        }
+    }
+    
+    /*
+    public func requestReceived(channelName: String, request: AnyObject) -> AnyObject? {
+        
+    }
+    */
+    
+    /*
+    
+    // MARK: ESTBeaconManagerDelegate
+    func beaconManager(manager: ESTBeaconManager, didRangeBeacons: [ESTBeacon], inRegion: ESTBeaconRegion) {
+        println("I've found \(didRangeBeacons.count) in range")
+        
+        for beacon in didRangeBeacons {
+            //println("----")
+            //println("Majour: \(beacon.major)")
+            //println("Minor: \(beacon.minor)")
+            //println("RSSI: \(beacon.rssi)")
+            //println("Distance: \(beacon.distance)")
+            //sprintln("Name: \(beacon.name)")
+            
+            if let name: String = beacon.name {
+                if beacon.distance.doubleValue > 0 {
+                    println("Name: \(beacon.name)")
+                    
+                    if let actorName = configDelegate?.actorName {
+                        var location: [String: AnyObject] = ["rid": actorName,
+                            "proximity": ["rid": name,
+                                "distance": beacon.distance.stringValue,
+                                "rssi": String(beacon.rssi)]]
+                        
+                        net.publish("location/update", message: location)
+                        println("Message published")
+                    }
+                }
+                
+            }
+        }
+    }
+
+    */
+}

Common/NutellaMain.swift

@@ -7,20 +7,33 @@
 //  jazzy -o doc -a "Gianluca Venturini" -g "https://github.com/nutella-framework/nutella_lib.swift.git" --skip-undocumented
 //
 
+#if DEBUG
+    let DEBUG = true
+#else
+    let DEBUG = false
+#endif
+
 import Foundation
 
 /**
     This is the main class that contains all the modules. It acts as a interface with the external world.
 */
-public class Nutella: NutellaNetDelegate {
-    var actorName: String
+public class Nutella: NutellaConfigDelegate {
+    var componentId: String
     var runId: String
+    public var resourceId: String?
+    
 
     /**
         Nutella network module, it enable the explicit interaction using MQTT protocol.
     */
     public var net: NutellaNet
 
+    /**
+        Nutella location module, it enable the detection of near beacon
+    */
+    public var location: NutellaLocation
+    
     /**
         The NutellaDelegateused in order to manage the notification about the status of Nutella.
     */
@@ -34,25 +47,34 @@ public class Nutella: NutellaNetDelegate {
         :param: runId The run id of the instance of the application.
         :param: clientId The client id used for techinical reason. Do not use it unless you have a valid motivation, the system will take care of generating it if left null
     */
-    public init(host: String, actorName: String, runId: String, clientId: String? = nil) {
-        self.actorName = actorName
+    public init(brokerHostname: String, runId: String, componentId: String) {
+        
+        self.componentId = componentId
         self.runId = runId
-        self.net = NutellaNet(host: host, clientId: clientId)
+        self.net = NutellaNet(host: brokerHostname, clientId: nil)
+        self.location = NutellaLocation(locationServer: brokerHostname)
 
-        self.net.delegate = self
+        if(DEBUG) {
+            println("[\(self)] init brokerHostname: \(brokerHostname) runId: \(runId) componentId: \(componentId)")
+        }
+        
+        self.net.configDelegate = self
+        self.location.configDelegate = self
     }
 
-    // MARK: NutellaNetDelegate
+    /**
+        Nutella newtork module delegate.
+    */
 
-    func messageReceived(channel: String, message: AnyObject, from: String) {
-        self.delegate?.messageReceived?(channel, message: message, from: from)
+    public var netDelegate: NutellaNetDelegate? {
+        get {
+            return self.net.delegate
+        }
+        set(delegate) {
+            self.net.delegate = delegate
+        }
     }
 
-    func responseReceived(channelName: String, requestName: String?, response: AnyObject) {
-        self.delegate?.responseReceived?(channelName, requestName: requestName, response: response)
-    }
 
-    func requestReceived(channelName: String, request: AnyObject) -> AnyObject? {
-        return self.delegate?.requestReceived?(channelName, request: request)
-    }
+    
 }