bluetooth: Create base class BluetoothDevice::CreateGattConnection impl.

device/bluetooth/bluetooth_device.h

 // Copyright (c) 2012 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 222 matching lines @@
   virtual bool IsPaired() const = 0;
 
   // Indicates whether the device is currently connected to the adapter.
   // Note that if IsConnected() is true, does not imply that the device is
   // connected to any application or service. If the device is not paired, it
   // could be still connected to the adapter for other reason, for example, to
   // request the adapter's SDP records. The same holds for paired devices, since
   // they could be connected to the adapter but not to an application.
   virtual bool IsConnected() const = 0;
 
+  // Indicates whether an active GATT connection exists to the device.
+  virtual bool IsGattConnected() const = 0;
+
   // Indicates whether the paired device accepts connections initiated from the
   // adapter. This value is undefined for unpaired devices.
   virtual bool IsConnectable() const = 0;
 
   // Indicates whether there is a call to Connect() ongoing. For this attribute,
   // we consider a call is ongoing if none of the callbacks passed to Connect()
   // were called after the corresponding call to Connect().
   virtual bool IsConnecting() const = 0;
 
   // Indicates whether the device can be trusted, based on device properties,
@@ skipping 147 matching lines @@
   // BluetoothGattConnection will be handed to the caller via |callback|. On
   // error, |error_callback| will be called. The connection will be kept alive,
   // as long as there is at least one active GATT connection. In the case that
   // the underlying connection gets terminated, either due to a call to
   // BluetoothDevice::Disconnect or other unexpected circumstances, the
   // returned BluetoothGattConnection will be automatically marked as inactive.
   // To monitor the state of the connection, observe the
   // BluetoothAdapter::Observer::DeviceChanged method.
   typedef base::Callback<void(scoped_ptr<BluetoothGattConnection>)>
       GattConnectionCallback;
-  virtual void CreateGattConnection(
-      const GattConnectionCallback& callback,
-      const ConnectErrorCallback& error_callback) = 0;
+  virtual void CreateGattConnection(const GattConnectionCallback& callback,
+                                    const ConnectErrorCallback& error_callback);
 
   // Returns the list of discovered GATT services.
   virtual std::vector<BluetoothGattService*> GetGattServices() const;
 
   // Returns the GATT service with device-specific identifier |identifier|.
   // Returns NULL, if no such service exists.
   virtual BluetoothGattService* GetGattService(
       const std::string& identifier) const;
 
   // Returns service data of a service given its UUID.
   virtual base::BinaryValue* GetServiceData(BluetoothUUID serviceUUID) const;
 
   // Returns the list UUIDs of services that have service data.
   virtual UUIDList GetServiceDataUUIDs() const;
 
   // Returns the |address| in the canonical format: XX:XX:XX:XX:XX:XX, where
   // each 'X' is a hex digit.  If the input |address| is invalid, returns an
   // empty string.
   static std::string CanonicalizeAddress(const std::string& address);
 
  protected:
+  // BluetoothGattConnection is a friend to call
+  // In/DecrementGattConnectionReferenceCount.

[Jeffrey Yasskin, 2015/08/19 22:49:45]

"Inc/Decrement", I think.

[scheib, 2015/09/13 02:40:27]

Done.

+  friend BluetoothGattConnection;
+
   BluetoothDevice(BluetoothAdapter* adapter);
 
   // Returns the internal name of the Bluetooth device, used by GetName().
   virtual std::string GetDeviceName() const = 0;
 
+  // Implements platform specific operations to initiate a GATT connection.
+  // Subclasses must also call DidConnectGatt, DidFailToConnectGatt, or
+  // DidDisconnectGatt immediately or asynchronously as the connection state

[Jeffrey Yasskin, 2015/08/19 22:49:45]

"immediately or asynchronously" covers all the options, so you can probably skip
it.

[scheib, 2015/09/13 02:40:27]

Done. I was trying to communicate that these may be called safely at any time.

[Jeffrey Yasskin, 2015/09/16 00:45:39]

Ah, yeah, I like the explicit statement you've added to those functions that
they can be called at any time.

You didn't remove the "immediately or asynchronously" here. I don't insist, but
still think it's extraneous.

+  // changes.
+  virtual void CreateGattConnectionImpl() = 0;

[Jeffrey Yasskin, 2015/08/19 22:49:45]

If you intend to only call this from BluetoothDevice, it should be private.
Subclasses can still override private members.

[scheib, 2015/09/13 02:40:28]

Doesn't overriding for implementation then defeat the private scoping? I'm not
sure how this adds compile safety, but I do see that it will split related
methods to be non contiguous.

[Jeffrey Yasskin, 2015/09/16 00:45:39]

Yeah, good point: subclasses will be able to call their own overrides. Making
the function private still makes it clear that the base class doesn't intend to
provide any service to the subclasses through this function, but, on the other
hand, the =0 makes the same statement, so I guess it doesn't matter much.

+
+  // Disconnects GATT connection on platforms that maintain a specific GATT
+  // connection.
+  virtual void DisconnectGatt() = 0;
+
+  // Calls pending callbacks for CreateGattConnection based on result of

[Jeffrey Yasskin, 2015/08/19 22:49:45]

Say something about how Did*Gatt() calls need to match up with
CreateGattConnectionImpl and DisconnectGatt calls. Are they 1-1? Can Did*Gatt()
calls come in spontaneously? Does one of these report the device going out of
range?

[scheib, 2015/09/13 02:40:27]

Done. Regarding out of range, there isn't anything specific in this design that
addresses out of range - but if the platform indicates that the GATT connection
is disconnected then DidDisconnectGatt is the only expected API point to call.
BluetoothDevice doesn't otherwise make any statements about out of range.

+  // subclasses actions initiated in CreateGattConnectionImpl or related
+  // disconnection event.
+  void DidConnectGatt();
+  void DidFailToConnectGatt(ConnectErrorCode);
+  void DidDisconnectGatt();
+
+  // Maintains GattConnection reference count. Called by friend class
+  // BluetoothGattConnection.
+  void IncrementGattConnectionReferenceCount();
+  void DecrementGattConnectionReferenceCount();
+
   // Clears the list of service data.
   void ClearServiceData();
 
   // Set the data of a given service designated by its UUID.
   void SetServiceData(BluetoothUUID serviceUUID, const char* buffer,
                       size_t size);
 
   // Raw pointer to adapter owning this device object. Subclasses use platform
   // specific pointers via adapter_.
   BluetoothAdapter* adapter_;
 
+  // Callbacks for pending success and error result of CreateGattConnection.
+  std::vector<GattConnectionCallback> create_gatt_connection_success_callbacks_;
+  std::vector<ConnectErrorCallback> create_gatt_connection_error_callbacks_;
+
+  // Represents the number of BluetoothGattConnection objects keeping the
+  // Gatt connection alive to the device.
+  uint32_t gatt_connection_reference_count_ = 0;
+
   // Mapping from the platform-specific GATT service identifiers to
   // BluetoothGattService objects.
   typedef std::map<std::string, BluetoothGattService*> GattServiceMap;
   GattServiceMap gatt_services_;
 
   // Mapping from service UUID represented as a std::string of a bluetooth
   // service to
   // the specific data. The data is stored as BinaryValue.
   scoped_ptr<base::DictionaryValue> services_data_;
 
  private:
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_