     }
     
     // advertising
-    public func startAdvertising(name:String, uuids:[CBUUID]?) -> Future<Void> {
+    public func startAdvertising(peripheral:Wrapper, name:String, uuids:[CBUUID]?) -> Future<Void> {
         self.afterAdvertisingStartedPromise = Promise<Void>()
         var advertisementData : [NSObject:AnyObject] = [CBAdvertisementDataLocalNameKey:name]
         if let uuids = uuids {
             advertisementData[CBAdvertisementDataServiceUUIDsKey] = uuids
         }
-        self.peripheral.startAdvertising(advertisementData)
+        peripheral.startAdvertising(advertisementData)
         return self.afterAdvertisingStartedPromise.future
     }
     
-    public func startAdvertising(name:String) -> Future<Void> {
-        return self.startAdvertising(name, uuids:nil)
-    }
-    
-    public func startAdvertising(region:BeaconRegion) -> Future<Void> {
+    public func startAdvertising(peripheral:Wrapper, name:String) -> Future<Void> {
+        return self.startAdvertising(peripheral, name:name, uuids:nil)
+    }
+    
+    public func startAdvertising(peripheral:Wrapper, region:BeaconRegion) -> Future<Void> {
         self.afterAdvertisingStartedPromise = Promise<Void>()
-        self.peripheral.startAdvertising(region.peripheralDataWithMeasuredPower())
+        peripheral.startAdvertising(region.peripheralDataWithMeasuredPower())
         return self.afterAdvertisingStartedPromise.future
     }
     
-    public func stopAdvertising() -> Future<Void> {
+    public func stopAdvertising(peripheral:Wrapper) -> Future<Void> {
         self.afterAdvertsingStoppedPromise = Promise<Void>()
-        self.peripheral.stopAdvertising()
-        dispatch_async(self.peripheralQueue, {self.lookForAdvertisingToStop()})
+        peripheral.stopAdvertising()
+        PeripheralQueue.async{self.lookForAdvertisingToStop(peripheral)}
         return self.afterAdvertsingStoppedPromise.future
     }
     
     // services
-    public func addService(service:Wrapper.WrappedService) -> Future<Void> {
+    public func addService(peripheral:Wrapper, service:Wrapper.WrappedService) -> Future<Void> {
         self.afterSeriviceAddPromise = Promise<Void>()
-        if !self.peripheral.isAdvertising {
-            self.peripheral.addWrappedService(service)
+        if !peripheral.isAdvertising {
+            peripheral.addWrappedService(service)
             Logger.debug("PeripheralManagerImpl#addService:\(service.name), \(service.uuid)")
         } else {
             self.afterSeriviceAddPromise.failure(BCError.peripheralManagerAddServiceFailed)

public final class PeripheralManagerImpl<Wrapper where Wrapper:PeripheralManagerWrappable,
                                                       Wrapper.WrappedService:MutableServiceWrappable> {
    
    let peripheral : Wrapper
    
    private let WAIT_FOR_ADVERTISING_TO_STOP_POLLING_INTERVAL : Float = 0.25
    
    private var afterAdvertisingStartedPromise      = Promise<Void>()
    private var afterAdvertsingStoppedPromise       = Promise<Void>()
    private var afterPowerOnPromise                 = Promise<Void>()
    private var afterPowerOffPromise                = Promise<Void>()
    private var afterSeriviceAddPromise             = Promise<Void>()
    
    internal let peripheralQueue = dispatch_queue_create("com.gnos.us.peripheral.main", DISPATCH_QUEUE_SERIAL)
    
    private var _isPoweredOn : Bool = false
    

///////////////////////////////////////////
public final class PeripheralManager : NSObject, CBPeripheralManagerDelegate, PeripheralManagerWrappable {
    
    private var impl = PeripheralManagerImpl<PeripheralManager>()
    
    // PeripheralManagerImpl
    public var isAdvertising : Bool {
