bluetooth: android: Initial basic Descriptors implementation.

device/bluetooth/bluetooth_remote_gatt_characteristic_android.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "device/bluetooth/bluetooth_adapter_android.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session_android.h"
+#include "device/bluetooth/bluetooth_remote_gatt_descriptor_android.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_android.h"
 #include "jni/ChromeBluetoothRemoteGattCharacteristic_jni.h"
 
 using base::android::AttachCurrentThread;
 
 namespace device {
 
 // static
 scoped_ptr<BluetoothRemoteGattCharacteristicAndroid>
 BluetoothRemoteGattCharacteristicAndroid::Create(
+    BluetoothAdapterAndroid* adapter,
     const std::string& instance_id,
     jobject /* BluetoothGattCharacteristicWrapper */
     bluetooth_gatt_characteristic_wrapper,
     jobject /* ChromeBluetoothDevice */ chrome_bluetooth_device) {
   scoped_ptr<BluetoothRemoteGattCharacteristicAndroid> characteristic(
-      new BluetoothRemoteGattCharacteristicAndroid(instance_id));
+      new BluetoothRemoteGattCharacteristicAndroid(adapter, instance_id));
 
+  JNIEnv* env = AttachCurrentThread();
   characteristic->j_characteristic_.Reset(
       Java_ChromeBluetoothRemoteGattCharacteristic_create(
-          AttachCurrentThread(),
-          reinterpret_cast<intptr_t>(characteristic.get()),
-          bluetooth_gatt_characteristic_wrapper, chrome_bluetooth_device));
+          env, reinterpret_cast<intptr_t>(characteristic.get()),
+          bluetooth_gatt_characteristic_wrapper,
+          base::android::ConvertUTF8ToJavaString(env, instance_id).obj(),
+          chrome_bluetooth_device));
 
   return characteristic;
 }
 
 BluetoothRemoteGattCharacteristicAndroid::
     ~BluetoothRemoteGattCharacteristicAndroid() {
   Java_ChromeBluetoothRemoteGattCharacteristic_onBluetoothRemoteGattCharacteristicAndroidDestruction(
       AttachCurrentThread(), j_characteristic_.obj());
 }
 
@@ skipping 45 matching lines @@
   return 0;
 }
 
 bool BluetoothRemoteGattCharacteristicAndroid::IsNotifying() const {
   NOTIMPLEMENTED();
   return false;
 }
 
 std::vector<BluetoothGattDescriptor*>
 BluetoothRemoteGattCharacteristicAndroid::GetDescriptors() const {
-  NOTIMPLEMENTED();
-  return std::vector<BluetoothGattDescriptor*>();
+  EnsureDescriptorsCreated();
+  std::vector<BluetoothGattDescriptor*> descriptors;
+  for (const auto& map_iter : descriptors_)
+    descriptors.push_back(map_iter.second);
+  return descriptors;
 }
 
 BluetoothGattDescriptor*
 BluetoothRemoteGattCharacteristicAndroid::GetDescriptor(
     const std::string& identifier) const {
-  NOTIMPLEMENTED();
-  return nullptr;
+  EnsureDescriptorsCreated();
+  const auto& iter = descriptors_.find(identifier);
+  if (iter == descriptors_.end())
+    return nullptr;
+  return iter->second;
 }
 
 bool BluetoothRemoteGattCharacteristicAndroid::AddDescriptor(
     BluetoothGattDescriptor* descriptor) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool BluetoothRemoteGattCharacteristicAndroid::UpdateValue(
     const std::vector<uint8_t>& value) {
@@ skipping 108 matching lines @@
 
   if (status == 0  // android.bluetooth.BluetoothGatt.GATT_SUCCESS
       && !write_callback.is_null()) {
     write_callback.Run();
   } else if (!write_error_callback.is_null()) {
     write_error_callback.Run(
         BluetoothRemoteGattServiceAndroid::GetGattErrorCode(status));
   }
 }
 
+void BluetoothRemoteGattCharacteristicAndroid::CreateGattRemoteDescriptor(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& caller,
+    const JavaParamRef<jstring>& instanceId,
+    const JavaParamRef<jobject>& /* BluetoothGattDescriptorWrapper */
+    bluetooth_gatt_descriptor_wrapper,
+    const JavaParamRef<jobject>& /* ChromeBluetoothDevice */
+    chrome_bluetooth_device) {
+  std::string instanceIdString =
+      base::android::ConvertJavaStringToUTF8(env, instanceId);
+
+  DCHECK(!descriptors_.contains(instanceIdString));
+
+  descriptors_.set(instanceIdString,
+                   BluetoothRemoteGattDescriptorAndroid::Create(
+                       instanceIdString, bluetooth_gatt_descriptor_wrapper,
+                       chrome_bluetooth_device));
+}
+
 BluetoothRemoteGattCharacteristicAndroid::
-    BluetoothRemoteGattCharacteristicAndroid(const std::string& instance_id)
-    : instance_id_(instance_id) {}
+    BluetoothRemoteGattCharacteristicAndroid(BluetoothAdapterAndroid* adapter,
+                                             const std::string& instance_id)
+    : adapter_(adapter), instance_id_(instance_id) {}
+
+void BluetoothRemoteGattCharacteristicAndroid::EnsureDescriptorsCreated()
+    const {
+  if (!descriptors_.empty())
+    return;
+
+  Java_ChromeBluetoothRemoteGattCharacteristic_createDescriptors(
+      AttachCurrentThread(), j_characteristic_.obj());
+}
 
 }  // namespace device