server2.h

// Copyright 2024 The Pigweed Authors
//
// 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
//
//     https://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>
 
#include "pw_async2/dispatcher.h"
#include "pw_async2/once_sender.h"
#include "pw_bluetooth/gatt/error.h"
#include "pw_bluetooth/gatt/types.h"
#include "pw_bluetooth/internal/raii_ptr.h"
#include "pw_bluetooth/types.h"
#include "pw_multibuf/multibuf.h"
#include "pw_result/expected.h"
#include "pw_span/span.h"
 
namespace pw::bluetooth::gatt {
 
 
class LocalServiceDelegate2 {
 public:
  virtual ~LocalServiceDelegate2() = default;
 
  virtual void OnError(Error error) = 0;
 
  virtual void CharacteristicConfiguration(PeerId peer_id,
                                           Handle handle,
                                           bool notify,
                                           bool indicate) = 0;
 
  virtual async2::OnceReceiver<pw::expected<multibuf::MultiBuf, Error>>
  ReadValue(PeerId peer_id, Handle handle, uint32_t offset) = 0;
 
  virtual async2::OnceReceiver<pw::expected<void, Error>> WriteValue(
      PeerId peer_id,
      Handle handle,
      uint32_t offset,
      multibuf::MultiBuf&& value) = 0;
 
  virtual void MtuUpdate(PeerId peer_id, uint16_t mtu) = 0;
};
 
class LocalService2 {
 public:
  struct ValueChangedParameters {
    pw::span<const PeerId> peer_ids;
    Handle handle;
    multibuf::MultiBuf value;
  };
 
  using ValueChangedResult = pw::expected<void, Error>;
 
  virtual ~LocalService2() = default;
 
  virtual async2::OnceReceiver<ValueChangedResult> NotifyValue(
      ValueChangedParameters&& parameters) = 0;
 
  virtual async2::OnceReceiver<ValueChangedResult> IndicateValue(
      ValueChangedParameters&& parameters) = 0;
 
 private:
  virtual void UnpublishService() = 0;
 
 public:
  using Ptr =
      internal::RaiiPtr<LocalService2, &LocalService2::UnpublishService>;
};
 
class Server2 {
 public:
  enum class PublishServiceError {
    kInternalError = 0,
 
    kInvalidHandle = 1,
 
    kInvalidUuid = 2,
 
    kInvalidCharacteristics = 3,
 
    kInvalidIncludes = 4,
  };
 
  struct LocalServiceInfo {
    ServiceHandle handle;
 
    bool primary;
 
    Uuid type;
 
    span<const Characteristic2> characteristics;
 
    span<const ServiceHandle> includes;
  };
 
  using PublishServiceResult =
      pw::expected<LocalService2::Ptr, PublishServiceError>;
 
  virtual ~Server2() = default;
 
  virtual async2::OnceReceiver<PublishServiceResult> PublishService(
      const LocalServiceInfo& info, LocalServiceDelegate2& delegate) = 0;
};
 
}  // namespace pw::bluetooth::gatt