 	 */
 	public func discoverIncludedServices(includedServiceUUIDs: [CBUUID]?,
 		forService service: Service) -> Observable<[Service]> {
+        if let identifiers = includedServiceUUIDs, let services = service.includedServices?.filter({ identifiers.contains($0.UUID) })
+            where identifiers.count == services.count {
+            return ensureValidPeripheralState(Observable.just(services))
+        } else {
 			let observable = peripheral
 				.rx_didDiscoverIncludedServicesForService
 				.filter { $0.0 == service.service }

	 Immediately after that `.Complete` is emitted.
	 */
	public func discoverCharacteristics(identifiers: [CBUUID]?, service: Service) -> Observable<[Characteristic]> {
		let observable = peripheral
			.rx_didDiscoverCharacteristicsForService
			.filter { $0.0 == service.service }
			.flatMap { (cbService, error) -> Observable<[Characteristic]> in
				guard let rxCharacteristics = cbService.characteristics where error == nil else {
					return Observable.error(BluetoothError.CharacteristicsDiscoveryFailed(service, error))
				}
				let characteristics = rxCharacteristics.map { Characteristic(characteristic: $0, service: service) }
				guard let characteristicIdentifiers = identifiers else { return Observable.just(characteristics) }
                return Observable.just(characteristics.filter { characteristicIdentifiers.contains($0.UUID) })
            }
			.take(1)

		return Observable.create { observer in
			let disposable = self.ensureValidPeripheralState(observable).subscribe(observer)
			self.peripheral.discoverCharacteristics(identifiers, forService: service.service)
			return AnonymousDisposable {
				disposable.dispose()
			}
		}
	}

	/**

	 Immediately after that `.Complete` is emitted.
	 */
	public func discoverServices(serviceUUIDs: [CBUUID]?) -> Observable<[Service]> {
        if let identifiers = serviceUUIDs, let services = self.services?.filter({ identifiers.contains($0.UUID) })
            where identifiers.count == services.count {
            return ensureValidPeripheralState(Observable.just(services))
        } else {
            let observable = peripheral.rx_didDiscoverServices
			.flatMap {
				(_, error) -> Observable<[Service]> in
				if let cachedServices = self.services  {
					guard let identifiers = serviceUUIDs else { return Observable.just(cachedServices) }
					let uuids = cachedServices.map { $0.service.uuid }
					if Set(identifiers).isSubsetOf(Set(uuids)) {
