144 lines
4.9 KiB
C++
144 lines
4.9 KiB
C++
//
|
|
// Copyright (C) 2015 Google, Inc.
|
|
//
|
|
// 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 <memory>
|
|
#include <string>
|
|
|
|
#include <bluetooth/uuid.h>
|
|
|
|
namespace bluetooth {
|
|
|
|
// Used to uniquely identify a GATT object/attribute
|
|
// (service/characteristic/descriptor/include entry) after it has been
|
|
// registered with the stack. Each registered object will be assigned a GATT
|
|
// identifier that the callers may use in future callbacks.
|
|
//
|
|
// For local services, the uniqueness of each identifier is guaranteed only
|
|
// within the registered GATT server that they exist in.
|
|
class GattIdentifier final {
|
|
public:
|
|
// Static initialization methods. These return NULL if invalid parameters are
|
|
// given.
|
|
static std::unique_ptr<GattIdentifier> CreateServiceId(
|
|
const std::string& device_address,
|
|
int id,
|
|
const UUID& uuid,
|
|
bool is_primary);
|
|
static std::unique_ptr<GattIdentifier> CreateCharacteristicId(
|
|
int id, const UUID& uuid,
|
|
const GattIdentifier& service_id);
|
|
static std::unique_ptr<GattIdentifier> CreateDescriptorId(
|
|
int id, const UUID& uuid,
|
|
const GattIdentifier& characteristic_id);
|
|
|
|
// Constructors and assignment operator.
|
|
GattIdentifier();
|
|
GattIdentifier(
|
|
const std::string& device_address,
|
|
bool is_primary,
|
|
const UUID& service_uuid,
|
|
const UUID& characteristic_uuid,
|
|
const UUID& descriptor_uuid,
|
|
int service_instance_id,
|
|
int characteristic_instance_id,
|
|
int descriptor_instance_id);
|
|
~GattIdentifier() = default;
|
|
GattIdentifier(const GattIdentifier& other);
|
|
GattIdentifier& operator=(const GattIdentifier& other);
|
|
|
|
|
|
// Comparison function and operator.
|
|
bool Equals(const GattIdentifier& other) const;
|
|
bool operator==(const GattIdentifier& rhs) const;
|
|
bool operator!=(const GattIdentifier& rhs) const;
|
|
|
|
// Functions to verify the type of attribute represented by this identifier.
|
|
bool IsService() const;
|
|
bool IsCharacteristic() const;
|
|
bool IsDescriptor() const;
|
|
|
|
// For characteristics and descriptors, this returns the identifier of the
|
|
// owning service. For services, this returns NULL.
|
|
std::unique_ptr<GattIdentifier> GetOwningServiceId() const;
|
|
|
|
// For descriptors, this returns the identifier of the owning characteristic.
|
|
// For services and characteristics, this returns NULL.
|
|
std::unique_ptr<GattIdentifier> GetOwningCharacteristicId() const;
|
|
|
|
// Getters for internal fields.
|
|
const std::string& device_address() const { return device_address_; }
|
|
bool is_primary() const { return is_primary_; }
|
|
const UUID& service_uuid() const { return service_uuid_; }
|
|
const UUID& characteristic_uuid() const { return char_uuid_; }
|
|
const UUID& descriptor_uuid() const { return desc_uuid_; }
|
|
int service_instance_id() const { return service_instance_id_; }
|
|
int characteristic_instance_id() const { return char_instance_id_; }
|
|
int descriptor_instance_id() const { return desc_instance_id_; }
|
|
|
|
private:
|
|
friend struct std::hash<bluetooth::GattIdentifier>;
|
|
|
|
// NOTE: Don't forget to update the std::hash specialization below if you
|
|
// update any of the instance variables in this class.
|
|
|
|
// The BD_ADDR of the device associated with the attribute.
|
|
std::string device_address_;
|
|
|
|
// An instance ID value of -1 means that it is unitialized. For example, a
|
|
// service ID would have -1 for characteristic and descriptor instance IDs.
|
|
bool is_primary_;
|
|
UUID service_uuid_;
|
|
UUID char_uuid_;
|
|
UUID desc_uuid_;
|
|
int service_instance_id_;
|
|
int char_instance_id_;
|
|
int desc_instance_id_;
|
|
};
|
|
|
|
} // namespace bluetooth
|
|
|
|
// Custom std::hash specialization so that bluetooth::GattIdentifier can be used
|
|
// as a key in std::unordered_map.
|
|
namespace std {
|
|
|
|
template<>
|
|
struct hash<bluetooth::GattIdentifier> {
|
|
std::size_t operator()(const bluetooth::GattIdentifier& key) const {
|
|
std::size_t seed = 0;
|
|
|
|
hash_combine(seed, key.device_address_);
|
|
hash_combine(seed, key.is_primary_);
|
|
hash_combine(seed, key.service_uuid_);
|
|
hash_combine(seed, key.char_uuid_);
|
|
hash_combine(seed, key.desc_uuid_);
|
|
hash_combine(seed, key.service_instance_id_);
|
|
hash_combine(seed, key.char_instance_id_);
|
|
hash_combine(seed, key.desc_instance_id_);
|
|
|
|
return seed;
|
|
}
|
|
|
|
private:
|
|
template<typename T>
|
|
inline void hash_combine(std::size_t& seed, const T& v) const {
|
|
std::hash<T> hasher;
|
|
seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
|
|
}
|
|
};
|
|
|
|
} // namespace std
|