diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..8984d186
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,16 @@
+# Ignore maven built artifacts
+/*/**/.settings
+/*/**/.classpath
+/*/**/.project
+/*/**/target
+
+/*/.settings
+/*/.classpath
+/*/.project
+/*/target
+
+/.project
+/.settings
+
+# Ignore user specific files and folders of Xcode 
+/bluecove/src/main/c/intelbth/bluecove.xcodeproj/project.xcworkspace
diff --git a/bluecove/build-native-osx-debug.sh b/bluecove/build-native-osx-debug.sh
new file mode 100755
index 00000000..39b31a88
--- /dev/null
+++ b/bluecove/build-native-osx-debug.sh
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+# $Id$
+
+BUILD_ROOT=`pwd`
+
+cd ${BUILD_ROOT}/src/main/c/intelbth
+
+xcodebuild -configuration Debug
+BUILD_ERROR_CODE=$?
+
+cd ${BUILD_ROOT}
+
+if [[ ${BUILD_ERROR_CODE} != 0  ]] ; then
+  exit ${BUILD_ERROR_CODE}
+fi
+
+echo ---- Created library ----
+otool -fv ${BUILD_ROOT}/src/main/resources/libbluecove.jnilib
+echo Copy Library to ${BUILD_ROOT}/target/classes/
+cp ${BUILD_ROOT}/src/main/resources/libbluecove.jnilib ${BUILD_ROOT}/target/classes/
diff --git a/bluecove/pom.xml b/bluecove/pom.xml
index 92a9fbe8..4be67d7b 100644
--- a/bluecove/pom.xml
+++ b/bluecove/pom.xml
@@ -68,6 +68,7 @@
             <timezone>-5</timezone>
         </contributor>
 
+
         <contributor>
             <name>Sam Halliday</name>
             <email>sam.halliday@gmail.com</email>
@@ -76,6 +77,19 @@
             </roles>
         </contributor>
 
+        <contributor>
+            <name>Mathias Kühn</name>
+            <email>kuehn@synerva.de</email>
+            <organization>SYNERVA GmbH</organization>
+            <organizationUrl>http://www.synerva.de</organizationUrl>
+            <roles>
+                <role>developer</role>
+                <role>developer-OSX</role>
+                <role>developer-OSX-10.8</role>
+            </roles>
+            <timezone>+1</timezone>
+        </contributor>
+        
         <!--
         <contributor>
             <name></name>
diff --git a/bluecove/src/.gitignore b/bluecove/src/.gitignore
new file mode 100644
index 00000000..e5f95dab
--- /dev/null
+++ b/bluecove/src/.gitignore
@@ -0,0 +1,11 @@
+# Do not use resources folder
+resources/
+
+main/c/intelbth/bluecove.xcodeproj/xcuserdata
+main/c/intelbth/bluecove.xcodeproj/project.workspace
+main/c/intelbth/bluecove.xcodeproj/project.workspace/**
+
+main/c/intelbth/build/
+main/c/intelbth/DerivedData/
+
+main/c/intelbth/com_intel_bluetooth_*.h
\ No newline at end of file
diff --git a/bluecove/src/main/c/intelbth/OSXStack.h b/bluecove/src/main/c/intelbth/OSXStack.h
index b8fb07ca..59011556 100755
--- a/bluecove/src/main/c/intelbth/OSXStack.h
+++ b/bluecove/src/main/c/intelbth/OSXStack.h
@@ -40,12 +40,14 @@ class OSXStack {
 public:
 	OSXStack();
 	~OSXStack();
-
+    
 public:
 	pthread_mutex_t deviceInquiryInProcessMutex;
-	MPEventID deviceInquiryNotificationEvent;
-	MPEventID deviceInquiryBusyEvent;
-	MPEventID deviceInquiryFinishedEvent;
+    
+	dispatch_semaphore_t deviceInquiryNotificationEvent;
+	dispatch_semaphore_t deviceInquiryBusyEvent;
+	dispatch_semaphore_t deviceInquiryFinishedEvent;
+    
 	volatile BOOL deviceInquiryInProcess;
 	volatile BOOL deviceInquiryBusy;
 	volatile BOOL deviceInquiryTerminated;
@@ -60,7 +62,7 @@ class Runnable {
 public:
     long magic1b;
 	long magic2b;
-    char* name;
+    const char* name;
     int error;
 
     // Data passes and received from thread
@@ -69,8 +71,7 @@ class Runnable {
     int iData;
     long lData;
     bool bData;
-    jlong jlData;
-    void* pData[RUNNABLE_DATA_MAX];
+    const void* pData[RUNNABLE_DATA_MAX];
 
     long magic1e;
 	long magic2e;
@@ -118,4 +119,4 @@ class OSXJNIHelper{
 extern OSXStack* stack;
 extern jint localDeviceSupportedSoftwareVersion;
 
-#endif // __OSXSTACK_H__
\ No newline at end of file
+#endif // __OSXSTACK_H__
diff --git a/bluecove/src/main/c/intelbth/OSXStack.mm b/bluecove/src/main/c/intelbth/OSXStack.mm
old mode 100644
new mode 100755
index d494795b..48ceff17
--- a/bluecove/src/main/c/intelbth/OSXStack.mm
+++ b/bluecove/src/main/c/intelbth/OSXStack.mm
@@ -24,6 +24,10 @@
 
 #include "OSXStack.h"
 #include <pthread.h>
+#include <dispatch/dispatch.h>
+
+#import <IOBluetooth/IOBluetooth.h>
+
 
 #ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
 #import <IOBluetooth/objc/IOBluetoothHostController.h>
@@ -38,38 +42,44 @@
     deviceInquiryInProcess = FALSE;
     deviceInquiryBusy = FALSE;
     deviceInquiryTerminated = FALSE;
-
+    
     pthread_mutexattr_t   mta;
     // Create a default mutex attribute
     pthread_mutexattr_init(&mta);
     // If a thread attempts to relock a mutex that it has already locked, an error is returned.
     pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_ERRORCHECK);
     pthread_mutex_init(&deviceInquiryInProcessMutex, &mta);
-
-    MPCreateEvent(&deviceInquiryNotificationEvent);
-    MPCreateEvent(&deviceInquiryFinishedEvent);
-    MPCreateEvent(&deviceInquiryBusyEvent);
-
+    
+    deviceInquiryNotificationEvent = dispatch_semaphore_create(0);
+    deviceInquiryFinishedEvent = dispatch_semaphore_create(0);
+    deviceInquiryBusyEvent = dispatch_semaphore_create(0);
+    
+    //    dispatch_semaphore_wait(retrieveConnectedPeripheralsSema, DISPATCH_TIME_FOREVER);
+    //    dispatch_release(retrieveConnectedPeripheralsSema);
+    
     commPool = new ObjectPool(100, 1, TRUE);
 }
 
 OSXStack::~OSXStack() {
+    
     if (commPool != NULL) {
         delete commPool;
         commPool = NULL;
     }
-    MPSetEvent(deviceInquiryNotificationEvent, 0);
-    MPDeleteEvent(deviceInquiryNotificationEvent);
-    MPDeleteEvent(deviceInquiryFinishedEvent);
-    MPDeleteEvent(deviceInquiryBusyEvent);
+    
+    dispatch_semaphore_signal(deviceInquiryNotificationEvent);
+    
+    dispatch_release(deviceInquiryNotificationEvent);
+    dispatch_release(deviceInquiryFinishedEvent);
+    dispatch_release(deviceInquiryBusyEvent);
+    
     pthread_mutex_destroy(&deviceInquiryInProcessMutex);
 }
 
 BOOL OSXStack::deviceInquiryLock(JNIEnv* env) {
     if (deviceInquiryInProcess && deviceInquiryTerminated) {
         // Wait until it terminates
-        MPEventFlags flags;
-        MPWaitForEvent(deviceInquiryFinishedEvent, &flags, kDurationMillisecond * 1000 * 3);
+        dispatch_semaphore_wait(deviceInquiryFinishedEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 3));
     }
     if (deviceInquiryInProcess) {
         throwBluetoothStateException(env, cINQUIRY_RUNNING);
@@ -87,7 +97,7 @@
 BOOL OSXStack::deviceInquiryUnlock() {
     deviceInquiryInProcess = false;
     BOOL rc = (pthread_mutex_unlock(&deviceInquiryInProcessMutex) == 0);
-    MPSetEvent(deviceInquiryFinishedEvent, 0);
+    dispatch_semaphore_signal(deviceInquiryFinishedEvent);
     return rc;
 }
 
@@ -96,7 +106,7 @@
     magic2b = MAGIC_2;
     magic1e = MAGIC_1;
     magic2e = MAGIC_2;
-
+    
     name = "n/a";
     sData[0] = '\0';
     error = 0;
@@ -120,76 +130,97 @@ BOOL isRunnableCorrupted(Runnable* r) {
 
 // --- One Native Thread and RunLoop, An issue with the OS X BT implementation is all the calls need to come from the same thread.
 
+#ifdef USE_WORKER_THREAD
 CFRunLoopRef            mainRunLoop = NULL;
 CFRunLoopSourceRef      btOperationSource;
 
 typedef struct BTOperationParams {
     Runnable* runnable;
-};
+} BTOperationParams_t;
 
 void *oneNativeThreadMain(void *pThreadParams);
 
 void performBTOperationCallBack(void *info);
 pthread_mutex_t btOperationInProgress;
-MPEventID synchronousBTOperationCallComplete;
+dispatch_semaphore_t synchronousBTOperationCallComplete;
 
 typedef struct NativeThreadParams {
     JavaVM *vm;
-    MPEventID initializedNotificationEvent;
-};
+    dispatch_semaphore_t initializedNotificationEvent;
+} NativeThreadParams_t;
 
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+#else
 
+dispatch_queue_t        mainQueue = NULL;
+
+#endif
+
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+    
+#ifdef USE_WORKER_THREAD
+    
     pthread_t thread;
     NativeThreadParams threadParams;
     threadParams.vm = vm;
-    MPCreateEvent(&(threadParams.initializedNotificationEvent));
-
+    threadParams.initializedNotificationEvent = dispatch_semaphore_create(0);
+    
     // Starting the OS X init and run thread
     pthread_create(&thread, NULL, oneNativeThreadMain, (void*) &threadParams);
     // Test for race condition
     //sleep(3);
-
+    
     // wait until the OS X thread has initialized before returning
-    MPEventFlags flags;
-    OSStatus status = MPWaitForEvent(threadParams.initializedNotificationEvent, &flags, kDurationMillisecond * 1000 * 10);
-
+    OSStatus status = dispatch_semaphore_wait(threadParams.initializedNotificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 10));
+    
     // clean up
-    MPDeleteEvent(threadParams.initializedNotificationEvent);
-
+    dispatch_release(threadParams.initializedNotificationEvent);
+    
     if (status == kMPTimeoutErr) {
         return -1;
     }
-
+#else
+    mainQueue = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
+#endif
     return JNI_VERSION_1_2;
 }
 
 JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved) {
+    
+#ifdef USE_WORKER_THREAD
+    
     if (mainRunLoop != NULL) {
         CFRunLoopStop(mainRunLoop);
         mainRunLoop = NULL;
     }
+    
+#else
+    dispatch_release(mainQueue);
+#endif
+    
 }
 
-void *oneNativeThreadMain(void * pThreadParams) {
+#ifdef USE_WORKER_THREAD
 
+void *oneNativeThreadMain(void * pThreadParams) {
+    
     NativeThreadParams* threadParams = (NativeThreadParams*)pThreadParams;
-
+    
     JavaVMAttachArgs args;
     args.version = JNI_VERSION_1_2;
-    args.name = "OS X Bluetooth CFRunLoop";
+    args.name = (char *)"OS X Bluetooth CFRunLoop";
     args.group = NULL;
     JNIEnv  *env;
     threadParams->vm->AttachCurrentThreadAsDaemon((void**)&env, &args);
-
+    
     // setup OS X managed memory environment
     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
-
+    
     mainRunLoop = CFRunLoopGetCurrent();
-
+    
     pthread_mutex_init(&btOperationInProgress, NULL);
-    MPCreateEvent(&synchronousBTOperationCallComplete);
-
+    synchronousBTOperationCallComplete = dispatch_semaphore_create(0);
+    
     // create event sources, i.e. requests from the java VM
     CFRunLoopSourceContext context = {0};
     BTOperationParams operationParams = {0};
@@ -198,22 +229,23 @@ JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved) {
     context.perform = performBTOperationCallBack;
     btOperationSource = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
     CFRunLoopAddSource(mainRunLoop, btOperationSource, kCFRunLoopDefaultMode);
-
+    
     // Init complete, releasing the library load thread
-    MPSetEvent(threadParams->initializedNotificationEvent, 1);
-
+    dispatch_semaphore_signal(threadParams->initializedNotificationEvent); // , 1);
+    
     ndebug(("Starting the CFRunLoop"));
     // Starting the CFRunLoop
     CFRunLoopRun();
     // should only reach this point when getting unloaded
     pthread_mutex_destroy(&btOperationInProgress);
-    MPSetEvent(synchronousBTOperationCallComplete, 0);
-    MPDeleteEvent(synchronousBTOperationCallComplete);
-
+    dispatch_semaphore_signal(synchronousBTOperationCallComplete); // , 0);
+    dispatch_release(synchronousBTOperationCallComplete);
+    
     [autoreleasepool release];
     return NULL;
 }
 
+
 void performBTOperationCallBack(void *info) {
     BTOperationParams* params = (BTOperationParams*)info;
     if (params->runnable != NULL) {
@@ -225,29 +257,63 @@ void performBTOperationCallBack(void *info) {
             ndebug((" finished BTOperation %s", params->runnable->name));
         }
     }
-    MPSetEvent(synchronousBTOperationCallComplete, 1);
+    dispatch_semaphore_signal(synchronousBTOperationCallComplete); // , 1);
 }
 
 void synchronousBTOperation(Runnable* runnable) {
-
+    
     pthread_mutex_lock(&btOperationInProgress);
-
+    
     CFRunLoopSourceContext  context={0};
     CFRunLoopSourceGetContext(btOperationSource, &context);
     BTOperationParams* params = (BTOperationParams*)context.info;
     params->runnable = runnable;
-
+    
     ndebug(("invoke    BTOperation %s", params->runnable->name));
     CFRunLoopSourceSignal(btOperationSource);
     CFRunLoopWakeUp(mainRunLoop);
-
-    MPEventFlags flags;
-    MPWaitForEvent(synchronousBTOperationCallComplete, &flags, kDurationForever);
-
+    
+    dispatch_semaphore_wait(synchronousBTOperationCallComplete, kDurationForever);
+    
     pthread_mutex_unlock(&btOperationInProgress);
     ndebug(("return    BTOperation %s", params->runnable->name));
 }
 
+#else
+
+void synchronousBTOperation(Runnable* runnable) {
+    if (runnable != NULL) {
+        ndebug(("invoke    BTOperation %s", runnable->name));
+        
+        dispatch_block_t block = ^
+        {
+            if (isRunnableCorrupted(runnable)) {
+                ndebug(("Error: execute BTOperation got corrupted runnable"));
+            }
+            else {
+                ndebug((" execute  BTOperation %s", runnable->name));
+                runnable->run();
+                ndebug((" finished BTOperation %s", runnable->name));
+            }
+        };
+        
+        // Prevent deadlocking the main thread with dispatch_sync
+        // by checking if we are on the main thread first.
+        if ([NSThread isMainThread])
+        {
+            block();
+        }
+        else
+        {
+            dispatch_sync(dispatch_get_main_queue(), block);
+        }        
+
+        ndebug(("return    BTOperation %s", runnable->name));
+    }
+}
+
+#endif
+
 // --- Helper functions
 
 OSXJNIHelper::OSXJNIHelper() {
@@ -293,7 +359,7 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 // --- JNI function
 
 JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isNativeCodeLoaded
-  (JNIEnv *env, jobject peer) {
+(JNIEnv *env, jobject peer) {
     return JNI_TRUE;
 }
 
@@ -330,34 +396,18 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 // --- LocalDevice
 
 RUNNABLE(GetLocalDeviceBluetoothAddress, "GetLocalDeviceBluetoothAddress") {
-    BluetoothDeviceAddress localAddress;
-    if (!IOBluetoothLocalDeviceAvailable()) {
+    
+    if ([IOBluetoothHostController defaultController] == nil) {
         error = 1;
         return;
     }
-#ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
-    if (localDeviceSupportedSoftwareVersion >= BLUETOOTH_VERSION_2_0) {
-        IOBluetoothHostController* controller = [IOBluetoothHostController defaultController];
-        if (controller != NULL) {
-            IOReturn rc = [controller getAddress:&localAddress];
-            if (rc != kIOReturnSuccess) {
-                ndebug(("IOBluetoothHostController.getAddress error [0x%08x]", rc));
-                error = 2;
-                return;
-            }
-            OSxAddrToString(sData, &localAddress);
-            return;
-        }
-    }
-#endif
-    // Tiger version
-    IOReturn rc = IOBluetoothLocalDeviceReadAddress(&localAddress, NULL, NULL, NULL);
-    if (rc != kIOReturnSuccess) {
-        ndebug(("LocalDeviceReadAddress error [0x%08x]", rc));
-        error = 2;
+    
+    IOBluetoothHostController* controller = [IOBluetoothHostController defaultController];
+    if (controller != NULL) {
+        NSString* address = [controller addressAsString];
+        strncpy(sData, [address cStringUsingEncoding:NSUnicodeStringEncoding], RUNNABLE_DATA_MAX);
         return;
     }
-    OSxAddrToString(sData, &localAddress);
 }
 
 JNIEXPORT jstring JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_getLocalDeviceBluetoothAddress
@@ -377,11 +427,18 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 }
 
 RUNNABLE(GetLocalDeviceName, "GetLocalDeviceName") {
-    BluetoothDeviceName localName;
-    if (IOBluetoothLocalDeviceReadName(localName, NULL, NULL, NULL)) {
+    
+    if ([IOBluetoothHostController defaultController] == nil) {
         error = 1;
-    } else {
-        strncpy(sData, (char*)localName, RUNNABLE_DATA_MAX);
+        return;
+    }
+    
+    IOBluetoothHostController* controller = [IOBluetoothHostController defaultController];
+    if (controller != NULL) {
+        NSString* localName = [controller nameAsString];
+        
+        strncpy(sData, [localName cStringUsingEncoding:NSUnicodeStringEncoding], RUNNABLE_DATA_MAX);
+        return;
     }
 }
 
@@ -397,12 +454,18 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 }
 
 RUNNABLE(GetDeviceClass, "GetDeviceClass") {
-    BluetoothClassOfDevice cod;
-    if (IOBluetoothLocalDeviceReadClassOfDevice(&cod, NULL, NULL, NULL)) {
+    
+    if ([IOBluetoothHostController defaultController] == nil) {
         error = 1;
-    } else {
-        lData = cod;
+        return;
     }
+    
+    
+    IOBluetoothHostController* controller = [IOBluetoothHostController defaultController];
+    
+    BluetoothClassOfDevice cod = [controller classOfDevice];
+    
+    lData = cod;
 }
 
 JNIEXPORT jint JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_getDeviceClassImpl
@@ -414,17 +477,12 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 }
 
 RUNNABLE(IsLocalDevicePowerOn, "IsLocalDevicePowerOn") {
-    if (!IOBluetoothLocalDeviceAvailable()) {
+    if ([IOBluetoothHostController defaultController] == nil) {
         error = 1;
         bData = false;
         return;
     }
-    BluetoothHCIPowerState powerState;
-    if (IOBluetoothLocalDeviceGetPowerState(&powerState)) {
-        error = 2;
-        bData = false;
-        return;
-    }
+    BluetoothHCIPowerState powerState = [[IOBluetoothHostController defaultController] powerState];
     bData = (powerState == kBluetoothHCIPowerStateON)?true:false;
 }
 
@@ -436,19 +494,19 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
     return (runnable.bData)?JNI_TRUE:JNI_FALSE;
 }
 
+int IOBluetoothPreferenceGetDiscoverableState();
+
 RUNNABLE(IsLocalDeviceDiscoverable, "IsLocalDeviceDiscoverable") {
-    if (!IOBluetoothLocalDeviceAvailable()) {
+    
+    if ([IOBluetoothHostController defaultController] == nil) {
         error = 1;
         bData = false;
         return;
     }
-    Boolean discoverableStatus;
-    if (IOBluetoothLocalDeviceGetDiscoverable(&discoverableStatus)) {
-        error = 1;
-        bData = false;
-        return;
-    }
-    bData = discoverableStatus;
+    
+    // Boolean discoverableStatus = IOBluetoothPreferenceGetDiscoverableState();
+    
+    bData = YES; // discoverableStatus;
 }
 
 JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_getLocalDeviceDiscoverableImpl
@@ -461,10 +519,10 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 
 RUNNABLE(GetBluetoothHCISupportedFeatures, "GetBluetoothHCISupportedFeatures") {
     BluetoothHCISupportedFeatures features;
-    if (IOBluetoothLocalDeviceReadSupportedFeatures(&features, NULL, NULL, NULL)) {
-        error = 1;
-        return;
-    }
+    //if (IOBluetoothLocalDeviceReadSupportedFeatures(&features, NULL, NULL, NULL)) {
+    error = 1;
+    return;
+    //}
     lData = features.data[iData];
 }
 
@@ -480,18 +538,6 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
     return (kBluetoothFeatureSwitchRoles & runnable.lData)?JNI_TRUE:JNI_FALSE;
 }
 
-JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isLocalDeviceFeatureRSSI
-(JNIEnv *env, jobject) {
-    Edebug(("isLocalDeviceFeatureSwitchRoles"));
-    GetBluetoothHCISupportedFeatures runnable;
-    runnable.iData = 6;
-    synchronousBTOperation(&runnable);
-    if (runnable.error) {
-        return JNI_FALSE;
-    }
-    return (kBluetoothFeatureRSSI & runnable.lData)?JNI_TRUE:JNI_FALSE;
-}
-
 JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isLocalDeviceFeatureParkMode
 (JNIEnv *env, jobject) {
     Edebug(("isLocalDeviceFeatureParkMode"));
@@ -511,10 +557,19 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
 
 RUNNABLE(GetLocalDeviceVersion, "GetLocalDeviceVersion") {
     NumVersion* btVersion = (NumVersion*)pData[0];
-    BluetoothHCIVersionInfo* hciVersion = (BluetoothHCIVersionInfo*)pData[1];
-    if (IOBluetoothGetVersion(btVersion, hciVersion)) {
-        error = 1;
-    }
+    // BluetoothHCIVersionInfo* hciVersion = (BluetoothHCIVersionInfo*)pData[1];
+    
+    btVersion->majorRev = 10;
+    btVersion->minorAndBugRev = 8;
+    btVersion->nonRelRev = 2;
+    btVersion->stage = 0;
+    
+    // hciVersion->manufacturerName = "Apple";
+    // if (IOBluetoothGetVersion(btVersion, hciVersion)) {
+    error = 1;
+    //}
+    
+    error = 0;
 }
 
 JNIEXPORT jstring JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_getLocalDeviceSoftwareVersionInfo
@@ -528,9 +583,9 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
     if (runnable.error) {
         return NULL;
     }
-
+    
     snprintf(swVers, 133, "%1d.%1d.%1d rev %d", btVersion.majorRev, (btVersion.minorAndBugRev >> 4) & 0x0F,
-                          btVersion.minorAndBugRev & 0x0F, btVersion.nonRelRev);
+             btVersion.minorAndBugRev & 0x0F, btVersion.nonRelRev);
     return env->NewStringUTF(swVers);
 }
 
@@ -544,19 +599,19 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
     if (runnable.error) {
         return 0;
     }
-
+    
     // Define starts with 0 and interprited as Octal constants
     int compiledFor = 0;
-    #ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
-        // not Octal since API version 2
-        compiledFor = BLUETOOTH_VERSION_CURRENT;
-    #else
-        compiledFor = 10603;
-    #endif
+#ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
+    // not Octal since API version 2
+    compiledFor = 10803; // BLUETOOTH_VERSION_CURRENT;
+#else
+    compiledFor = 10603;
+#endif
     //log_info("compiled for         %d", compiledFor);
     //log_info(" this majorRev       %d", (int)btVersion.majorRev);
     //log_info(" this minorAndBugRev %d", (int)btVersion.minorAndBugRev);
-
+    
     jint v = (100 * ((100 * btVersion.majorRev) + ((btVersion.minorAndBugRev >> 4) & 0x0F))) + (btVersion.minorAndBugRev & 0x0F);
     //log_info(" this                %d", v);
     if (v < compiledFor) {
@@ -572,7 +627,7 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
     Edebug(("getLocalDeviceManufacturer"));
     BluetoothHCIVersionInfo hciVersion;
     GetLocalDeviceVersion runnable;
-    runnable.pData[1] = &hciVersion;
+    runnable.pData[0] = &hciVersion;
     synchronousBTOperation(&runnable);
     if (runnable.error) {
         return 0;
@@ -585,13 +640,68 @@ void LongToOSxBTAddr(jlong longAddr, BluetoothDeviceAddress* addr) {
     Edebug(("getLocalDeviceVersion"));
     BluetoothHCIVersionInfo hciVersion;
     GetLocalDeviceVersion runnable;
-    runnable.pData[1] = &hciVersion;
+    runnable.pData[0] = &hciVersion;
     synchronousBTOperation(&runnable);
     if (runnable.error) {
         return 0;
     }
     char swVers[133];
     snprintf(swVers, 133, "LMP Version: %d.%d, HCI Version: %d.%d", hciVersion.lmpVersion, hciVersion.lmpSubVersion,
-                          hciVersion.hciVersion, hciVersion.hciRevision);
+             hciVersion.hciVersion, hciVersion.hciRevision);
     return env->NewStringUTF(swVers);
 }
+
+JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_retrieveDevicesImpl
+(JNIEnv *env, jobject peer, jint option, jobject retrieveDevicesCallback) {
+    Edebug(("retrieveDevicesImpl"));
+    RetrieveDevicesCallback callback;
+    if (!callback.builCallback(env, peer, retrieveDevicesCallback)) {
+        return JNI_FALSE;
+    }
+    
+    jboolean result = JNI_TRUE;
+
+    switch (option) {
+        case RETRIEVEDEVICES_OPTION_PREKNOWN: {
+            NSArray* pPairedDevices = [IOBluetoothDevice pairedDevices];
+    
+            if (pPairedDevices != NULL) {
+                int deviceCount = [pPairedDevices count];
+                for (int index = 0; index < deviceCount; index++) {
+                    IOBluetoothDevice* device = (IOBluetoothDevice*)[pPairedDevices objectAtIndex:index];
+                    jlong deviceAddr = OSxAddrToLong( [device getAddress] );
+                    jint deviceClass = (jint) [device classOfDevice];
+                    jstring deviceName = OSxNewJString(env, [device name]);
+                    jboolean paired = JNI_TRUE;
+               
+                    if (!callback.callDeviceFoundCallback(env, deviceAddr, deviceClass, deviceName, paired)) {
+                        result = JNI_FALSE;
+                        break;
+                    }
+                }
+            }
+        }
+        break;
+            
+    default:
+      //Not supported
+      result = JNI_FALSE;
+    }
+    
+    return result;
+}
+
+JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isRemoteDeviceTrustedImpl
+(JNIEnv *, jobject, jlong) {
+    //TODO: This is just a dummy implementation to prevent UnstatisfiedLinkErrors on OS X
+    return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isRemoteDeviceAuthenticatedImpl
+(JNIEnv *, jobject, jlong) {
+    //TODO: This is just a dummy implementation to prevent UnstatisfiedLinkErrors on OS X
+    return JNI_FALSE;
+}
+
+
+
diff --git a/bluecove/src/main/c/intelbth/OSXStackChannelController.h b/bluecove/src/main/c/intelbth/OSXStackChannelController.h
index 6df82fae..dccba66a 100755
--- a/bluecove/src/main/c/intelbth/OSXStackChannelController.h
+++ b/bluecove/src/main/c/intelbth/OSXStackChannelController.h
@@ -28,8 +28,9 @@
 
 class ChannelController : public PoolableObject {
 public:
-    MPEventID notificationEvent;
-	MPEventID writeCompleteNotificationEvent;
+    dispatch_semaphore_t notificationEvent;
+	dispatch_semaphore_t writeCompleteNotificationEvent;
+    
     volatile IOReturn openStatus;
 
     IOBluetoothDevice* bluetoothDevice;
@@ -76,4 +77,4 @@ class BasebandConnectionGetOptions: public Runnable {
 
     BasebandConnectionGetOptions();
     virtual void run();
-};
\ No newline at end of file
+};
diff --git a/bluecove/src/main/c/intelbth/OSXStackChannelController.mm b/bluecove/src/main/c/intelbth/OSXStackChannelController.mm
index 9269bad8..475ee3ad 100755
--- a/bluecove/src/main/c/intelbth/OSXStackChannelController.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackChannelController.mm
@@ -19,7 +19,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  *
- *  @version $Id: OSXStackRFCOMM.mm 1244 2007-11-27 04:06:32Z skarzhevskyy $
+ *  @version $Id$
  */
 
 #import "OSXStackChannelController.h"
