                 return .ReachableViaWWAN
             }
         }
-        
+
         return .NotReachable
     }
-    
-    var currentReachabilityString: String {
+
+    public var currentReachabilityString: String {
         return "\(currentReachabilityStatus)"
     }
-    
+
     // MARK: - *** Initialisation methods ***
-    convenience init(hostname: String) {
+    public convenience init(hostname: String) {
         let ref = SCNetworkReachabilityCreateWithName(nil, (hostname as NSString).UTF8String).takeRetainedValue()
         self.init(reachabilityRef: ref)
     }
-    
-    class func reachabilityForInternetConnection() -> Reachability {
-        
+
+    public class func reachabilityForInternetConnection() -> Reachability {
+
         var zeroAddress = sockaddr_in(sin_len: __uint8_t(0), sin_family: sa_family_t(0), sin_port: in_port_t(0), sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
         zeroAddress.sin_len = UInt8(sizeofValue(zeroAddress))
         zeroAddress.sin_family = sa_family_t(AF_INET)
-        
+
         let ref = withUnsafePointer(&zeroAddress) {
             SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, UnsafePointer($0)).takeRetainedValue()
         }
         return Reachability(reachabilityRef: ref)
     }
-    
-    class func reachabilityForLocalWiFi() -> Reachability {
-        
+
+    public class func reachabilityForLocalWiFi() -> Reachability {
+
         var localWifiAddress: sockaddr_in = sockaddr_in(sin_len: __uint8_t(0), sin_family: sa_family_t(0), sin_port: in_port_t(0), sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
         localWifiAddress.sin_len = UInt8(sizeofValue(localWifiAddress))
         localWifiAddress.sin_family = sa_family_t(AF_INET)
-        
+
         // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
         let address: Int64 = 0xA9FE0000
         localWifiAddress.sin_addr.s_addr = in_addr_t(address.bigEndian)
-        
+
         let ref = withUnsafePointer(&localWifiAddress) {
             SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, UnsafePointer($0)).takeRetainedValue()
         }
         return Reachability(reachabilityRef: ref)
     }
-    
+
     // MARK: - *** Notifier methods ***
-    func startNotifier() -> Bool {
-        
+    public func startNotifier() -> Bool {
+
         reachabilityObject = self
         let reachability = self.reachabilityRef!
-        
+
         previousReachabilityFlags = reachabilityFlags
         if let timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, timer_queue) {
             dispatch_source_set_timer(timer, dispatch_walltime(nil, 0), 500 * NSEC_PER_MSEC, 100 * NSEC_PER_MSEC)
             dispatch_source_set_event_handler(timer, { [unowned self] in
                 self.timerFired()
-            })
-            
+                })
+
             dispatch_timer = timer
             dispatch_resume(timer)
-            
+
             return true
         } else {
             return false
         }
     }
-    
-    func stopNotifier() {
-        
+
+    public func stopNotifier() {
+
         reachabilityObject = nil
-        
+
         if let timer = dispatch_timer {
             dispatch_source_cancel(timer)
             dispatch_timer = nil
         }
-        
-    }
-    
+
+    }
+
     // MARK: - *** Connection test methods ***
-    func isReachable() -> Bool {
+    public func isReachable() -> Bool {
         return isReachableWithTest({ (flags: SCNetworkReachabilityFlags) -> (Bool) in
             return self.isReachableWithFlags(flags)
         })
     }
-    
-    func isReachableViaWWAN() -> Bool {
-        
+
+    public func isReachableViaWWAN() -> Bool {
+
         if isRunningOnDevice {
             return isReachableWithTest() { flags -> Bool in
                 // Check we're REACHABLE
                 if self.isReachable(flags) {
-                    
+
                     // Now, check we're on WWAN
                     if self.isOnWWAN(flags) {
                         return true

        let testcase = SCNetworkReachabilityFlags(kSCNetworkReachabilityFlagsConnectionRequired | kSCNetworkReachabilityFlagsTransientConnection)
        return flags & testcase == testcase
    }
    
    private var reachabilityFlags: SCNetworkReachabilityFlags {
        var flags: SCNetworkReachabilityFlags = 0
        let gotFlags = SCNetworkReachabilityGetFlags(reachabilityRef, &flags) != 0
        if gotFlags {
            return flags
        }
        
        return 0
    }
    
    override var description: String {
        
        var W: String
        if isRunningOnDevice {
            W = isOnWWAN(reachabilityFlags) ? "W" : "-"

            }
        }
    }

    // MARK: - *** Public properties ***

    public var whenReachable: NetworkReachable?
    public var whenUnreachable: NetworkUneachable?
    public var reachableOnWWAN: Bool

    public var currentReachabilityStatus: NetworkStatus {
        if isReachable() {
            if isReachableViaWiFi() {
                return .ReachableViaWiFi
