             return cbCharacteristic?.properties.contains(CBCharacteristicProperties.notify) ?? false
         }
         
-        // If enabled is true then handler must not be nil
+        public var isNotifying : Bool {
+            return cbCharacteristic?.isNotifying ?? false
+        }
+        
+        // If enabled is true then handler must not be nil. If enabled is false then handler is ignored.
         public func notify(enabled: Bool, handler: ReadCompletionHandler?) -> PeripheralStatus {
             guard isNotifiable else { return .failure(.notNotifiable) }
 
             guard let characteristic = cbCharacteristic else { return .failure(.cbAttributeIsNil) }
 
-            if enabled && handler == nil {
-                return .failure(.handlerCannotBeNil)
-            }
-            
-            notificationHandler = handler
+            if enabled {
+                if handler == nil { return .failure(.handlerCannotBeNil) }
+                notificationHandler = handler
+            }
+            else {
+                notificationHandler = nil
+            }
 
             parent.parent.cbPeripheral.setNotifyValue(enabled, for: characteristic)
             
             return .success
         }
         
-        // The Central Manager will call this method when the asynchronous notification state update has completed.
+        // The Central Manager will call this method when the asynchronous notification state update
+        // has completed.
         func setNotificationStateCompleted(value: Bool, cbError: Error?) {
             if let error = cbError {
                 notificationHandler!(.failure(.characteristicNotifyError(self, cbError: error)))
+                notificationHandler = nil
+                return
             }
         }
     }

        public var isReadable : Bool {
            return cbCharacteristic?.properties.contains(CBCharacteristicProperties.read) ?? false
        }
        
        public func read(_ completionHandler: @escaping ReadCompletionHandler) -> PeripheralStatus {
            guard isReadable else { return .failure(.notReadable) }

            guard readCompletionHandler == nil else { return .failure(.readInProgress) }

            guard let characteristic = cbCharacteristic else { return .failure(.cbAttributeIsNil) }

            readCompletionHandler = completionHandler

            parent.parent.cbPeripheral.readValue(for: characteristic)

            return .success
        }
        
        // The Central Manager will call this method when an asynchronous read has completed.
        // The Central Manager will also call this method when a notification is received.
        //
        // I wish that there were a way to distingush read completion from notification.
        func readCompleted(_ value : Data?, cbError: Error?) {
            guard readCompletionHandler != nil || notificationHandler != nil else {
                fatalError("Read completed method invoked but both completion handlers are nil???")
            }
            
            let result: ReadResult
            if let error = cbError {
                result = .failure(.characteristicReadError(self, cbError: error))

                result = .success(value!)
            }

            // TODO: Reconsider whether or not the following logic works if a read is issued
            // by the central "at the same time" that a notification is being produced by the
            // peripheral. The assumption is that two events will produced. Consider that the
            // timing is such that the read completion handler receives the notification data
            // and the notification handler receives the read result.
            if let handler = readCompletionHandler {
                readCompletionHandler = nil // Do this first so that the handler can initiate a new read if desired.
                handler(result)
            }
            else if let handler = notificationHandler {
                handler(result)
            }
            else {
                fatalError("Read completed method invoked but both completion handlers are nil???")
            }
        }
        