@@ -32,20 +32,20 @@
     isBasebandConnected = false;
 	isConnected = false;
 	bluetoothDevice = NULL;
-	MPCreateEvent(&notificationEvent);
-	MPCreateEvent(&writeCompleteNotificationEvent);
+	notificationEvent = dispatch_semaphore_create(0);
+	writeCompleteNotificationEvent = dispatch_semaphore_create(0);
 }
 
 ChannelController::~ChannelController() {
-    MPSetEvent(notificationEvent, 0);
-    MPSetEvent(writeCompleteNotificationEvent, 0);
-    MPDeleteEvent(notificationEvent);
-    MPDeleteEvent(writeCompleteNotificationEvent);
+    dispatch_semaphore_signal(notificationEvent); //, 0);
+    dispatch_semaphore_signal(writeCompleteNotificationEvent); //, 0);
+    dispatch_release(notificationEvent);
+    dispatch_release(writeCompleteNotificationEvent);
 }
 
 BOOL ChannelController::waitForConnection(JNIEnv *env, jobject peer, BOOL baseband, jint timeout) {
     CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent ();
-    char* name = "";
+    const char* name = "";
     if (baseband) {
         name = "baseband ";
     }
@@ -55,8 +55,8 @@
         } else if (!baseband && isConnected) {
             break;
         }
