L2CAP dynamic channel API

Add API for Classic Dynamic Channel
Test: cert/run_cert.sh and bluetooth_test_gd
Bug: 138260719

Change-Id: I7afb0d7e540ae1c133c967045163e400f86e312a

system/gd/l2cap/Android.bp

@@ -3,6 +3,9 @@ filegroup {
     srcs: [
         "fcs.cc",
         "l2cap_layer.cc",
+        "classic_dynamic_channel.cc",
+        "classic_dynamic_channel_manager.cc",
+        "classic_dynamic_channel_service.cc",
         "classic_fixed_channel.cc",
         "classic_fixed_channel_manager.cc",
         "classic_fixed_channel_service.cc",

system/gd/l2cap/cid.h

@@ -27,7 +27,7 @@ constexpr Cid kInvalidCid = 0;
 constexpr Cid kFirstFixedChannel = 1;
 constexpr Cid kLastFixedChannel = 63;
 constexpr Cid kFirstDynamicChannel = kLastFixedChannel + 1;
-constexpr Cid kLastDynamicChannel = (uint16_t)(0xffff + 1);
+constexpr Cid kLastDynamicChannel = (uint16_t)(0xffff);
 
 constexpr Cid kClassicSignallingCid = 1;
 constexpr Cid kConnectionlessCid = 2;

system/gd/l2cap/classic_dynamic_channel.cc

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "l2cap/classic_dynamic_channel.h"
+#include "common/bind.h"
+
+namespace bluetooth {
+namespace l2cap {
+
+hci::Address ClassicDynamicChannel::GetDevice() const {
+  return {};
+}
+
+void ClassicDynamicChannel::RegisterOnCloseCallback(os::Handler* user_handler,
+                                                    ClassicDynamicChannel::OnCloseCallback on_close_callback) {}
+
+void ClassicDynamicChannel::Close() {}
+
+common::BidiQueueEnd<packet::BasePacketBuilder, packet::PacketView<packet::kLittleEndian>>*
+ClassicDynamicChannel::GetQueueUpEnd() const {
+  return nullptr;
+}
+}  // namespace l2cap
+}  // namespace bluetooth
\ No newline at end of file

system/gd/l2cap/classic_dynamic_channel.h

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "common/bidi_queue.h"
+#include "common/callback.h"
+#include "hci/acl_manager.h"
+#include "os/handler.h"
+#include "packet/base_packet_builder.h"
+#include "packet/packet_view.h"
+
+namespace bluetooth {
+namespace l2cap {
+
+namespace internal {
+class ClassicDynamicChannelImpl;
+}  // namespace internal
+
+/**
+ * L2CAP Dynamic channel object. User needs to call Close() when user no longer wants to use it. Otherwise the link
+ * won't be disconnected.
+ */
+class ClassicDynamicChannel {
+ public:
+  // Should only be constructed by modules that have access to ClassicLinkManager
+  ClassicDynamicChannel(std::shared_ptr<internal::ClassicDynamicChannelImpl> impl, os::Handler* l2cap_handler)
+      : impl_(std::move(impl)), l2cap_handler_(l2cap_handler) {
+    ASSERT(impl_ != nullptr);
+    ASSERT(l2cap_handler_ != nullptr);
+  }
+
+  hci::Address GetDevice() const;
+
+  /**
+   * Register close callback. If close callback is registered, when a channel is closed, the channel's resource will
+   * only be freed after on_close callback is invoked. Otherwise, if no on_close callback is registered, the channel's
+   * resource will be freed immediately after closing.
+   *
+   * @param user_handler The handler used to invoke the callback on
+   * @param on_close_callback The callback invoked upon channel closing.
+   */
+  using OnCloseCallback = common::OnceCallback<void(hci::ErrorCode)>;
+  void RegisterOnCloseCallback(os::Handler* user_handler, OnCloseCallback on_close_callback);
+
+  /**
+   * Indicate that this Dynamic Channel should be closed. OnCloseCallback will be invoked when channel close is done.
+   * L2cay layer may terminate this ACL connection to free the resource after channel is closed.
+   */
+  void Close();
+
+  /**
+   * This method will retrieve the data channel queue to send and receive packets.
+   *
+   * {@see BidiQueueEnd}
+   *
+   * @return The upper end of a bi-directional queue.
+   */
+  common::BidiQueueEnd<packet::BasePacketBuilder, packet::PacketView<packet::kLittleEndian>>* GetQueueUpEnd() const;
+
+ private:
+  std::shared_ptr<internal::ClassicDynamicChannelImpl> impl_;
+  os::Handler* l2cap_handler_;
+};
+
+}  // namespace l2cap
+}  // namespace bluetooth

system/gd/l2cap/classic_dynamic_channel_manager.cc

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "l2cap/classic_dynamic_channel_manager.h"
+#include "l2cap/internal/classic_link_manager.h"
+
+namespace bluetooth {
+namespace l2cap {
+
+bool ClassicDynamicChannelManager::ConnectChannel(hci::Address device, Psm psm,
+                                                  OnConnectionOpenCallback on_connection_open,
+                                                  OnConnectionFailureCallback on_fail_callback, os::Handler* handler) {
+  // TODO impl me when there is no link, and when there is link
+  return false;
+}
+
+bool ClassicDynamicChannelManager::RegisterService(Psm psm, const SecurityPolicy& security_policy,
+                                                   OnRegistrationCompleteCallback on_registration_complete,
+                                                   OnConnectionOpenCallback on_connection_open, os::Handler* handler) {
+  return false;
+}
+
+}  // namespace l2cap
+}  // namespace bluetooth

system/gd/l2cap/classic_dynamic_channel_manager.h

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+
+#include "hci/acl_manager.h"
+#include "hci/address.h"
+#include "l2cap/classic_dynamic_channel.h"
+#include "l2cap/classic_dynamic_channel_service.h"
+#include "l2cap/l2cap_packets.h"
+#include "l2cap/psm.h"
+#include "l2cap/security_policy.h"
+#include "os/handler.h"
+
+namespace bluetooth {
+namespace l2cap {
+
+class L2capLayer;
+
+namespace internal {
+class ClassicLinkManager;
+class ClassicDynamicChannelServiceManagerImpl;
+}  // namespace internal
+
+class ClassicDynamicChannelManager {
+ public:
+  enum class ConnectionResultCode {
+    SUCCESS = 0,
+    FAIL_NO_SERVICE_REGISTERED = 1,  // No service is registered
+    FAIL_HCI_ERROR = 2,              // See hci_error
+    FAIL_L2CAP_ERROR = 3,            // See l2cap_connection_response_result
+  };
+
+  struct ConnectionResult {
+    ConnectionResultCode connection_result_code = ConnectionResultCode::SUCCESS;
+    hci::ErrorCode hci_error = hci::ErrorCode::SUCCESS;
+    ConnectionResponseResult l2cap_connection_response_result = ConnectionResponseResult::SUCCESS;
+  };
+  /**
+   * OnConnectionFailureCallback(std::string failure_reason);
+   */
+  using OnConnectionFailureCallback = common::OnceCallback<void(ConnectionResult result)>;
+
+  /**
+   * OnConnectionOpenCallback(ClassicDynamicChannel channel);
+   */
+  using OnConnectionOpenCallback = common::Callback<void(std::unique_ptr<ClassicDynamicChannel>)>;
+
+  enum class RegistrationResult {
+    SUCCESS = 0,
+    FAIL_DUPLICATE_SERVICE = 1,  // Duplicate service registration for the same PSM
+    FAIL_INVALID_SERVICE = 2,    // Invalid PSM
+  };
+
+  /**
+   * OnRegistrationFailureCallback(RegistrationResult result, ClassicDynamicChannelService service);
+   */
+  using OnRegistrationCompleteCallback =
+      common::OnceCallback<void(RegistrationResult, std::unique_ptr<ClassicDynamicChannelService>)>;
+
+  /**
+   * Connect to a Dynamic channel on a remote device
+   *
+   * - This method is asynchronous
+   * - When false is returned, the connection fails immediately
+   * - When true is returned, method caller should wait for on_fail_callback or on_open_callback
+   * - If an ACL connection does not exist, this method will create an ACL connection
+   * - If HCI connection failed, on_fail_callback will be triggered with FAIL_HCI_ERROR
+   * - If Dynamic channel on a remote device is already reported as connected via on_open_callback, it won't be
+   *   reported again
+   *
+   * @param device: Remote device to make this connection.
+   * @param psm: Service PSM to connect. PSM is defined in Core spec Vol 3 Part A 4.2.
+   * @param on_open_callback: A callback to indicate success of a connection initiated from a remote device.
+   * @param on_fail_callback: A callback to indicate connection failure along with a status code.
+   * @param handler: The handler context in which to execute the @callback parameters.
+   *
+   * Returns: true if connection was able to be initiated, false otherwise.
+   */
+  bool ConnectChannel(hci::Address device, Psm psm, OnConnectionOpenCallback on_connection_open,
+                      OnConnectionFailureCallback on_fail_callback, os::Handler* handler);
+
+  /**
+   * Register a service to receive incoming connections bound to a specific channel.
+   *
+   * - This method is asynchronous.
+   * - When false is returned, the registration fails immediately.
+   * - When true is returned, method caller should wait for on_service_registered callback that contains a
+   *   ClassicDynamicChannelService object. The registered service can be managed from that object.
+   * - If a PSM is already registered or some other error happens, on_registration_complete will be triggered with a
+   *   non-SUCCESS value
+   * - After a service is registered, a ClassicDynamicChannel is delivered through on_open_callback when the remote
+   *   initiates a channel open and channel is opened successfully
+   * - on_open_callback, will only be triggered after on_service_registered callback
+   *
+   * @param security_policy: The security policy used for the connection.
+   * @param psm: Service PSM to register. PSM is defined in Core spec Vol 3 Part A 4.2.
+   * @param on_registration_complete: A callback to indicate the service setup has completed. If the return status is
+   *        not SUCCESS, it means service is not registered due to reasons like PSM already take
+   * @param on_open_callback: A callback to indicate success of a connection initiated from a remote device.
+   * @param handler: The handler context in which to execute the @callback parameter.
+   */
+  bool RegisterService(Psm psm, const SecurityPolicy& security_policy,
+                       OnRegistrationCompleteCallback on_registration_complete,
+                       OnConnectionOpenCallback on_connection_open, os::Handler* handler);
+
+  friend class L2capLayer;
+
+ private:
+  // The constructor is not to be used by user code
+  ClassicDynamicChannelManager(internal::ClassicDynamicChannelServiceManagerImpl* service_manager,
+                               internal::ClassicLinkManager* link_manager, os::Handler* l2cap_layer_handler)
+      : service_manager_(service_manager), link_manager_(link_manager), l2cap_layer_handler_(l2cap_layer_handler) {
+    ASSERT(service_manager_ != nullptr);
+    ASSERT(link_manager_ != nullptr);
+    ASSERT(l2cap_layer_handler_ != nullptr);
+  }
+  internal::ClassicDynamicChannelServiceManagerImpl* service_manager_ = nullptr;
+  internal::ClassicLinkManager* link_manager_ = nullptr;
+  os::Handler* l2cap_layer_handler_ = nullptr;
+  DISALLOW_COPY_AND_ASSIGN(ClassicDynamicChannelManager);
+};
+
+}  // namespace l2cap
+}  // namespace bluetooth

system/gd/l2cap/classic_dynamic_channel_service.cc

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "l2cap/classic_dynamic_channel_service.h"
+#include "common/bind.h"
+
+namespace bluetooth {
+namespace l2cap {
+
+void ClassicDynamicChannelService::Unregister(OnUnregisteredCallback on_unregistered,
+                                              os::Handler* on_unregistered_handler) {}
+
+}  // namespace l2cap
+}  // namespace bluetooth

system/gd/l2cap/classic_dynamic_channel_service.h

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "common/callback.h"
+#include "l2cap/psm.h"
+#include "os/handler.h"
+#include "os/log.h"
+
+namespace bluetooth {
+namespace l2cap {
+
+namespace internal {
+class ClassicDynamicChannelServiceManagerImpl;
+}
+
+class ClassicDynamicChannelService {
+ public:
+  ClassicDynamicChannelService() = default;
+
+  using OnUnregisteredCallback = common::OnceCallback<void()>;
+
+  /**
+   * Unregister a service from L2CAP module. This operation cannot fail.
+   * All channels opened for this service will be closed.
+   *
+   * @param on_unregistered will be triggered when unregistration is complete
+   */
+  void Unregister(OnUnregisteredCallback on_unregistered, os::Handler* on_unregistered_handler);
+
+  friend internal::ClassicDynamicChannelServiceManagerImpl;
+
+ private:
+  ClassicDynamicChannelService(Psm psm, internal::ClassicDynamicChannelServiceManagerImpl* manager,
+                               os::Handler* handler)
+      : psm_(psm), manager_(manager), l2cap_layer_handler_(handler) {
+    ASSERT(IsPsmValid(psm));
+    ASSERT(manager_ != nullptr);
+    ASSERT(l2cap_layer_handler_ != nullptr);
+  }
+  Psm psm_ = kDefaultPsm;
+  internal::ClassicDynamicChannelServiceManagerImpl* manager_ = nullptr;
+  os::Handler* l2cap_layer_handler_;
+  DISALLOW_COPY_AND_ASSIGN(ClassicDynamicChannelService);
+};
+
+}  // namespace l2cap
+}  // namespace bluetooth

system/gd/l2cap/psm.h

+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace bluetooth {
+namespace l2cap {
+
+using Psm = uint16_t;
+constexpr Psm kDefaultPsm = 0;  // Invalid Psm as a default value
+
+constexpr bool IsPsmValid(Psm psm) {
+  return (psm & 0x0101u) == 0x0001u;
+}
+
+}  // namespace l2cap
+}  // namespace bluetooth