-        MPEventFlags flags;
-        MPWaitForEvent(notificationEvent, &flags, kDurationMillisecond * 500);
+
+        dispatch_semaphore_wait(notificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
         if (isCurrentThreadInterrupted(env, peer, "connection wait")) {
 			return false;
 		}
@@ -92,14 +92,14 @@
 }
 
 BasebandConnectionOpen::BasebandConnectionOpen() {
-    name = "BasebandConnectionOpen";
+    name = (char*) [[@"BasebandConnectionOpen" dataUsingEncoding:NSASCIIStringEncoding] bytes];
 }
 
 void BasebandConnectionOpen::run() {
     BluetoothDeviceAddress btAddress;
     LongToOSxBTAddr(this->address, &btAddress);
-    IOBluetoothDeviceRef deviceRef = IOBluetoothDeviceCreateWithAddress(&btAddress);
-    if (deviceRef == NULL) {
+    IOBluetoothDevice* device = [IOBluetoothDevice deviceWithAddress:(const BluetoothDeviceAddress*)&btAddress];
+    if (device == NULL) {
         error = 1;
         return;
     }
@@ -107,7 +107,7 @@
     comm->isClosed = false;
 
     comm->initDelegate();
-    comm->bluetoothDevice = [IOBluetoothDevice withDeviceRef:deviceRef];
+    comm->bluetoothDevice = device;
     if (comm->bluetoothDevice == NULL) {
         error = 1;
         return;
diff --git a/bluecove/src/main/c/intelbth/OSXStackDiscovery.h b/bluecove/src/main/c/intelbth/OSXStackDiscovery.h
index b4d7cdca..55386f3b 100755
--- a/bluecove/src/main/c/intelbth/OSXStackDiscovery.h
+++ b/bluecove/src/main/c/intelbth/OSXStackDiscovery.h
@@ -22,17 +22,12 @@
  *  @version $Id$
  */
 
-#include "OSXStack.h"
-
 #import <Cocoa/Cocoa.h>
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothDeviceInquiry.h>
 
-#ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
-#import <IOBluetooth/objc/IOBluetoothHostController.h>
-#endif
-
+#include "OSXStack.h"
 
 /**
  * OS x BUG. If discovery has been cancelled by stop. For next discovery deviceInquiryComplete function is called for previous Delegate Object, not for current
@@ -47,7 +42,7 @@
     IOBluetoothDeviceInquiry*       _inquiry;
     NSMutableArray*                 _foundDevices;
 
-    MPEventID*                      _notificationEvent;
+    dispatch_semaphore_t*           _notificationEvent;
 
     volatile BOOL                   _aborted;
     volatile IOReturn               _error;
@@ -73,51 +68,30 @@
 
 @end
 
-class GetRemoteDeviceFriendlyName: public Runnable {
-public:
-    MPEventID inquiryFinishedEvent;
-    IOBluetoothDeviceRef deviceRef;
+class GetRemoteDeviceFriendlyName;
 
-    GetRemoteDeviceFriendlyName();
-    virtual ~GetRemoteDeviceFriendlyName();
-
-    virtual void run();
-};
+@interface GetRemoteDeviceFriendlyNameDelegate : NSObject <IOBluetoothDeviceAsyncCallbacks> {
+    
+    GetRemoteDeviceFriendlyName*    _runnable;
+    
+    IOBluetoothDevice*              _device;
+}
 
 
-class RetrieveDevices: public Runnable {
-public:
-    NSArray *pairedDevices;
-    NSArray *favoriteDevices;
-    NSArray *recentDevices;
+- (id)initWithRunnable:(GetRemoteDeviceFriendlyName*)runnable;
 
-    RetrieveDevices();
+- (void)remoteNameRequest:(long)address;
 
-    virtual void run();
-};
+@end
 
-#ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
-class GetRemoteDeviceRSSI: public Runnable {
+class GetRemoteDeviceFriendlyName: public Runnable {
 public:
-    MPEventID inquiryFinishedEvent;
-    IOBluetoothDevice *bluetoothDevice;
-
-    NSObject*   delegate;
-    NSObject*   orig_delegate;
-
-    GetRemoteDeviceRSSI();
-    virtual ~GetRemoteDeviceRSSI();
+    dispatch_semaphore_t inquiryFinishedEvent;
+    IOBluetoothDeviceRef deviceRef;
+    GetRemoteDeviceFriendlyNameDelegate* delegate;
+    
+    GetRemoteDeviceFriendlyName();
+    virtual ~GetRemoteDeviceFriendlyName();
 
     virtual void run();
-    
-    void release();
 };
-
-@interface RemoteDeviceRSSIHostControllerDelegate : NSObject {
-    GetRemoteDeviceRSSI* _runnable;
-}
-- (id)initWithRunnable:(GetRemoteDeviceRSSI*)runnable;
-    // See IOBluetoothHostControllerDelegate
-- (void)readRSSIForDeviceComplete:(id)controller device:(IOBluetoothDevice*)device	info:(BluetoothHCIRSSIInfo*)info	error:(IOReturn)error;
-@end
-#endif
\ No newline at end of file
diff --git a/bluecove/src/main/c/intelbth/OSXStackDiscovery.mm b/bluecove/src/main/c/intelbth/OSXStackDiscovery.mm
index 58cd3fd8..0c96fe3f 100644
--- a/bluecove/src/main/c/intelbth/OSXStackDiscovery.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackDiscovery.mm
@@ -24,6 +24,10 @@
 
 #import "OSXStackDiscovery.h"
 
+#include <dispatch/dispatch.h>
+
+#import <IOBluetooth/IOBluetooth.h>
+
 #define CPP_FILE "OSXStackDiscovery.mm"
 
 @implementation OSXStackDiscovery
@@ -47,11 +51,10 @@ -(BOOL) startSearch:(int)logID inquiryLength:(int)inquiryLength {
     _busy = FALSE;
 
     if (_foundDevices == NULL) {
-        _foundDevices = [NSMutableArray arrayWithCapacity:15];
+        _foundDevices = [[NSMutableArray alloc] initWithCapacity:15];
         if (!_foundDevices) {
            return FALSE;
         }
-        [_foundDevices retain];
     }
 
     _started = FALSE;
@@ -141,8 +144,8 @@ -(BOOL) wait {
     if (![self busy]) {
         return FALSE;
     }
-    MPEventFlags flags;
-    return (kMPTimeoutErr == MPWaitForEvent(*_notificationEvent, &flags, kDurationMillisecond * 1000));
+
+    return (kMPTimeoutErr == dispatch_semaphore_wait(*_notificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 1)));
 }
 
 //===========================================================================================================================
@@ -175,7 +178,7 @@ -(void) updateDeviceInfo:(IOBluetoothDevice *)inDevice {
 
 -(void) deviceInquiryStarted:(IOBluetoothDeviceInquiry*)sender {
     _started = TRUE;
-    MPSetEvent(*_notificationEvent, 0);
+    dispatch_semaphore_signal(*_notificationEvent);
 }
 
 //===========================================================================================================================
@@ -187,7 +190,7 @@ -(void) deviceInquiryDeviceFound:(IOBluetoothDeviceInquiry*)sender  device:(IOBl
         return;
     }
     [self addDeviceToList:device];
-    MPSetEvent(*_notificationEvent, 0);
+    dispatch_semaphore_signal(*_notificationEvent);
 }
 
 //===========================================================================================================================
@@ -206,7 +209,7 @@ -(void) deviceInquiryDeviceNameUpdated:(IOBluetoothDeviceInquiry*)sender    devi
         return;
     }
     [self updateDeviceInfo:device];
-    MPSetEvent(*_notificationEvent, 0);
+    dispatch_semaphore_signal(*_notificationEvent);
 }
 
 //===========================================================================================================================
@@ -241,10 +244,10 @@ -(void) deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender error:(IOReturn)
         }
         if (stack != NULL) {
             stack->deviceInquiryBusy = false;
-            MPSetEvent(stack->deviceInquiryBusyEvent, 1);
+            dispatch_semaphore_signal(stack->deviceInquiryBusyEvent); // , 1);
         }
     }
-    MPSetEvent(*_notificationEvent, 1);
+    dispatch_semaphore_signal(*_notificationEvent); // , 1);
 }
 
 @end
@@ -306,7 +309,7 @@ -(void) deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender error:(IOReturn)
 void DeviceInquiryStart::run() {
     startStatus = FALSE;
 
-    if (IOBluetoothLocalDeviceAvailable() == FALSE) {
+    if ([IOBluetoothHostController defaultController] == nil) {
         this->error = 1;
         return;
     }
@@ -404,8 +407,8 @@ -(void) deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender error:(IOReturn)
         if ((stack != NULL) && (d != NULL)) {
             debug(("deviceInquiry device discovered"));
             jlong deviceAddr = OSxAddrToLong([d getAddress]);
-            jint deviceClass = (jint)[d getClassOfDevice];
-            jstring name = OSxNewJString(env, [d getName]);
+            jint deviceClass = (jint)d.classOfDevice;
+            jstring name = OSxNewJString(env, d.name);
             jboolean paired = [d isPaired];
             if (!callback.callDeviceDiscovered(env, listener, deviceAddr, deviceClass, name, paired)) {
                 synchronousBTOperation(&discoveryRelease);
@@ -459,7 +462,7 @@ -(void) deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender error:(IOReturn)
     if ((stack != NULL) && (stack->deviceInquiryInProcess)) {
         // This will dellay termiantion untill loop in runDeviceInquiryImpl will detect this flag
         stack->deviceInquiryTerminated = TRUE;
-        MPSetEvent(stack->deviceInquiryNotificationEvent, 1);
+        dispatch_semaphore_signal(stack->deviceInquiryNotificationEvent); // , 1);
         return TRUE;
     } else {
         return FALSE;
@@ -470,49 +473,18 @@ -(void) deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender error:(IOReturn)
 
 GetRemoteDeviceFriendlyName::GetRemoteDeviceFriendlyName() {
     name = "GetRemoteDeviceFriendlyName";
-    MPCreateEvent(&inquiryFinishedEvent);
+    inquiryFinishedEvent = dispatch_semaphore_create(0);
+    delegate = [[GetRemoteDeviceFriendlyNameDelegate alloc] init];
 }
 
 GetRemoteDeviceFriendlyName::~GetRemoteDeviceFriendlyName() {
-    MPDeleteEvent(inquiryFinishedEvent);
+    dispatch_release(inquiryFinishedEvent);
+    [delegate release];
+    delegate = nil;
 }
 
 void GetRemoteDeviceFriendlyName::run() {
-    BluetoothDeviceAddress btAddress;
-    LongToOSxBTAddr(jlData, &btAddress);
-    deviceRef = IOBluetoothDeviceCreateWithAddress(&btAddress);
-    if (deviceRef == NULL) {
-        error = 1;
-        return;
-    }
-    if (kIOReturnSuccess != IOBluetoothDeviceRemoteNameRequest(deviceRef, remoteNameRequestResponse, this, NULL)) {
-        error = 1;
-        IOBluetoothObjectRelease(deviceRef);
-    }
-}
-
-void remoteNameRequestResponse(void *userRefCon, IOBluetoothDeviceRef deviceRef, IOReturn status ) {
-    GetRemoteDeviceFriendlyName* runnable = (GetRemoteDeviceFriendlyName*) userRefCon;
-    if (isRunnableCorrupted(runnable)) {
-        return;
-    }
-    if (kIOReturnSuccess != status) {
-        runnable->error = 1;
-    } else {
-        CFStringRef name = IOBluetoothDeviceGetName(deviceRef);
-        if (name == NULL) {
-            runnable->error = 1;
-        } else {
-            CFIndex buflength = CFStringGetLength(name);
-            CFRange range = {0};
-            range.length = MIN(RUNNABLE_DATA_MAX, buflength);
-            runnable->iData = range.length;
-            CFStringGetCharacters(name, range, runnable->uData);
-            runnable->bData = TRUE;
-        }
-    }
-    IOBluetoothObjectRelease(runnable->deviceRef);
-    MPSetEvent(runnable->inquiryFinishedEvent, 0);
+    [delegate remoteNameRequest:lData];
 }
 
 JNIEXPORT jstring JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_getRemoteDeviceFriendlyName
@@ -527,20 +499,18 @@ void remoteNameRequestResponse(void *userRefCon, IOBluetoothDeviceRef deviceRef,
         debug(("blocked until deviceInquiry ends"));
     }
     while ((stack != NULL) && (stack->deviceInquiryBusy)) {
-        MPEventFlags flags;
-        MPWaitForEvent(stack->deviceInquiryBusyEvent, &flags, kDurationMillisecond * 500);
+                dispatch_semaphore_wait(stack->deviceInquiryBusyEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
     }
     // Call from DeviceDiscovered callback deviceInquiryInProcessMutex already locked
     //if (!stack->deviceInquiryLock(env)) {
     //    return NULL;
     //}
     GetRemoteDeviceFriendlyName runnable;
-    runnable.jlData = address;
+    runnable.lData = address;
     synchronousBTOperation(&runnable);
 
     while ((stack != NULL) && (runnable.error == 0) && (!runnable.bData)) {
-        MPEventFlags flags;
-        MPWaitForEvent(runnable.inquiryFinishedEvent, &flags, kDurationMillisecond * 500);
+                dispatch_semaphore_wait(runnable.inquiryFinishedEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
     }
     //if (stack != NULL) {
     //  stack->deviceInquiryUnlock();
@@ -552,222 +522,69 @@ void remoteNameRequestResponse(void *userRefCon, IOBluetoothDeviceRef deviceRef,
     return env->NewString(runnable.uData, runnable.iData);
 }
 
-RetrieveDevices::RetrieveDevices() {
-    name = "RetrieveDevices";
-    pairedDevices = NULL;
-    favoriteDevices = NULL;
-    recentDevices = NULL;
-}
+@implementation GetRemoteDeviceFriendlyNameDelegate
 
-void RetrieveDevices::run() {
-    pairedDevices = [IOBluetoothDevice pairedDevices];
-    favoriteDevices = [IOBluetoothDevice favoriteDevices];
-    recentDevices = [IOBluetoothDevice recentDevices:0];
-}
-
-jboolean callDeviceFound(JNIEnv *env, RetrieveDevicesCallback *callback, NSArray *devices) {
-    jboolean result = JNI_TRUE;
-    if (devices == NULL) {
-        return JNI_TRUE;
-    }
-    NSEnumerator* devicesEnum = [devices objectEnumerator];
-    id device = nil;
-    while ( device = (IOBluetoothDevice*) [devicesEnum nextObject]) {
-        jlong deviceAddr = OSxAddrToLong([device getAddress]);
-        jint deviceClass = (jint)[device getClassOfDevice];
-        jstring deviceName = OSxNewJString(env, [device getName]);
-        jboolean paired = [device isPaired];
-        if (!callback->callDeviceFoundCallback(env, deviceAddr, deviceClass, deviceName, paired)) {
-            result = JNI_FALSE;
-            break;
-        }
-    }
-    return result;
-}
-
-JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_retrieveDevicesImpl
-  (JNIEnv *env, jobject peer, jint option, jobject retrieveDevicesCallback) {
-    if (stack == NULL) {
-        throwRuntimeException(env, cSTACK_CLOSED);
-        return JNI_FALSE;
-    }
-    RetrieveDevicesCallback callback;
-    if (!callback.builCallback(env, peer, retrieveDevicesCallback)) {
-        return JNI_FALSE;
-    }
-
-    RetrieveDevices runnable;
-    synchronousBTOperation(&runnable);
-    if (RETRIEVEDEVICES_OPTION_CACHED == option) {
-        return callDeviceFound(env, &callback, runnable.recentDevices);
-    } else {
-        jboolean result = callDeviceFound(env, &callback, runnable.pairedDevices);
-        if (result == JNI_TRUE) {
-            return callDeviceFound(env, &callback, runnable.favoriteDevices);
-        } else {
-            return result;
-        }
-    }
-}
-
-RUNNABLE(IsRemoteDeviceTrusted, "IsRemoteDeviceTrusted") {
-    BluetoothDeviceAddress btAddress;
-    LongToOSxBTAddr(jlData, &btAddress);
-    IOBluetoothDevice *device = [IOBluetoothDevice withAddress:&btAddress];
-    bData = [device isPaired];
-}
-
-JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isRemoteDeviceTrustedImpl
-  (JNIEnv *env, jobject, jlong address) {
-    IsRemoteDeviceTrusted runnable;
-    runnable.jlData = address;
-    synchronousBTOperation(&runnable);
-    return (runnable.bData)?JNI_TRUE:JNI_FALSE;
-}
-
-RUNNABLE(IsRemoteDeviceAuthenticated, "IsRemoteDeviceAuthenticated") {
-    BluetoothDeviceAddress btAddress;
-    LongToOSxBTAddr(jlData, &btAddress);
-    IOBluetoothDevice *device = [IOBluetoothDevice withAddress:&btAddress];
-    bData = [device isPaired] && [device isConnected];
-}
-
-JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_isRemoteDeviceAuthenticatedImpl
-  (JNIEnv *env, jobject, jlong address) {
-    IsRemoteDeviceAuthenticated runnable;
-    runnable.jlData = address;
-    synchronousBTOperation(&runnable);
-    return (runnable.bData)?JNI_TRUE:JNI_FALSE;
-}
-
-//  -------- read RSSI --------
-
-#ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
-@implementation RemoteDeviceRSSIHostControllerDelegate
-
-- (id)initWithRunnable:(GetRemoteDeviceRSSI*)runnable {
+- (id)initWithRunnable:(GetRemoteDeviceFriendlyName*)runnable
+{
     _runnable = runnable;
+    
     return self;
 }
 
-- (void)readRSSIForDeviceComplete:(id)controller device:(IOBluetoothDevice*)device  info:(BluetoothHCIRSSIInfo*)info    error:(IOReturn)error {
-    if (!isRunnableCorrupted(_runnable)) {
-        if (_runnable->bluetoothDevice && [_runnable->bluetoothDevice isEqual:device]) {
-            if ((error != kIOReturnSuccess) || (info == NULL)) {
-                ndebug(("ERROR: readRSSIForDeviceComplete return error"));
-                _runnable->error = 1;
-                _runnable->lData = error;
-            } else if (info->handle == kBluetoothConnectionHandleNone) {
-                ndebug(("ERROR: readRSSIForDeviceComplete no connection"));
-                _runnable->error = 2;
-            } else {
-                _runnable->bData = TRUE;
-                _runnable->iData = info->RSSIValue;
-            }
-            MPSetEvent(_runnable->inquiryFinishedEvent, 0);
-        }
+- (void)remoteNameRequest:(long)address
+{
+    BluetoothDeviceAddress btAddress;
+    LongToOSxBTAddr(address, &btAddress);
+    
+    _device = [IOBluetoothDevice deviceWithAddress:(const BluetoothDeviceAddress*)&btAddress];
+    if (_device == NULL) {
+        _runnable->error = 1;
+        return;
     }
+    
+    if (kIOReturnSuccess != [_device remoteNameRequest:self]) {
+        _runnable->error = 1;
+        _device = nil;
+    }    
 }
 
-@end
-
-GetRemoteDeviceRSSI::GetRemoteDeviceRSSI() {
-    name = "GetRemoteDeviceRSSI";
-    delegate = NULL;
-    MPCreateEvent(&inquiryFinishedEvent);
-}
-
-GetRemoteDeviceRSSI::~GetRemoteDeviceRSSI() {
-    MPDeleteEvent(inquiryFinishedEvent);
-}
-
-void GetRemoteDeviceRSSI::run() {
-    BluetoothDeviceAddress btAddress;
-    LongToOSxBTAddr(jlData, &btAddress);
-    bluetoothDevice = [IOBluetoothDevice withAddress:&btAddress];
-    if (bluetoothDevice == NULL) {
-        this->error = 1;
-        this->lData = 0;
+- (void)remoteNameRequestComplete:(IOBluetoothDevice *)device status:(IOReturn)status
+{
+    if (isRunnableCorrupted(_runnable)) {
         return;
     }
-    IOBluetoothHostController* controller = [IOBluetoothHostController defaultController];
-    if (controller == NULL) {
-        this->error = 1;
-        this->lData = 0;
-        return;
+    
+    if (kIOReturnSuccess != status) {
+        _runnable->error = 1;
     }
-    orig_delegate = [controller delegate];
-    delegate = [[RemoteDeviceRSSIHostControllerDelegate alloc] initWithRunnable:this];
-    [delegate retain];
-    [controller setDelegate:delegate];
-    IOReturn rc = [controller readRSSIForDevice:bluetoothDevice];
-    if (rc != noErr) {
-        ndebug(("ERROR: call readRSSIForDevice failed"));
-        this->error = 1;
-        this->lData = rc;
+    else {
+        NSString* name = [device name]; // IOBluetoothDeviceGetName(deviceRef);
+        if (name == NULL) {
+            _runnable->error = 1;
+        }
+        else {
+            NSData* data = [name dataUsingEncoding:NSUnicodeStringEncoding];
+            UniChar* uniData = (UniChar*)[data bytes];
+            _runnable->iData = MIN(RUNNABLE_DATA_MAX, [data length]);
+            
+            memccpy(_runnable->uData, uniData, 0, _runnable->iData);
+            _runnable->bData = TRUE;
+        }
     }
+    
+    device = nil;
+    dispatch_semaphore_signal(_runnable->inquiryFinishedEvent); // , 0);
 }
 
- void GetRemoteDeviceRSSI::release() {
-    if (delegate != NULL) {
-        IOBluetoothHostController* controller = [IOBluetoothHostController defaultController];
-        [controller setDelegate:orig_delegate];
-        [delegate release];
-        delegate = NULL;
-    }
- }
-
-RUNNABLE(GetRemoteDeviceRSSIRelease, "GetRemoteDeviceRSSIRelease") {
-    GetRemoteDeviceRSSI* r = (GetRemoteDeviceRSSI*)pData[0];
-    r->release();
+- (void)connectionComplete:(IOBluetoothDevice *)device status:(IOReturn)status
+{
+    
 }
 
-#endif
-
-JNIEXPORT jint JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_readRemoteDeviceRSSIImpl
-  (JNIEnv *env, jobject, jlong address) {
-#ifdef AVAILABLE_BLUETOOTH_VERSION_2_0_AND_LATER
-    if (localDeviceSupportedSoftwareVersion < BLUETOOTH_VERSION_2_0) {
-        // Run on Tiger
-        throwIOException(env, "Not Supported on OS X Bluetooth API before 2.0");
-        return -1;
-    }
-    GetRemoteDeviceRSSI runnable;
-    runnable.jlData = address;
-    synchronousBTOperation(&runnable);
-
-    if ((stack != NULL) && (runnable.error == 0) && (!runnable.bData)) {
-        MPEventFlags flags;
-        MPWaitForEvent(runnable.inquiryFinishedEvent, &flags, kDurationMillisecond * 700);
-    }
-
-    GetRemoteDeviceRSSIRelease release;
-    release.pData[0] = &runnable;
-    synchronousBTOperation(&release);
-
-    if (runnable.error) {
-        switch (runnable.error) {
-        case 2:
-            throwIOException(env, "Error reading remote device RSSI, no connection");
-            break;
-        default:
-            throwIOException(env, "Error reading remote device RSSI [0x%08x]", runnable.lData);
-        }
-        return -1;
-    } else if (!runnable.bData) {
-        throwIOException(env, "Error reading remote device RSSI timeout");
-        return -1;
-    } else {
-        return runnable.iData;
-    }
-#else
-    throwIOException(env, "Not Supported on OS X Bluetooth API before 2.0");
-    return -1;
-#endif
+- (void)sdpQueryComplete:(IOBluetoothDevice *)device status:(IOReturn)status
+{
+    
 }
 
-JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackOSX_authenticateRemoteDeviceImpl
-  (JNIEnv *env, jobject, jlong address) {
-    //TODO
-    return JNI_FALSE;
-}
\ No newline at end of file
+
+@end
diff --git a/bluecove/src/main/c/intelbth/OSXStackL2CAP.mm b/bluecove/src/main/c/intelbth/OSXStackL2CAP.mm
index bc550402..84f06a94 100755
--- a/bluecove/src/main/c/intelbth/OSXStackL2CAP.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackL2CAP.mm
@@ -19,7 +19,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  *
- *  @version $Id: OSXStackRFCOMM.mm 1244 2007-11-27 04:06:32Z skarzhevskyy $
+ *  @version $Id$
  */
 
 #import "OSXStackL2CAP.h"
@@ -123,18 +123,18 @@ - (void)l2capChannelReconfigured:(IOBluetoothL2CAPChannel*)l2capChannel {
     } else {
         openStatus = status;
     }
-    MPSetEvent(notificationEvent, 1);
+    dispatch_semaphore_signal(notificationEvent); // , 1);
 }
 
 void L2CAPChannelController::l2capChannelOpenComplete(IOReturn error) {
     if (error == kIOReturnSuccess) {
         isConnected = true;
-        int incomingMTU = [l2capChannel getIncomingMTU];
+        int incomingMTU = l2capChannel.incomingMTU;
         if (receiveMTU > incomingMTU) {
             receiveMTU = incomingMTU;
         }
 
-        int remoteMtu = [l2capChannel getOutgoingMTU];
+        int remoteMtu = l2capChannel.outgoingMTU;
 	    if (transmitMTU == -1) {
 		    transmitMTU = remoteMtu;
 	    } else if (transmitMTU < remoteMtu) {
@@ -146,7 +146,7 @@ - (void)l2capChannelReconfigured:(IOBluetoothL2CAPChannel*)l2capChannel {
     } else {
         openStatus = error;
     }
-    MPSetEvent(notificationEvent, 1);
+    dispatch_semaphore_signal(notificationEvent); // , 1);
 }
 
 void L2CAPChannelController::openIncomingChannel(IOBluetoothL2CAPChannel* newL2CAPChannel) {
@@ -156,20 +156,21 @@ - (void)l2capChannelReconfigured:(IOBluetoothL2CAPChannel*)l2capChannel {
     l2capChannel = newL2CAPChannel;
     [l2capChannel retain];
     openStatus = [l2capChannel setDelegate:delegate];
-    bluetoothDevice = [l2capChannel getDevice];
+    bluetoothDevice = l2capChannel.device;
 }
 
 void L2CAPChannelController::l2capChannelClosed() {
     isClosed = true;
     isConnected = false;
-    MPSetEvent(notificationEvent, 0);
-    MPSetEvent(writeCompleteNotificationEvent, 0);
+
+    dispatch_semaphore_signal(notificationEvent); // , 0);
+    dispatch_semaphore_signal(writeCompleteNotificationEvent); // , 0);
 }
 
 void L2CAPChannelController::l2capChannelData(void* dataPointer, size_t dataLength) {
     if (isConnected && !isClosed) {
 	    receiveBuffer.write_with_len(dataPointer, dataLength);
-		MPSetEvent(notificationEvent, 1);
+        dispatch_semaphore_signal(notificationEvent); // , 1);
     }
 }
 
@@ -177,7 +178,7 @@ - (void)l2capChannelReconfigured:(IOBluetoothL2CAPChannel*)l2capChannel {
     if (refcon != NULL) {
         ((L2CAPConnectionWrite*)refcon)->l2capChannelWriteComplete(error);
     }
-    MPSetEvent(writeCompleteNotificationEvent, 1);
+    dispatch_semaphore_signal(writeCompleteNotificationEvent); // , 1);
 }
 
 IOReturn L2CAPChannelController::close() {
@@ -188,10 +189,11 @@ - (void)l2capChannelReconfigured:(IOBluetoothL2CAPChannel*)l2capChannel {
     }
     if (l2capChannel != NULL) {
         isClosed = true;
-        MPSetEvent(notificationEvent, 0);
-        MPSetEvent(writeCompleteNotificationEvent, 0);
 
-        IOBluetoothDevice *device = [l2capChannel getDevice];
+        dispatch_semaphore_signal(notificationEvent); // , 0);
+        dispatch_semaphore_signal(writeCompleteNotificationEvent); // , 0);
+        
+        IOBluetoothDevice *device = l2capChannel.device;
         [l2capChannel setDelegate:NULL];
         rc = [l2capChannel closeChannel];
         if (device != NULL) {
@@ -386,12 +388,7 @@ long L2CAPChannelCloseExec(L2CAPChannelController* comm) {
 
 	while ((stack != NULL) && comm->isConnected  && (!comm->isClosed) && (comm->receiveBuffer.available() <= paketLengthSize)) {
 		Edebug(("receive[] waits for data"));
-		MPEventFlags flags;
-        OSStatus err = MPWaitForEvent(comm->notificationEvent, &flags, kDurationMillisecond * 500);
-		if ((err != kMPTimeoutErr) && (err != noErr)) {
-			throwRuntimeException(env, "MPWaitForEvent");
-			return 0;
-		}
+        dispatch_semaphore_wait(comm->notificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 		if (isCurrentThreadInterrupted(env, peer, "receive")) {
 			return 0;
 		}
@@ -499,15 +496,11 @@ long L2CAPChannelCloseExec(L2CAPChannelController* comm) {
             if (runnable.writeComplete) {
                 break;
             }
-            MPEventFlags flags;
-            OSStatus err = MPWaitForEvent(comm->writeCompleteNotificationEvent, &flags, kDurationMillisecond * 500);
-            if (err == kMPTimeoutErr) {
+            long result = dispatch_semaphore_wait(comm->writeCompleteNotificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
+            if (result != 0) {
+                // Timeout occured
                 continue;
             }
-		    if ((err != kMPTimeoutErr) && (err != noErr)) {
-			    throwRuntimeException(env, "MPWaitForEvent");
-			    break;
-		    }
             if (isCurrentThreadInterrupted(env, peer, "send")) {
 			    break;
 		    }
@@ -544,7 +537,7 @@ long L2CAPChannelCloseExec(L2CAPChannelController* comm) {
         error = 1;
         return;
     }
-    IOBluetoothDevice* device = [comm->l2capChannel getDevice];
+    IOBluetoothDevice* device = comm->l2capChannel.device;
     if (device == NULL) {
         error = 1;
         return;
diff --git a/bluecove/src/main/c/intelbth/OSXStackL2CAPServer.mm b/bluecove/src/main/c/intelbth/OSXStackL2CAPServer.mm
index f4b76bb9..67cb09e9 100755
--- a/bluecove/src/main/c/intelbth/OSXStackL2CAPServer.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackL2CAPServer.mm
@@ -70,7 +70,7 @@
 	}
 
     // cleanup
-	IOBluetoothObjectRelease(serviceRecordRef);
+	//IOBluetoothObjectRelease(serviceRecordRef);
 
 	return status;
 }
@@ -114,14 +114,14 @@
 	}
 
     // cleanup
-	IOBluetoothObjectRelease(serviceRecordRef);
+	//IOBluetoothObjectRelease(serviceRecordRef);
 
     return kIOReturnSuccess;
 }
 
 void L2CAPServerController::close() {
     isClosed = true;
-    MPSetEvent(incomingChannelNotificationEvent, 0);
+    dispatch_semaphore_signal(incomingChannelNotificationEvent); // , 0);
 
     if (sdpServiceRecordHandle != 0) {
         IOBluetoothRemoveServiceWithRecordHandle(sdpServiceRecordHandle);
@@ -317,7 +317,7 @@ void l2capServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNotif
 	    return;
 	}
 	if (comm->authenticate) {
-	    IOBluetoothDevice* device = [l2capChannel getDevice];
+	    IOBluetoothDevice* device = l2capChannel.device;
 	    if (device == NULL) {
 	        ndebug(("drop incomming connection unable to get device"));
 	        [l2capChannel closeChannel];
@@ -338,7 +338,7 @@ void l2capServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNotif
 	}
 	client->openIncomingChannel(l2capChannel);
 	comm->openningClient = true;
-    MPSetEvent(comm->incomingChannelNotificationEvent, 0);
+    dispatch_semaphore_signal(comm->incomingChannelNotificationEvent);
 }
 
 RUNNABLE(L2CAPServiceRegisterForOpen, "L2CAPServiceRegisterForOpen") {
@@ -357,12 +357,7 @@ void l2capServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNotif
 	}
 	// Avoid more than once Accept at the same time
 	while ((stack != NULL) && (!comm->isClosed) && (comm->acceptClientComm != NULL)) {
-		MPEventFlags flags;
-        OSStatus err = MPWaitForEvent(comm->acceptedEvent, &flags, kDurationMillisecond * 500);
-		if ((err != kMPTimeoutErr) && (err != noErr)) {
-			throwRuntimeException(env, "MPWaitForEvent");
-			return 0;
-		}
+        dispatch_semaphore_wait(comm->acceptedEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 		if (isCurrentThreadInterrupted(env, peer, "close")) {
 			return 0;
 		}
@@ -398,13 +393,7 @@ void l2capServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNotif
     comm->openningClient = false;
     BOOL error = false;
 	while ((stack != NULL) && (!comm->isClosed) && (comm->openningClient == false)) {
-		MPEventFlags flags;
-        OSStatus err = MPWaitForEvent(comm->incomingChannelNotificationEvent, &flags, kDurationMillisecond * 500);
-		if ((err != kMPTimeoutErr) && (err != noErr)) {
-			throwRuntimeException(env, "MPWaitForEvent");
-			error = true;
-			break;
-		}
+        dispatch_semaphore_wait(comm->incomingChannelNotificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 		if (isCurrentThreadInterrupted(env, peer, "accept")) {
 			error = true;
 			break;
@@ -412,7 +401,7 @@ void l2capServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNotif
 	}
 	if ((stack != NULL) && (!comm->isClosed)) {
 	    comm->acceptClientComm = NULL;
-	    MPSetEvent(comm->acceptedEvent, 0);
+        dispatch_semaphore_signal(comm->acceptedEvent);
     }
 
 	if ((error) || (stack == NULL) || (comm->isClosed) || (!comm->openningClient)) {
diff --git a/bluecove/src/main/c/intelbth/OSXStackRFCOMM.mm b/bluecove/src/main/c/intelbth/OSXStackRFCOMM.mm
index b1432856..28dd8dbc 100755
--- a/bluecove/src/main/c/intelbth/OSXStackRFCOMM.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackRFCOMM.mm
@@ -24,6 +24,8 @@
 
 #import "OSXStackRFCOMM.h"
 
+#import <dispatch/dispatch.h>
+
 #define CPP_FILE "OSXStackRFCOMM.mm"
 
 BOOL isValidObject(RFCOMMChannelController* comm ) {
@@ -132,7 +134,7 @@ - (void)rfcommChannelQueueSpaceAvailable:(IOBluetoothRFCOMMChannel*)rfcommChanne
     } else {
         openStatus = status;
     }
-    MPSetEvent(notificationEvent, 1);
+    dispatch_semaphore_signal(notificationEvent); // , 1);
 }
 
 void RFCOMMChannelController::rfcommChannelOpenComplete(IOReturn error) {
@@ -143,7 +145,7 @@ - (void)rfcommChannelQueueSpaceAvailable:(IOBluetoothRFCOMMChannel*)rfcommChanne
     } else {
         openStatus = error;
     }
-    MPSetEvent(notificationEvent, 1);
+    dispatch_semaphore_signal(notificationEvent); // , 1);
 }
 
 void RFCOMMChannelController::openIncomingChannel(IOBluetoothRFCOMMChannel* newRfcommChannel) {
@@ -159,15 +161,15 @@ - (void)rfcommChannelQueueSpaceAvailable:(IOBluetoothRFCOMMChannel*)rfcommChanne
 void RFCOMMChannelController::rfcommChannelClosed() {
     ndebug(("rfcommChannelClosed"));
     isClosed = true;
-    MPSetEvent(notificationEvent, 0);
-    MPSetEvent(writeCompleteNotificationEvent, 0);
+    dispatch_semaphore_signal(notificationEvent); // , 0);
+    dispatch_semaphore_signal(writeCompleteNotificationEvent); // , 0);
 }
 
 void RFCOMMChannelController::rfcommChannelData(void* dataPointer, size_t dataLength) {
     ndebug(("rfcommChannelData"));
     if (isConnected && !isClosed) {
         receiveBuffer.write(dataPointer, dataLength);
-		MPSetEvent(notificationEvent, 1);
+		dispatch_semaphore_signal(notificationEvent); // , 1);
     }
 }
 
@@ -175,7 +177,7 @@ - (void)rfcommChannelQueueSpaceAvailable:(IOBluetoothRFCOMMChannel*)rfcommChanne
     if (refcon != NULL) {
         ((RFCOMMConnectionWrite*)refcon)->rfcommChannelWriteComplete(error);
     }
-    MPSetEvent(writeCompleteNotificationEvent, 1);
+    dispatch_semaphore_signal(writeCompleteNotificationEvent); // , 1);
 }
 
 IOReturn RFCOMMChannelController::close() {
@@ -185,8 +187,8 @@ - (void)rfcommChannelQueueSpaceAvailable:(IOBluetoothRFCOMMChannel*)rfcommChanne
     }
     if (rfcommChannel != NULL) {
         isClosed = true;
-        MPSetEvent(notificationEvent, 0);
-        MPSetEvent(writeCompleteNotificationEvent, 0);
+        dispatch_semaphore_signal(notificationEvent); // , 0);
+        dispatch_semaphore_signal(writeCompleteNotificationEvent); // , 0);
 
         IOBluetoothDevice *device = [rfcommChannel getDevice];
         [rfcommChannel setDelegate:NULL];
@@ -378,12 +380,7 @@ long RFCOMMChannelCloseExec(RFCOMMChannelController* comm) {
 		return 0;
 	}
 	while ((stack != NULL) && comm->isConnected && (!comm->isClosed) && (comm->receiveBuffer.available() == 0)) {
-		MPEventFlags flags;
-        OSStatus err = MPWaitForEvent(comm->notificationEvent, &flags, kDurationMillisecond * 500);
-		if ((err != kMPTimeoutErr) && (err != noErr)) {
-			throwRuntimeException(env, "MPWaitForEvent");
-			return 0;
-		}
+        dispatch_semaphore_wait(comm->notificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 		if (isCurrentThreadInterrupted(env, peer, "read")) {
 			return 0;
 		}
@@ -414,13 +411,9 @@ long RFCOMMChannelCloseExec(RFCOMMChannelController* comm) {
 	int done = 0;
 	while ((stack != NULL) && comm->isConnected && (!comm->isClosed) && (done < len)) {
 		while ((stack != NULL) && comm->isConnected  && (!comm->isClosed) && (comm->receiveBuffer.available() == 0)) {
-			MPEventFlags flags;
-            OSStatus err = MPWaitForEvent(comm->notificationEvent, &flags, kDurationMillisecond * 500);
-		    if ((err != kMPTimeoutErr) && (err != noErr)) {
-			    throwRuntimeException(env, "MPWaitForEvent");
-			    return 0;
-		    }
+            dispatch_semaphore_wait(comm->notificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 			if (isCurrentThreadInterrupted(env, peer, "read")) {
+				debug(("Interrupted while reading"));
 				return 0;
 			}
 		}
@@ -538,16 +531,11 @@ long RFCOMMChannelCloseExec(RFCOMMChannelController* comm) {
                 debug(("rfcomm wait for writeComplete %i, %i of %i", waitCount, done, len));
             }
             waitCount ++;
-            MPEventFlags flags;
-            OSStatus err = MPWaitForEvent(comm->writeCompleteNotificationEvent, &flags, kDurationMillisecond * 500);
-            if (err == kMPTimeoutErr) {
+            long result = dispatch_semaphore_wait(comm->writeCompleteNotificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
+            if (result != 0) {
+                // Timeout occured
                 continue;
             }
-		    if ((err != kMPTimeoutErr) && (err != noErr)) {
-			    throwRuntimeException(env, "MPWaitForEvent");
-			    error = true;
-			    break;
-		    }
             if (isCurrentThreadInterrupted(env, peer, "write")) {
 			    error = true;
 			    break;
diff --git a/bluecove/src/main/c/intelbth/OSXStackRFCOMMServer.mm b/bluecove/src/main/c/intelbth/OSXStackRFCOMMServer.mm
index 07f0ab32..eebeb4fb 100755
--- a/bluecove/src/main/c/intelbth/OSXStackRFCOMMServer.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackRFCOMMServer.mm
@@ -65,9 +65,6 @@
 	    }
 	}
 
-    // cleanup
-	IOBluetoothObjectRelease(serviceRecordRef);
-
 	return status;
 }
 
@@ -108,15 +105,12 @@
 	    }
 	}
 
-    // cleanup
-	IOBluetoothObjectRelease(serviceRecordRef);
-
     return kIOReturnSuccess;
 }
 
 void RFCOMMServerController::close() {
     isClosed = true;
-    MPSetEvent(incomingChannelNotificationEvent, 0);
+    dispatch_semaphore_signal(incomingChannelNotificationEvent); // , 0);
 
     if (sdpServiceRecordHandle != 0) {
         IOBluetoothRemoveServiceWithRecordHandle(sdpServiceRecordHandle);
@@ -303,7 +297,7 @@ void rfcommServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNoti
 	}
 	client->openIncomingChannel(rfcommChannel);
 	comm->openningClient = true;
-    MPSetEvent(comm->incomingChannelNotificationEvent, 0);
+    dispatch_semaphore_signal(comm->incomingChannelNotificationEvent); // , 0);
 }
 
 RUNNABLE(RFCOMMServiceRegisterForOpen, "RFCOMMServiceRegisterForOpen") {
@@ -321,13 +315,9 @@ void rfcommServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNoti
 		return 0;
 	}
 	while ((stack != NULL) && (!comm->isClosed) && (comm->acceptClientComm != NULL)) {
-		MPEventFlags flags;
-        OSStatus err = MPWaitForEvent(comm->acceptedEvent, &flags, kDurationMillisecond * 500);
-		if ((err != kMPTimeoutErr) && (err != noErr)) {
-			throwRuntimeException(env, "MPWaitForEvent");
-			return 0;
-		}
+        dispatch_semaphore_wait(comm->acceptedEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 		if (isCurrentThreadInterrupted(env, peer, "close")) {
+			debug(("Interrupted while waiting for connections"));
 			return 0;
 		}
 	}
@@ -360,21 +350,16 @@ void rfcommServiceOpenNotificationCallback(void *userRefCon, IOBluetoothUserNoti
     comm->openningClient = false;
     BOOL error = false;
 	while ((stack != NULL) && (!comm->isClosed) && (comm->openningClient == false)) {
-		MPEventFlags flags;
-        OSStatus err = MPWaitForEvent(comm->incomingChannelNotificationEvent, &flags, kDurationMillisecond * 500);
-		if ((err != kMPTimeoutErr) && (err != noErr)) {
-			throwRuntimeException(env, "MPWaitForEvent");
-			error = true;
-			break;
-		}
+        dispatch_semaphore_wait(comm->incomingChannelNotificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
 		if (isCurrentThreadInterrupted(env, peer, "accept")) {
+			debug(("Interrupted while waiting for connections"));
 			error = true;
 			break;
 		}
 	}
 	if ((stack != NULL) && (!comm->isClosed)) {
 	    comm->acceptClientComm = NULL;
-	    MPSetEvent(comm->acceptedEvent, 0);
+	    dispatch_semaphore_signal(comm->acceptedEvent); // , 0);
     }
 
 	if ((error) || (stack == NULL) || (comm->isClosed) || (!comm->openningClient)) {
diff --git a/bluecove/src/main/c/intelbth/OSXStackSDPQuery.h b/bluecove/src/main/c/intelbth/OSXStackSDPQuery.h
index 08292ae0..72c6683a 100755
--- a/bluecove/src/main/c/intelbth/OSXStackSDPQuery.h
+++ b/bluecove/src/main/c/intelbth/OSXStackSDPQuery.h
@@ -26,19 +26,36 @@
 
 #include "OSXStack.h"
 
+#import <IOBluetooth/IOBluetooth.h>
+
+class StackSDPQueryStart;
+
+@interface SDPQueryHandler : NSObject <IOBluetoothDeviceAsyncCallbacks>
+{
+    StackSDPQueryStart* _owner;
+}
+
+-(id)initWithOwner:(StackSDPQueryStart*)owner;
+
+-(void)sdpQueryComplete:(IOBluetoothDevice *)device status:(IOReturn)status;
+
+@end
+
 class StackSDPQueryStart: public Runnable {
 public:
     volatile BOOL complete;
     jlong address;
-    CFAbsoluteTime startTime;
+    NSDate* startTime;
     volatile IOReturn status;
     volatile int recordsSize;
-    IOBluetoothDeviceRef deviceRef;
-
+    
+    IOBluetoothDevice* device;
+    SDPQueryHandler*    handler;
+    
     StackSDPQueryStart();
     virtual void run();
 
-    void sdpQueryComplete(IOBluetoothDeviceRef deviceRef, IOReturn status);
+    void sdpQueryComplete(IOBluetoothDevice* device, IOReturn status);
 };
 
 #define DATA_BLOB_MAX  0x4000
@@ -56,7 +73,7 @@ class GetAttributeDataElement: public Runnable {
     GetAttributeDataElement();
     virtual void run();
 
-    void getData(const IOBluetoothSDPDataElementRef dataElement);
+    void getData(const IOBluetoothSDPDataElement* dataElement);
 };
 
 class SDPOutputStream {
@@ -70,7 +87,7 @@ class SDPOutputStream {
     void write(const UInt8 *bytes, CFIndex length);
     void writeLong(UInt64 l, int size);
 
-    BOOL writeElement(const IOBluetoothSDPDataElementRef dataElement);
-    int getLength(const IOBluetoothSDPDataElementRef dataElement);
+    BOOL writeElement(const IOBluetoothSDPDataElement* dataElement);
+    int getLength(const IOBluetoothSDPDataElement* dataElement);
     void getBytes(int max, int*  dataLen, UInt8* buf);
-};
\ No newline at end of file
+};
diff --git a/bluecove/src/main/c/intelbth/OSXStackSDPQuery.mm b/bluecove/src/main/c/intelbth/OSXStackSDPQuery.mm
index cd9d4cd5..7dc56b9b 100644
--- a/bluecove/src/main/c/intelbth/OSXStackSDPQuery.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackSDPQuery.mm
@@ -24,10 +24,44 @@
 
 #import "OSXStackSDPQuery.h"
 
+#import <IOBluetooth/IOBluetooth.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <CoreFoundation/CFDate.h>
+
 #define CPP_FILE "OSXStackSDPQuery.mm"
 
 #define MAX_TERMINATE 10
 
+@implementation SDPQueryHandler
+
+-(id)initWithOwner:(StackSDPQueryStart *)owner
+{
+    if ((self = [super init]) != nil) {
+        _owner = owner;
+    }
+    
+    return self;
+}
+
+-(void)sdpQueryComplete:(IOBluetoothDevice *)device status:(IOReturn)status
+{
+    if (_owner != NULL) {
+        _owner->sdpQueryComplete(device, status);
+    }
+}
+
+-(void)connectionComplete:(IOBluetoothDevice *)device status:(IOReturn)status
+{
+    
+}
+
+- (void)remoteNameRequestComplete:(IOBluetoothDevice *)device status:(IOReturn)status
+{
+    
+}
+
+@end
+
 jint terminatedTansID[MAX_TERMINATE] = {0};
 jint runningTansID[MAX_TERMINATE] = {0};
 void* searchServicesIgnore[MAX_TERMINATE] = {0};
@@ -54,59 +88,69 @@ BOOL isSearchServicesIgnore(void* ptr) {
 StackSDPQueryStart::StackSDPQueryStart() {
     name = "StackSDPQueryStart";
     complete = FALSE;
-    deviceRef = NULL;
+    device = nil;
+    handler = nil;
     error = 0;
 }
 
+/*
 void callbackSDPQueryIsComplete(void* userRefCon, IOBluetoothDeviceRef deviceRef, IOReturn status) {
     if ((!isSearchServicesIgnore(userRefCon)) && (!isRunnableCorrupted((StackSDPQueryStart*)userRefCon))) {
         ((StackSDPQueryStart*)userRefCon)->sdpQueryComplete(deviceRef, status);
     }
 }
+*/
 
 void StackSDPQueryStart::run() {
-    startTime = CFAbsoluteTimeGetCurrent();
+    startTime = [[NSDate date] retain];
 
     BluetoothDeviceAddress btAddress;
     LongToOSxBTAddr(address, &btAddress);
-    deviceRef = IOBluetoothDeviceCreateWithAddress(&btAddress);
-    if (deviceRef == NULL) {
+    device = [IOBluetoothDevice deviceWithAddress:(const BluetoothDeviceAddress*)&btAddress];
+    if (device == NULL) {
         error = 1;
         return;
     }
-    status = IOBluetoothDevicePerformSDPQuery(deviceRef, callbackSDPQueryIsComplete, this);
-    if (kIOReturnSuccess != status) {
-        error = 1;
-    }
+    
+    handler = [[SDPQueryHandler alloc] initWithOwner:this];
+    
+    [device performSDPQuery:handler];
 }
 
-void StackSDPQueryStart::sdpQueryComplete(IOBluetoothDeviceRef deviceRef, IOReturn status) {
+void StackSDPQueryStart::sdpQueryComplete(IOBluetoothDevice* device, IOReturn status)
+{
     ndebug(("sdpQueryComplete 0x%08x", status));
+    [handler release];
     this->status = status;
+
     // Apperantly connection to device is still open after SDP query for some time. This may affect other connections.
-    if (deviceRef != NULL) {
-        IOBluetoothDeviceCloseConnection(deviceRef);
+    if (device != nil) {
+        [device closeConnection];
     }
+    
     if (kIOReturnSuccess != status) {
-        this->error = 1;
-    } else {
-        CFArrayRef services = IOBluetoothDeviceGetServices(deviceRef);
+        error = 1;
+    }
+    else {
+        NSArray* services = [device services];
+        
         if (services != NULL) {
-            recordsSize = CFArrayGetCount(services);
-            CFDateRef startDate = CFDateCreate(kCFAllocatorDefault, startTime);
-            CFDateRef updatedTime = IOBluetoothDeviceGetLastServicesUpdate(deviceRef);
-            if (CFDateGetTimeIntervalSinceDate(updatedTime, startDate) < 0) {
+            recordsSize = [services count];
+            NSDate* updatedTime = [device lastNameUpdate];
+            if ([updatedTime compare:startTime] == NSOrderedDescending) {
                 this->status = kIOReturnNotFound;
-                this->error = 1;
+                error = 1;
             }
-            CFRelease(startDate);
-        } else {
+            [startTime release];
+        }
+        else {
             recordsSize = 0;
         }
     }
-    this->complete = TRUE;
+
+    complete = TRUE;
     if (stack != NULL) {
-        MPSetEvent(stack->deviceInquiryNotificationEvent, 1);
+        dispatch_semaphore_signal(stack->deviceInquiryNotificationEvent); // , 1);
     }
 }
 
@@ -146,8 +190,7 @@ void setSearchServicesEnds(jint transID) {
     runnable.address = address;
     synchronousBTOperation(&runnable);
     while ((stack != NULL) && (runnable.error == 0) && (!runnable.complete)) {
-        MPEventFlags flags;
-        MPWaitForEvent(stack->deviceInquiryNotificationEvent, &flags, kDurationMillisecond * 500);
+                dispatch_semaphore_wait(stack->deviceInquiryNotificationEvent, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_MSEC * 500));
         if (isSearchServicesTerminated(transID)) {
             setSearchServicesIgnore(&runnable);
             return 0;
@@ -180,7 +223,7 @@ void setSearchServicesEnds(jint transID) {
         if ((runningTansID[i] == transID) && (terminatedTansID[i] == 0)) {
             terminatedTansID[i] = transID;
             if (stack != NULL) {
-                MPSetEvent(stack->deviceInquiryNotificationEvent, 1);
+                dispatch_semaphore_signal(stack->deviceInquiryNotificationEvent); // , 1);
             }
             break;
         }
@@ -192,38 +235,48 @@ void setSearchServicesEnds(jint transID) {
 }
 
 void GetAttributeDataElement::run() {
+
     BluetoothDeviceAddress btAddress;
-    LongToOSxBTAddr(address, &btAddress);
-    IOBluetoothDeviceRef deviceRef = IOBluetoothDeviceCreateWithAddress(&btAddress);
-    if (deviceRef == NULL) {
+    LongToOSxBTAddr(this->address, &btAddress);
+    IOBluetoothDevice* device = [IOBluetoothDevice deviceWithAddress:(const BluetoothDeviceAddress*)&btAddress];
+    if (device == NULL) {
         error = 1;
         return;
     }
-    CFArrayRef services = IOBluetoothDeviceGetServices(deviceRef);
+    
+    NSArray* services = [device services];
+
     if (services == NULL) {
         error = 1;
         return;
     }
-    if (serviceRecordIndex >= CFArrayGetCount(services)) {
+    
+    if (serviceRecordIndex >= [services count]) {
         error = 1;
         return;
     }
-    IOBluetoothSDPServiceRecordRef serviceRef = (IOBluetoothSDPServiceRecordRef)CFArrayGetValueAtIndex(services, serviceRecordIndex);
-    IOBluetoothSDPDataElementRef dataElementRef = IOBluetoothSDPServiceRecordGetAttributeDataElement(serviceRef, attrID);
-    if (dataElementRef == NULL) {
+    
+    IOBluetoothSDPServiceRecord* service = (IOBluetoothSDPServiceRecord*)[services objectAtIndex:serviceRecordIndex];
+    IOBluetoothSDPDataElement* dataElement = [service getAttributeDataElement:attrID];
+    
+    if (dataElement == nil) {
         error = 1;
     }
-    getData(dataElementRef);
+    
+    getData(dataElement);
 }
 
-void GetAttributeDataElement::getData(const IOBluetoothSDPDataElementRef dataElement) {
+void GetAttributeDataElement::getData(const IOBluetoothSDPDataElement* dataElement)
+{
     if (dataElement == NULL) {
         return;
     }
+    
     SDPOutputStream os;
     if (!os.writeElement(dataElement)) {
         error = 1;
-    } else {
+    }
+    else {
         os.getBytes(DATA_BLOB_MAX, &dataLen, data);
     }
 }
@@ -247,7 +300,7 @@ void setSearchServicesEnds(jint transID) {
 void SDPOutputStream::writeLong(UInt64 l, int size) {
 	UInt64 v = l;
 	for (int i = 0; i < size; i++) {
-		write((UInt8) (0xFFLL & (v >> (size - 1 << 3))));
+		write((UInt8) (0xFFLL & (v >> ((size - 1) << 3))));
 		v <<= 8;
 	}
 }
@@ -258,10 +311,13 @@ void setSearchServicesEnds(jint transID) {
     (*dataLen) = len;
 }
 
-int SDPOutputStream::getLength(const IOBluetoothSDPDataElementRef dataElement) {
-    BluetoothSDPDataElementTypeDescriptor typeDescrip = IOBluetoothSDPDataElementGetTypeDescriptor(dataElement);
-    BluetoothSDPDataElementSizeDescriptor sizeDescriptor = IOBluetoothSDPDataElementGetSizeDescriptor(dataElement);
+int SDPOutputStream::getLength(const IOBluetoothSDPDataElement* dataElement)
+{
+    BluetoothSDPDataElementTypeDescriptor typeDescrip = [dataElement getTypeDescriptor];
+    BluetoothSDPDataElementSizeDescriptor sizeDescriptor = [dataElement getSizeDescriptor];
+    
     BOOL isURL = false;
+    
     switch (typeDescrip) {
         case kBluetoothSDPDataElementTypeNil:
             return 1;
@@ -278,11 +334,11 @@ void setSearchServicesEnds(jint transID) {
                 return 1 + length;
             }
         case kBluetoothSDPDataElementTypeUUID: {
-                IOBluetoothSDPUUIDRef	aUUIDRef = IOBluetoothSDPDataElementGetUUIDValue(dataElement);
+                IOBluetoothSDPUUID*	aUUIDRef = [dataElement getUUIDValue];
                 if (aUUIDRef == NULL) {
                     return -1;
                 }
-				UInt8 length = IOBluetoothSDPUUIDGetLength(aUUIDRef);
+				UInt8 length = [aUUIDRef length];
 				if (length <= 2) {
 				    return 1 + 2;
 				} else if (length <= 4) {
@@ -294,14 +350,16 @@ void setSearchServicesEnds(jint transID) {
         case kBluetoothSDPDataElementTypeURL:
             isURL = true;
 		case kBluetoothSDPDataElementTypeString: {
-		        CFStringRef str = IOBluetoothSDPDataElementGetStringValue(dataElement);
-		        if (str == NULL) {
+                NSString* str = [dataElement getStringValue];
+                if (str == NULL) {
                     return -1;
                 }
-                CFIndex strLength = CFStringGetLength(str);
-		        CFIndex usedBufLen = 0;
+                CFIndex strLength = [str length];
+		        NSUInteger usedBufLen = 0;
 		        CFStringEncoding encoding = isURL?kCFStringEncodingASCII:kCFStringEncodingUTF8;
-		        CFStringGetBytes(str, CFRangeMake(0, strLength), encoding, '?', true, NULL, 0, &usedBufLen);
+            
+                [str getBytes:NULL maxLength:strLength usedLength:&usedBufLen encoding:encoding options:NULL range:NSMakeRange(0, strLength) remainingRange:NULL];
+		        //CFStringGetBytes(str, CFRangeMake(0, strLength), encoding, '?', true, NULL, 0, &usedBufLen);
 		        if (usedBufLen < 0x100) {
 				    return usedBufLen + 2;
 			    } else if (usedBufLen < 0x10000) {
@@ -315,13 +373,13 @@ void setSearchServicesEnds(jint transID) {
         case kBluetoothSDPDataElementTypeDataElementSequence:
         case kBluetoothSDPDataElementTypeDataElementAlternative: {
             int len = 5;
-            CFArrayRef array = IOBluetoothSDPDataElementGetArrayValue(dataElement);
+            NSArray* array = [dataElement getArrayValue];
             if (array == NULL) {
                 return -1;
             }
-            CFIndex count = CFArrayGetCount(array);
+            CFIndex count = [array count];
             for(CFIndex i = 0; i < count; i++) {
-                const IOBluetoothSDPDataElementRef item = (IOBluetoothSDPDataElementRef)CFArrayGetValueAtIndex(array, i);
+                const IOBluetoothSDPDataElement* item = (IOBluetoothSDPDataElement*)[array objectAtIndex:i];
                 len += getLength(item);
             }
             return len;
@@ -332,40 +390,50 @@ void setSearchServicesEnds(jint transID) {
 }
 
 // See com.intel.bluetooth.SDPOutputStream
-BOOL SDPOutputStream::writeElement(const IOBluetoothSDPDataElementRef dataElement) {
-    BluetoothSDPDataElementTypeDescriptor typeDescrip = IOBluetoothSDPDataElementGetTypeDescriptor(dataElement);
-    BluetoothSDPDataElementSizeDescriptor sizeDescriptor = IOBluetoothSDPDataElementGetSizeDescriptor(dataElement);
+BOOL SDPOutputStream::writeElement(const IOBluetoothSDPDataElement* dataElement)
+{
+    BluetoothSDPDataElementTypeDescriptor typeDescrip = [dataElement getTypeDescriptor];
+    BluetoothSDPDataElementSizeDescriptor sizeDescriptor = [dataElement getSizeDescriptor];
+    
     ndebug(("sizeDescriptor %i", sizeDescriptor));
+    
     BOOL isSeq = false;
     BOOL isURL = false;
     BOOL isUnsigned = false;
     switch (typeDescrip) {
         case kBluetoothSDPDataElementTypeNil:
-            write(0 | 0);
+            {
+                write(0 | 0);
+            }
             break;
-        case kBluetoothSDPDataElementTypeBoolean: {
-            write(40 | 0);
-			CFNumberRef	bNumber = IOBluetoothSDPDataElementGetNumberValue(dataElement);
-			if (bNumber == NULL) {
-			    return FALSE;
-			}
-            UInt8 aBool;
-			CFNumberGetValue(bNumber, kCFNumberCharType, &aBool);
-			write(aBool);
+            
+        case kBluetoothSDPDataElementTypeBoolean:
+            {
+                write(40 | 0);
+                NSNumber* bNumber = [dataElement getNumberValue];
+                if (bNumber == NULL) {
+                    return FALSE;
+                }
+                UInt8 aBool = [bNumber boolValue];
+                write(aBool);
+            }
             break;
-        }
         case kBluetoothSDPDataElementTypeUnsignedInt:
-            isUnsigned = true;
-        case kBluetoothSDPDataElementTypeSignedInt: {
+            {
+                isUnsigned = true;
+            }
+            
+        case kBluetoothSDPDataElementTypeSignedInt:
+            {
                 UInt8 type = isUnsigned ? 8: 16;
                 ndebug(("processing number %i", type));
                 write(type | sizeDescriptor);
                 if (sizeDescriptor == 4) { /* 16 byte integer */
-				    CFDataRef bigData = IOBluetoothSDPDataElementGetDataValue(dataElement);
+                    NSData* bigData = [dataElement getDataValue];
 				    if (bigData == NULL) {
 				        return FALSE;
 				    }
-				    const UInt8 *byteArray = CFDataGetBytePtr(bigData);
+				    const UInt8 *byteArray = (UInt8 *)[bigData bytes];
 				    write(byteArray, 16);
 			    } else {
 			        int length;
@@ -375,24 +443,24 @@ void setSearchServicesEnds(jint transID) {
                         case 2: length = 4; break;
                         case 3: length = 8; break;
                     }
-				    CFNumberRef	number = IOBluetoothSDPDataElementGetNumberValue(dataElement);
+				    NSNumber* number = [dataElement getNumberValue];
 				    if (number == NULL) {
 				        return FALSE;
 				    }
-				    SInt64 l = 0LL;
-				    CFNumberGetValue(number, kCFNumberSInt64Type, &l);
-				    ndebug(("number len %i, %lli", length, l));
+				    SInt64 l = [number longLongValue];
+ 				    ndebug(("number len %i, %lli", length, l));
 				    writeLong(l, length);
 			    }
             }
             break;
+            
         case kBluetoothSDPDataElementTypeUUID: {
-                IOBluetoothSDPUUIDRef aUUIDRef = IOBluetoothSDPDataElementGetUUIDValue(dataElement);
+                IOBluetoothSDPUUID* aUUIDRef = [dataElement getUUIDValue];
                 if (aUUIDRef == NULL) {
                     return FALSE;
                 }
-			    const UInt8* uuidBytes = (UInt8*)IOBluetoothSDPUUIDGetBytes(aUUIDRef);
-				UInt8 length = IOBluetoothSDPUUIDGetLength(aUUIDRef);
+                const UInt8* uuidBytes = (UInt8*)[aUUIDRef bytes];
+            	UInt8 length = [aUUIDRef length];
 				UInt8 size = 0;
                 if (length <= 2) {
                     size = 2;
@@ -417,16 +485,16 @@ void setSearchServicesEnds(jint transID) {
             isURL = true;
 		case kBluetoothSDPDataElementTypeString: {
 		        UInt8 type = isURL ? 0x40: 0x20;
-		        CFStringRef str = IOBluetoothSDPDataElementGetStringValue(dataElement);
+		        NSString* str = [dataElement getStringValue];
 		        if (str == NULL) {
 		            return FALSE;
 		        }
-		        CFIndex strLength = CFStringGetLength(str);
+		        CFIndex strLength = [str length];
 		        CFIndex maxBufLen = 4* sizeof(UInt8)*strLength;
 		        UInt8* buffer = (UInt8*)malloc(maxBufLen);
-		        CFIndex usedBufLen = 0;
-		        CFStringEncoding encoding = isURL?kCFStringEncodingASCII:kCFStringEncodingUTF8;
-		        CFStringGetBytes(str, CFRangeMake(0, strLength), encoding, '?', false, buffer, maxBufLen, &usedBufLen);
+		        NSUInteger usedBufLen = 0;
+                CFStringEncoding encoding = isURL ? NSASCIIStringEncoding : NSUTF8StringEncoding;
+                [str getBytes:buffer maxLength:maxBufLen usedLength:&usedBufLen encoding:encoding options:NULL range:NSMakeRange(0, strLength) remainingRange:NULL];
 		        if (usedBufLen < 0x100) {
 				    write(type | 5);
 				    writeLong(usedBufLen, 1);
@@ -442,8 +510,10 @@ void setSearchServicesEnds(jint transID) {
 		    }
             break;
         case kBluetoothSDPDataElementTypeDataElementSequence:
-            isSeq = true;
-            write(48 | 7);
+            {
+                isSeq = true;
+                write(48 | 7);
+            }
         case kBluetoothSDPDataElementTypeDataElementAlternative: {
                 if (!isSeq) {
                     write(56 | 7);
@@ -453,13 +523,13 @@ void setSearchServicesEnds(jint transID) {
 		            return FALSE;
 		        }
                 writeLong(len - 5, 4);
-                CFArrayRef array = IOBluetoothSDPDataElementGetArrayValue(dataElement);
+                NSArray* array = [dataElement getArrayValue];
                 if (array == NULL) {
 		            return FALSE;
 		        }
-                CFIndex count = CFArrayGetCount(array);
+                CFIndex count = [array count];
                 for(CFIndex i = 0; i < count; i++) {
-                    const IOBluetoothSDPDataElementRef item = (IOBluetoothSDPDataElementRef)CFArrayGetValueAtIndex(array, i);
+                    const IOBluetoothSDPDataElement* item = (IOBluetoothSDPDataElement*)[array objectAtIndex:i];
                     if (!writeElement(item)) {
                         return FALSE;
                     }
@@ -487,4 +557,4 @@ void setSearchServicesEnds(jint transID) {
 	memcpy(bytes, runnable.data, runnable.dataLen);
 	env->ReleaseByteArrayElements(result, bytes, 0);
 	return result;
-}
\ No newline at end of file
+}
diff --git a/bluecove/src/main/c/intelbth/OSXStackSDPServer.h b/bluecove/src/main/c/intelbth/OSXStackSDPServer.h
index aaf80140..597415fd 100755
--- a/bluecove/src/main/c/intelbth/OSXStackSDPServer.h
+++ b/bluecove/src/main/c/intelbth/OSXStackSDPServer.h
@@ -44,19 +44,19 @@ class ServerController : public PoolableObject {
     int sdpSequenceDepthCurrent;
     NSMutableArray *sdpSequence[SDP_SEQUENCE_DEPTH_MAX];
 
-    MPEventID incomingChannelNotificationEvent;
+    dispatch_semaphore_t incomingChannelNotificationEvent;
     IOBluetoothUserNotificationRef incomingChannelNotification;
 
-    MPEventID acceptedEvent;
+    dispatch_semaphore_t acceptedEvent;
     volatile BOOL openningClient;
 
 public:
     ServerController();
     virtual ~ServerController();
 
-    char* addAttribute(SDPAttributeValue* value);
-    char* addAttributeSequence(jint attrID, jint attrType);
-    char* addDataElement(jint attrID, NSObject* value);
+    const char* addAttribute(SDPAttributeValue* value);
+    const char* addAttributeSequence(jint attrID, jint attrType);
+    const char* addDataElement(jint attrID, NSObject* value);
 
     void init();
     virtual IOReturn updateSDPServiceRecord() = 0;
diff --git a/bluecove/src/main/c/intelbth/OSXStackSDPServer.mm b/bluecove/src/main/c/intelbth/OSXStackSDPServer.mm
index ffd009af..b561b96c 100755
--- a/bluecove/src/main/c/intelbth/OSXStackSDPServer.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackSDPServer.mm
@@ -19,7 +19,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  *
- *  @version $Id: OSXStackRFCOMMServer.h 1303 2007-12-04 00:23:11Z skarzhevskyy $
+ *  @version $Id$
  */
 
 #import "OSXStackSDPServer.h"
@@ -48,20 +48,20 @@
         sdpSequence[i] = NULL;
     }
     incomingChannelNotification = NULL;
-    MPCreateEvent(&incomingChannelNotificationEvent);
-    MPCreateEvent(&acceptedEvent);
+    incomingChannelNotificationEvent = dispatch_semaphore_create(0);
+    acceptedEvent = dispatch_semaphore_create(0);
 }
 
 ServerController::~ServerController() {
     isClosed = true;
-    MPSetEvent(incomingChannelNotificationEvent, 0);
-    MPDeleteEvent(incomingChannelNotificationEvent);
-    MPSetEvent(acceptedEvent, 0);
-    MPDeleteEvent(acceptedEvent);
+    dispatch_semaphore_signal(incomingChannelNotificationEvent); // , 0);
+    dispatch_release(incomingChannelNotificationEvent);
+    dispatch_semaphore_signal(acceptedEvent); // , 0);
+    dispatch_release(acceptedEvent);
 }
 
 void ServerController::init() {
-    sdpEntries = [NSMutableDictionary dictionaryWithCapacity:256];
+    sdpEntries = [[NSMutableDictionary dictionaryWithCapacity:256] retain];
 }
 
 ServerController* validServerControllerHandle(JNIEnv *env, jlong handle, jchar handleType) {
@@ -115,7 +115,7 @@
     return dict;
 }
 
-char* ServerController::addAttributeSequence(jint attrID, jint attrType) {
+const char* ServerController::addAttributeSequence(jint attrID, jint attrType) {
     if (attrType == -1) {
         if (sdpSequenceDepthCurrent < 0) {
             return "Sequence End overflow";
@@ -149,25 +149,25 @@
     return NULL;
 }
 
-char* ServerController::addDataElement(jint attrID, NSObject* value) {
+const char* ServerController::addDataElement(jint attrID, NSObject* value) {
     if ((attrID < 0) && (sdpSequenceDepthCurrent < 0)) {
         return "sequence expected";
     }
     if (sdpSequenceDepthCurrent >= 0) {
         [sdpSequence[sdpSequenceDepthCurrent] addObject:value];
     } else {
-        NSString *keyName = [NSString stringWithFormat:@"%03x",  attrID];
+        NSString *keyName = [NSString stringWithFormat:@"%03lx",  (long) attrID];
         [sdpEntries setObject:value forKey:keyName];
     }
     return NULL;
 }
 
-char* ServerController::addAttribute(SDPAttributeValue* value) {
+const char* ServerController::addAttribute(SDPAttributeValue* value) {
     BluetoothSDPDataElementTypeDescriptor newType;
     UInt32 newSize;
     NSObject* newValue;
 
-    char* rc = NULL;
+    const char* rc = NULL;
 
     switch (value->attrType) {
     case DATA_ELEMENT_TYPE_U_INT_1:
@@ -313,7 +313,7 @@
 	}
 	SDPServiceAddAttribute runnable;
 	runnable.pData[0] = comm;
-
+      
 	SDPAttributeValue value = {0};
 	runnable.pData[1] = &value;
 
diff --git a/bluecove/src/main/c/intelbth/OSXStackTest.mm b/bluecove/src/main/c/intelbth/OSXStackTest.mm
index 23b05a37..ec469432 100644
--- a/bluecove/src/main/c/intelbth/OSXStackTest.mm
+++ b/bluecove/src/main/c/intelbth/OSXStackTest.mm
@@ -45,146 +45,177 @@ void tdebug(const char *fmt, ...) {
     va_end(ap);
 }
 
-IOBluetoothSDPDataElementRef createTestDataElementSimple(jint type, jlong ldata, jbyte *bytes, int inBytesLen) {
+IOBluetoothSDPDataElement* createTestDataElementSimple(jint type, jlong ldata, jbyte *bytes, int inBytesLen) {
     BluetoothSDPDataElementTypeDescriptor newType;
     BluetoothSDPDataElementSizeDescriptor newSizeDescriptor;
     UInt32 newSize;
     NSObject* newValue;
     switch (type) {
-    case DATA_ELEMENT_TYPE_U_INT_1: {
-        newType = kBluetoothSDPDataElementTypeUnsignedInt;
-        newSizeDescriptor = 0;
-        newSize = 1;
-        newValue = [NSNumber numberWithUnsignedInt:((unsigned int)ldata)];
+        case DATA_ELEMENT_TYPE_U_INT_1:
+        {
+            newType = kBluetoothSDPDataElementTypeUnsignedInt;
+            newSizeDescriptor = 0;
+            newSize = 1;
+            newValue = [NSNumber numberWithUnsignedInt:((unsigned int)ldata)];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_U_INT_2: {
-        newType = kBluetoothSDPDataElementTypeUnsignedInt;
-        newSizeDescriptor = 1;
-        newSize = 2;
-        newValue = [NSNumber numberWithUnsignedInt:((unsigned int)ldata)];
+            
+    case DATA_ELEMENT_TYPE_U_INT_2:
+        {
+            newType = kBluetoothSDPDataElementTypeUnsignedInt;
+            newSizeDescriptor = 1;
+            newSize = 2;
+            newValue = [NSNumber numberWithUnsignedInt:((unsigned int)ldata)];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_U_INT_4: {
-        newType = kBluetoothSDPDataElementTypeUnsignedInt;
-        newSizeDescriptor = 2;
-        newSize = 4;
-        newValue = [NSNumber numberWithUnsignedLong:((unsigned long)ldata)];
+            
+    case DATA_ELEMENT_TYPE_U_INT_4:
+        {
+            newType = kBluetoothSDPDataElementTypeUnsignedInt;
+            newSizeDescriptor = 2;
+            newSize = 4;
+            newValue = [NSNumber numberWithUnsignedLong:((unsigned long)ldata)];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_INT_1: {
-        newType = kBluetoothSDPDataElementTypeSignedInt;
-        newSizeDescriptor = 0;
-        newSize = 1;
-        newValue = [NSNumber numberWithInt:((int)ldata)];
+            
+    case DATA_ELEMENT_TYPE_INT_1:
+        {
+            newType = kBluetoothSDPDataElementTypeSignedInt;
+            newSizeDescriptor = 0;
+            newSize = 1;
+            newValue = [NSNumber numberWithInt:((int)ldata)];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_INT_2: {
-        newType = kBluetoothSDPDataElementTypeSignedInt;
-        newSizeDescriptor = 1;
-        newSize = 2;
-        newValue = [NSNumber numberWithInt:((int)ldata)];
+            
+    case DATA_ELEMENT_TYPE_INT_2:
+        {
+            newType = kBluetoothSDPDataElementTypeSignedInt;
+            newSizeDescriptor = 1;
+            newSize = 2;
+            newValue = [NSNumber numberWithInt:((int)ldata)];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_INT_4: {
-        newType = kBluetoothSDPDataElementTypeSignedInt;
-        newSizeDescriptor = 2;
-        newSize = 4;
-        newValue = [NSNumber numberWithLong:ldata];
+            
+    case DATA_ELEMENT_TYPE_INT_4:
+        {
+            newType = kBluetoothSDPDataElementTypeSignedInt;
+            newSizeDescriptor = 2;
+            newSize = 4;
+            newValue = [NSNumber numberWithLong:ldata];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_INT_8: {
-        newType = kBluetoothSDPDataElementTypeSignedInt;
-        newSizeDescriptor = 3;
-        newSize = 8;
-        newValue = [NSNumber numberWithLongLong:ldata];
+            
+    case DATA_ELEMENT_TYPE_INT_8:
+        {
+            newType = kBluetoothSDPDataElementTypeSignedInt;
+            newSizeDescriptor = 3;
+            newSize = 8;
+            newValue = [NSNumber numberWithLongLong:ldata];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_U_INT_8: {
-        newType = kBluetoothSDPDataElementTypeUnsignedInt;
-        newSizeDescriptor = 3;
-        newSize = 8;
+            
+    case DATA_ELEMENT_TYPE_U_INT_8:
         {
-            jbyte rbytes[8];
-            for(int i = 0; i < 8; i ++) {
-                rbytes[i] = bytes[7 - i];
+            newType = kBluetoothSDPDataElementTypeUnsignedInt;
+            newSizeDescriptor = 3;
+            newSize = 8;
+            {
+                jbyte rbytes[8];
+                for(int i = 0; i < 8; i ++) {
+                    rbytes[i] = bytes[7 - i];
+                }
+                unsigned long long lvalue = 0;
+                memcpy(&lvalue, rbytes, 8);
+                newValue = [NSNumber numberWithUnsignedLongLong:lvalue];
             }
-            unsigned long long lvalue = 0;
-            memcpy(&lvalue, rbytes, 8);
-            newValue = [NSNumber numberWithUnsignedLongLong:lvalue];
         }
         break;
-    }
-    case DATA_ELEMENT_TYPE_U_INT_16: {
-        newType = kBluetoothSDPDataElementTypeUnsignedInt;
-        newSizeDescriptor = 4;
-        newSize = 16;
-        newValue = [NSData dataWithBytes:bytes length:16];
+            
+    case DATA_ELEMENT_TYPE_U_INT_16:
+        {
+            newType = kBluetoothSDPDataElementTypeUnsignedInt;
+            newSizeDescriptor = 4;
+            newSize = 16;
+            newValue = [NSData dataWithBytes:bytes length:16];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_INT_16: {
-        newType = kBluetoothSDPDataElementTypeSignedInt;
-        newSizeDescriptor = 4;
-        newSize = 16;
-        newValue = [NSData dataWithBytes:bytes length:16];
+            
+    case DATA_ELEMENT_TYPE_INT_16:
+        {
+            newType = kBluetoothSDPDataElementTypeSignedInt;
+            newSizeDescriptor = 4;
+            newSize = 16;
+            newValue = [NSData dataWithBytes:bytes length:16];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_NULL: {
-        newType = kBluetoothSDPDataElementTypeNil;
-        newSizeDescriptor = 0;
-        newSize = 0;
-        newValue = NULL;
+
+    case DATA_ELEMENT_TYPE_NULL:
+        {
+            newType = kBluetoothSDPDataElementTypeNil;
+            newSizeDescriptor = 0;
+            newSize = 0;
+            newValue = NULL;
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_BOOL: {
-        newType = kBluetoothSDPDataElementTypeBoolean;
-        newSizeDescriptor = 0;
-        newSize = 1;
-        newValue = [NSNumber numberWithInt:((int)ldata)];
+            
+    case DATA_ELEMENT_TYPE_BOOL:
+        {
+            newType = kBluetoothSDPDataElementTypeBoolean;
+            newSizeDescriptor = 0;
+            newSize = 1;
+            newValue = [NSNumber numberWithInt:((int)ldata)];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_UUID: {
-        newType = kBluetoothSDPDataElementTypeUUID;
-        newSizeDescriptor = 4;
-        newSize = inBytesLen;
-        newValue = [IOBluetoothSDPUUID uuidWithBytes:(const void *)bytes length:(unsigned)inBytesLen];
+            
+    case DATA_ELEMENT_TYPE_UUID:
+        {
+            newType = kBluetoothSDPDataElementTypeUUID;
+            newSizeDescriptor = 4;
+            newSize = inBytesLen;
+            newValue = [IOBluetoothSDPUUID uuidWithBytes:(const void *)bytes length:(unsigned)inBytesLen];
+        }
         break;
-    }
-    case DATA_ELEMENT_TYPE_STRING: {
-        newType = kBluetoothSDPDataElementTypeString;
-        tdebug("createTestDataElementSimple string %i", inBytesLen);
-        newValue = [[NSString alloc] initWithBytes:(const void *)bytes length:(unsigned long)inBytesLen encoding:NSUTF8StringEncoding];
-        IOBluetoothSDPDataElement* ds = [IOBluetoothSDPDataElement withElementValue:newValue];
-        return [ds getSDPDataElementRef];
-    }
-    case DATA_ELEMENT_TYPE_URL: {
-        newType = kBluetoothSDPDataElementTypeURL;
-        tdebug("createTestDataElementSimple URL %i", inBytesLen);
-        // UTF8 is just encoding for test interface.
-        NSString* newStrValue = [[NSString alloc] initWithBytes:(const void *)bytes length:(unsigned long)inBytesLen encoding:NSNonLossyASCIIStringEncoding];
-        newValue = newStrValue;
-        newSize = [newStrValue length];
-        if (newSize < 0x100) {
-		    newSizeDescriptor  = 5;
-		} else if (newSize < 0x10000) {
-		    newSizeDescriptor  = 6;
-		} else {
-		    newSizeDescriptor  = 7;
-		}
-		//newSize + 1;
+            
+    case DATA_ELEMENT_TYPE_STRING:
+        {
+            newType = kBluetoothSDPDataElementTypeString;
+            tdebug("createTestDataElementSimple string %i", inBytesLen);
+            newValue = [[NSString alloc] initWithBytes:(const void *)bytes length:(unsigned long)inBytesLen encoding:NSUTF8StringEncoding];
+            IOBluetoothSDPDataElement* ds = [IOBluetoothSDPDataElement withElementValue:newValue];
+            return ds;
+        }
+            
+    case DATA_ELEMENT_TYPE_URL:
+        {
+            newType = kBluetoothSDPDataElementTypeURL;
+            tdebug("createTestDataElementSimple URL %i", inBytesLen);
+            // UTF8 is just encoding for test interface.
+            NSString* newStrValue = [[NSString alloc] initWithBytes:(const void *)bytes length:(unsigned long)inBytesLen encoding:NSNonLossyASCIIStringEncoding];
+            newValue = newStrValue;
+            newSize = [newStrValue length];
+            if (newSize < 0x100) {
+                newSizeDescriptor  = 5;
+            } else if (newSize < 0x10000) {
+                newSizeDescriptor  = 6;
+            } else {
+                newSizeDescriptor  = 7;
+            }
+            //newSize + 1;
+        }
         break;
-    }
+    
     default:
         return NULL;
     }
+    
     //[newValue retain];
     IOBluetoothSDPDataElement* de = [IOBluetoothSDPDataElement withType:newType sizeDescriptor:newSizeDescriptor size:newSize value:newValue];
     //[de retain];
     tdebug("createTestDataElementSimple %i %i %i", newType, newSizeDescriptor, newSize);
-    return [de getSDPDataElementRef];
+    return de;
 }
 
-IOBluetoothSDPDataElementRef createTestDataElement(jint testType, jint type, jlong ldata, jbyte *bytes, int inBytesLen) {
+IOBluetoothSDPDataElement* createTestDataElement(jint testType, jint type, jlong ldata, jbyte *bytes, int inBytesLen) {
     switch (testType) {
     case 0:
             return createTestDataElementSimple(type, ldata, bytes, inBytesLen);
@@ -206,7 +237,7 @@ IOBluetoothSDPDataElementRef createTestDataElement(jint testType, jint type, jlo
 	    inBytesLen = env->GetArrayLength(bdata);
     }
 
-    const IOBluetoothSDPDataElementRef dataElement = createTestDataElement(testType, type, ldata, inBytes, inBytesLen);
+    const IOBluetoothSDPDataElement* dataElement = createTestDataElement(testType, type, ldata, inBytes, inBytesLen);
 
     tdebug("dataElement created");
 
@@ -217,7 +248,7 @@ IOBluetoothSDPDataElementRef createTestDataElement(jint testType, jint type, jlo
     BOOL written = os.writeElement(dataElement);
 
     if (bdata != NULL) {
-        //env->ReleaseByteArrayElements(bdata, inBytes, 0);
+        env->ReleaseByteArrayElements(bdata, inBytes, 0);
     }
 
     if (!written) {
@@ -250,4 +281,4 @@ IOBluetoothSDPDataElementRef createTestDataElement(jint testType, jint type, jlo
         }
     }
 
-}
\ No newline at end of file
+}
diff --git a/bluecove/src/main/c/intelbth/bluecove.xcodeproj/project.pbxproj b/bluecove/src/main/c/intelbth/bluecove.xcodeproj/project.pbxproj
index 35cb7ae4..370b72b9 100644
--- a/bluecove/src/main/c/intelbth/bluecove.xcodeproj/project.pbxproj
+++ b/bluecove/src/main/c/intelbth/bluecove.xcodeproj/project.pbxproj
@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 42;
+	objectVersion = 46;
 	objects = {
 
 /* Begin PBXBuildFile section */
@@ -202,9 +202,16 @@
 /* Begin PBXProject section */
 		08FB7793FE84155DC02AAC07 /* Project object */ = {
 			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0460;
+			};
 			buildConfigurationList = 1DEB914E08733D8E0010E9CD /* Build configuration list for PBXProject "bluecove" */;
-			compatibilityVersion = "Xcode 2.4";
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
 			hasScannedForEncodings = 1;
+			knownRegions = (
+				en,
+			);
 			mainGroup = 08FB7794FE84155DC02AAC07 /* bluecove */;
 			projectDirPath = "";
 			projectRoot = "";
@@ -240,14 +247,18 @@
 		1DEB914B08733D8E0010E9CD /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
+				ARCHS = (
+					i386,
+					x86_64,
+				);
 				COPY_PHASE_STRIP = NO;
 				EXECUTABLE_PREFIX = lib;
 				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
 				GCC_MODEL_TUNING = G5;
 				GCC_OPTIMIZATION_LEVEL = 0;
 				INSTALL_PATH = /usr/local/lib;
 				PRODUCT_NAME = bluecove;
+				SDKROOT = macosx;
 				ZERO_LINK = YES;
 			};
 			name = Debug;
@@ -257,7 +268,6 @@
 			buildSettings = {
 				ARCHS = (
 					i386,
-					ppc,
 					x86_64,
 				);
 				EXECUTABLE_PREFIX = lib;
@@ -265,6 +275,8 @@
 				GCC_MODEL_TUNING = G5;
 				INSTALL_PATH = /usr/local/lib;
 				PRODUCT_NAME = bluecove;
+				SDKROOT = macosx;
+				VALID_ARCHS = "i386 x86_64";
 			};
 			name = Release;
 		};
@@ -285,8 +297,7 @@
 					"$(SDKROOT)/System/Library/Frameworks/JavaVM.framework/Headers",
 					"$(inherited)",
 				);
-				PREBINDING = NO;
-				SDKROOT = /Developer/SDKs/MacOSX10.5.sdk;
+				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
 			};
 			name = Debug;
 		};
@@ -307,8 +318,7 @@
 					"$(SDKROOT)/System/Library/Frameworks/JavaVM.framework/Headers",
 					"$(inherited)",
 				);
-				PREBINDING = NO;
-				SDKROOT = /Developer/SDKs/MacOSX10.5.sdk;
+				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
 				VALID_ARCHS = "ppc7400 ppc970 i386 x86_64 ppc";
 			};
 			name = Release;
diff --git a/bluecove/src/main/c/intelbth/common.cpp b/bluecove/src/main/c/intelbth/common.cpp
index 446186d0..9ab72b03 100644
--- a/bluecove/src/main/c/intelbth/common.cpp
+++ b/bluecove/src/main/c/intelbth/common.cpp
@@ -25,6 +25,9 @@
 #include "common.h"
 #include "commonObjects.h"
 
+#include <dispatch/queue.h>
+#include <dispatch/dispatch.h>
+
 #ifndef CPP_FILE
 #define CPP_FILE "common.cpp"
 #endif
@@ -431,31 +434,29 @@ jint getDeviceClassByOS(JNIEnv *env) {
 #endif
 }
 
-#ifndef WIN32
-void InitializeCriticalSection(CRITICAL_SECTION *criticalRegion) {
-    MPCreateCriticalRegion(criticalRegion);
-}
-void DeleteCriticalSection(CRITICAL_SECTION *criticalRegion) {
-    MPDeleteCriticalRegion(*criticalRegion);
-}
-void EnterCriticalSection(CRITICAL_SECTION *criticalRegion) {
-    MPEnterCriticalRegion(*criticalRegion, kDurationForever);
-}
-void LeaveCriticalSection(CRITICAL_SECTION *criticalRegion) {
-    MPExitCriticalRegion(*criticalRegion);
-}
-#endif
-
 ReceiveBuffer::ReceiveBuffer() {
     safe = RECEIVE_BUFFER_SAFE;
-    if (safe) InitializeCriticalSection(&lock);
+    if (safe) {
+        ioQueue = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
+    }
+    else {
+        ioQueue = dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT);
+    }
+    
     this->size = RECEIVE_BUFFER_MAX;
     reset();
 }
 
 ReceiveBuffer::ReceiveBuffer(int size) {
     safe = RECEIVE_BUFFER_SAFE;
-    if (safe) InitializeCriticalSection(&lock);
+    
+    if (safe) {
+        ioQueue = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
+    }
+    else {
+        ioQueue = dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT);
+    }
+    
     this->size = size;
     if (this->size > RECEIVE_BUFFER_MAX) {
         this->size = RECEIVE_BUFFER_MAX;
@@ -464,7 +465,9 @@ ReceiveBuffer::ReceiveBuffer(int size) {
 }
 
 ReceiveBuffer::~ReceiveBuffer() {
-    if (safe) DeleteCriticalSection(&lock);
+
+    dispatch_release(ioQueue);
+
     magic1b = 0;
     magic2b = 0;
     magic1e = 0;
@@ -544,9 +547,13 @@ int ReceiveBuffer::write(void *p_data, int len) {
     if (overflown) {
         return 0;
     }
-    if (safe) EnterCriticalSection(&lock);
-    int accept = write_buffer(p_data, len);
-    if (safe) LeaveCriticalSection(&lock);
+    
+    __block int accept = 0;
+    
+    dispatch_sync(ioQueue, ^{
+        accept = write_buffer(p_data, len);
+    });
+
     return accept;
 }
 
@@ -554,10 +561,14 @@ int ReceiveBuffer::write_with_len(void *p_data, int len) {
     if (overflown) {
         return 0;
     }
-    if (safe) EnterCriticalSection(&lock);
-    int accept = write_buffer(&len, sizeof(int));
-    accept += write_buffer(p_data, len);
-    if (safe) LeaveCriticalSection(&lock);
+    
+    __block int accept = 0;
+    
+    dispatch_sync(ioQueue, ^{
+        accept = write_buffer((void*)&len, sizeof(int));
+        accept += write_buffer(p_data, len);
+    });
+
     return accept;
 }
 
@@ -575,10 +586,14 @@ int ReceiveBuffer::readByte() {
     if (available() == 0) {
         return -1;
     }
-    if (safe) EnterCriticalSection(&lock);
-    jint result = (unsigned char)buffer[read_idx];
-    incReadIdx(1);
-    if (safe) LeaveCriticalSection(&lock);
+    
+    __block jint result = 0;
+    
+    dispatch_sync(ioQueue, ^{
+        result = (unsigned char)buffer[read_idx];
+        incReadIdx(1);
+    });
+    
     return result;
 }
 
@@ -591,32 +606,34 @@ int ReceiveBuffer::read_len(int* len) {
 }
 
 int ReceiveBuffer::read(void *p_data, int len) {
-    int count = available();
+    __block int count = available();
     if (count == 0) {
         return 0;
     }
-    if (safe) EnterCriticalSection(&lock);
-    if (count > len) {
-        count = len;
-    }
-    if (read_idx + count < size) {
-        if (p_data != NULL) {
-            memcpy(p_data, (buffer + read_idx), count);
-        }
-    } else {
-        // Read first part from the end of the buffer.
-        int accept_fill_end_size = size - read_idx;
-        if (p_data != NULL) {
-            memcpy(p_data, (buffer + read_idx), accept_fill_end_size);
+
+    dispatch_sync(ioQueue, ^{
+        if (count > len) {
+            count = len;
         }
-        // Read second part from the beginning of the buffer.
-        int accept_fill_begin_size = count - accept_fill_end_size;
-        if (p_data != NULL) {
-            memcpy((jbyte*)p_data + accept_fill_end_size, buffer, accept_fill_begin_size);
+        if (read_idx + count < size) {
+            if (p_data != NULL) {
+                memcpy(p_data, (buffer + read_idx), count);
+            }
+        } else {
+            // Read first part from the end of the buffer.
+            int accept_fill_end_size = size - read_idx;
+            if (p_data != NULL) {
+                memcpy(p_data, (buffer + read_idx), accept_fill_end_size);
+            }
+            // Read second part from the beginning of the buffer.
+            int accept_fill_begin_size = count - accept_fill_end_size;
+            if (p_data != NULL) {
+                memcpy((jbyte*)p_data + accept_fill_end_size, buffer, accept_fill_begin_size);
+            }
         }
-    }
-    incReadIdx(count);
-    if (safe) LeaveCriticalSection(&lock);
+        incReadIdx(count);
+    });
+
     return count;
 }
 
@@ -625,18 +642,21 @@ int ReceiveBuffer::skip(int n) {
 }
 
 int ReceiveBuffer::available() {
-    if (safe) EnterCriticalSection(&lock);
-    int rc;
-    int _rcv_idx = rcv_idx;
-    int _read_idx = read_idx;
-    if ((_read_idx == _rcv_idx) && full) {
-        rc = size;
-    } else if (_read_idx <= _rcv_idx) {
-        rc = (_rcv_idx - _read_idx);
-    } else {
-        rc = (_rcv_idx + (size - _read_idx));
-    }
-    if (safe) LeaveCriticalSection(&lock);
+
+    __block int rc;
+
+    dispatch_sync(ioQueue, ^{
+        int _rcv_idx = rcv_idx;
+        int _read_idx = read_idx;
+        if ((_read_idx == _rcv_idx) && full) {
+            rc = size;
+        } else if (_read_idx <= _rcv_idx) {
+            rc = (_rcv_idx - _read_idx);
+        } else {
+            rc = (_rcv_idx + (size - _read_idx));
+        }
+    });
+    
     return rc;
 }
 
@@ -682,7 +702,9 @@ BOOL PoolableObject::isExternalHandle(jlong handle) {
 }
 
 ObjectPool::ObjectPool(int size, int handleOffset, BOOL delayDelete) {
-    InitializeCriticalSection(&lock);
+    
+    lock = dispatch_queue_create(NULL, DISPATCH_QUEUE_SERIAL);
+
     this->size = size;
     this->handleOffset = handleOffset;
     this->delayDelete = delayDelete;
@@ -696,19 +718,22 @@ ObjectPool::ObjectPool(int size, int handleOffset, BOOL delayDelete) {
 }
 
 ObjectPool::~ObjectPool() {
-    EnterCriticalSection(&lock);
-    PoolableObject** __objs = objs;
-    objs = NULL;
-    for(int i = 0; i < size; i ++) {
-        if (__objs[i] != NULL) {
-            PoolableObject* o = __objs[i];
-            __objs[i] = NULL;
-            delete o;
+    
+    dispatch_sync(lock, ^{
+        
+        PoolableObject** __objs = objs;
+        objs = NULL;
+        for(int i = 0; i < size; i ++) {
+            if (__objs[i] != NULL) {
+                PoolableObject* o = __objs[i];
+                __objs[i] = NULL;
+                delete o;
+            }
         }
-    }
-    delete __objs;
-    LeaveCriticalSection(&lock);
-    DeleteCriticalSection(&lock);
+        delete __objs;
+    });
+    
+    dispatch_release(lock);
 }
 
 jlong ObjectPool::realIndex(jlong internalHandle) {
@@ -721,52 +746,54 @@ jlong ObjectPool::realIndex(PoolableObject* obj) {
 
 BOOL ObjectPool::addObject(PoolableObject* obj) {
     //ndebug(("new Object %p", obj));
-    EnterCriticalSection(&lock);
-    if (objs == NULL) {
-        LeaveCriticalSection(&lock);
-        return FALSE;
-    }
-    int freeIndex = -1;
-    for(int k = 0; k < size; k++) {
-        int i = k + handleMove;
-        if (i >= size) {
-            i -= size;
-        }
-
-        if (delayDelete && (objs[i] != NULL)) {
-            if (objs[i]->readyToFree) {
-                delete objs[i];
-                objs[i] = NULL;
-            }
-        }
-
-        if (objs[i] == NULL) {
-            freeIndex = i;
-            objs[freeIndex] = obj;
-            long newHandle = handleOffset + freeIndex + handleBatch * size;
-            while (newHandle <= handleReturned) {
-                newHandle += size;
-                handleBatch ++;
-            }
-            // Start all over from start
-            if (newHandle >= INT_MAX) {
-                newHandle = handleOffset + freeIndex;
-                handleBatch = 0;
-            }
-            handleReturned = (int)newHandle;
-            obj->internalHandle = (int)newHandle;
 
-            handleMove ++;
-            if (handleMove >= size) {
-                handleMove = 0;
+    __block BOOL result = FALSE;
+    
+    dispatch_sync(lock, ^{
+        if (objs != NULL) {
+            int freeIndex = -1;
+            for(int k = 0; k < size; k++) {
+                int i = k + handleMove;
+                if (i >= size) {
+                    i -= size;
+                }
+                
+                if (delayDelete && (objs[i] != NULL)) {
+                    if (objs[i]->readyToFree) {
+                        delete objs[i];
+                        objs[i] = NULL;
+                    }
+                }
+                
+                if (objs[i] == NULL) {
+                    freeIndex = i;
+                    objs[freeIndex] = obj;
+                    long newHandle = handleOffset + freeIndex + handleBatch * size;
+                    while (newHandle <= handleReturned) {
+                        newHandle += size;
+                        handleBatch ++;
+                    }
+                    // Start all over from start
+                    if (newHandle >= INT_MAX) {
+                        newHandle = handleOffset + freeIndex;
+                        handleBatch = 0;
+                    }
+                    handleReturned = (int)newHandle;
+                    obj->internalHandle = (int)newHandle;
+                    
+                    handleMove ++;
+                    if (handleMove >= size) {
+                        handleMove = 0;
+                    }
+
+                    result = TRUE;
+                    break;
+                }
             }
-
-            LeaveCriticalSection(&lock);
-            return TRUE;
         }
-    }
-    LeaveCriticalSection(&lock);
-    return FALSE;
+    });
+    
+    return result;
 }
 
 BOOL ObjectPool::hasObject(PoolableObject* obj) {
diff --git a/bluecove/src/main/c/intelbth/common.h b/bluecove/src/main/c/intelbth/common.h
index 5b37d9d6..ce436e01 100644
--- a/bluecove/src/main/c/intelbth/common.h
+++ b/bluecove/src/main/c/intelbth/common.h
@@ -24,12 +24,14 @@
 
 #pragma once
 
+#undef USE_WORKER_THREAD
+
 #ifndef BLUECOVE_BUILD
-#define BLUECOVE_BUILD 0
+#define BLUECOVE_BUILD 100
 #endif
 
 #ifndef BLUECOVE_VERSION
-#define BLUECOVE_VERSION 20101
+#define BLUECOVE_VERSION 20100
 #endif
 
 #ifdef _WIN32_WCE
diff --git a/bluecove/src/main/c/intelbth/commonObjects.h b/bluecove/src/main/c/intelbth/commonObjects.h
index 98e9e5ec..8f0f2549 100755
--- a/bluecove/src/main/c/intelbth/commonObjects.h
+++ b/bluecove/src/main/c/intelbth/commonObjects.h
@@ -25,21 +25,16 @@
 #define MAGIC_1 0xBC1AA01
 #define MAGIC_2 0xBC2BB02
 
-#ifndef _WIN32_WCE
-#define RECEIVE_BUFFER_MAX 0x40000
-#else //_WIN32_WCE
-#define RECEIVE_BUFFER_MAX 0x8000
-#endif  //_WIN32_WCE
-
+#define RECEIVE_BUFFER_MAX 0x10000
 // This is extra precaution, may be unnecessary
 #define RECEIVE_BUFFER_SAFE TRUE
 /*
- * FIFO with no memory allocations in write, 256K size can be overflown but not with BT communication speed we tested.
- */
+* FIFO with no memory allocations in write, can be overflown but not with BT communication speed.
+*/
 class ReceiveBuffer {
 private:
 	BOOL safe;
-	CRITICAL_SECTION lock;
+	dispatch_queue_t ioQueue;
 
 	int size;
 
@@ -101,7 +96,7 @@ class PoolableObject {
 
 class ObjectPool {
 private:
-	CRITICAL_SECTION lock;
+	dispatch_queue_t lock;
 
 	int size;
 
diff --git a/bluecove/src/test/java/com/intel/bluetooth/NativeSDPStreamOSXTest.java b/bluecove/src/test/java/com/intel/bluetooth/NativeSDPStreamOSXTest.java
index 764a59d5..3607ebd2 100644
--- a/bluecove/src/test/java/com/intel/bluetooth/NativeSDPStreamOSXTest.java
+++ b/bluecove/src/test/java/com/intel/bluetooth/NativeSDPStreamOSXTest.java
@@ -40,7 +40,7 @@ private void validateConversion(DataElement elementExpect, int testType, int typ
         byte[] blob = NativeTestInterfaces.testOsXDataElementConversion(testType, type, ldata, bdata);
         assertNotNull("NULL blob", blob);
         DataElement element = (new SDPInputStream(new ByteArrayInputStream(blob))).readElement();
-        SDPStreamTest.assertEquals("", elementExpect, element);
+        SDPStreamTest.assertEquals("XX", elementExpect, element);
     }
 
     /**
diff --git a/pom.xml b/pom.xml
index 790acc48..916ec5cf 100644
--- a/pom.xml
+++ b/pom.xml
@@ -173,6 +173,20 @@
             </roles>
         </contributor>
 
+
+        <contributor>
+            <name>Mathias Kühn</name>
+            <email>kuehn@synerva.de</email>
+            <organization>SYNERVA GmbH</organization>
+            <organizationUrl>http://www.synerva.de</organizationUrl>
+            <roles>
+                <role>developer</role>
+                <role>developer-OSX</role>
+                <role>developer-OSX-10.8</role>
+            </roles>
+            <timezone>+1</timezone>
+        </contributor>        
+        
         <!--
         <contributor>
             <name></name>