Import of the watch repository from Pebble

src/fw/applib/app_message/app_message_internal.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * 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 "applib/app_message/app_message.h"
+#include "applib/app_timer.h"
+#include "services/normal/app_message/app_message_sender.h"
+#include "util/attributes.h"
+#include "util/uuid.h"
+
+typedef struct CommSession CommSession;
+
+#define ACK_NACK_TIME_OUT_MS          (10000)
+#define APP_MESSAGE_ENDPOINT_ID       (0x30)
+
+typedef enum {
+  CMD_PUSH = 0x01,
+  CMD_REQUEST = 0x02,
+  CMD_ACK = 0xff,
+  CMD_NACK = 0x7f,
+} AppMessageCmd;
+
+typedef struct PACKED {
+  AppMessageCmd command:8;
+  uint8_t transaction_id;
+} AppMessageHeader;
+
+//! The actual wire format of an app message message
+typedef struct PACKED {
+  AppMessageHeader header;
+  Uuid uuid;
+  Dictionary dictionary; //!< Variable length!
+} AppMessagePush;
+// AppMessageHeader and Uuid size should be opaque to user of API
+#define APP_MSG_HDR_OVRHD_SIZE (offsetof(AppMessagePush, dictionary))
+
+#define APP_MSG_8K_DICT_SIZE (sizeof(Dictionary) + sizeof(Tuple) + (8 * 1024))
+
+typedef struct PACKED {
+  AppMessageHeader header;
+} AppMessageAck;
+
+// For a diagram of the state machine:
+// https://pebbletechnology.atlassian.net/wiki/pages/editpage.action?pageId=91914242
+
+typedef enum AppMessagePhaseOut {
+  //! The App Message Outbox is not enabled.  To enable it, call app_message_open().
+  OUT_CLOSED = 0,
+  //! The dictionary writing can be "started" by calling app_message_outbox_begin()
+  OUT_ACCEPTING,
+  //! app_message_outbox_begin() has been called and the dictionary can be written and then sent.
+  OUT_WRITING,
+  //! app_message_outbox_send() has been called. The ack/nack timeout timer has been set and
+  //! we're awaiting an ack/nack on the sent message AND the callback from the AppOutbox subsystem
+  //! that the data has been consumed. These 2 things happen in parallel, the order in which they
+  //! happen is undefined.
+  OUT_AWAITING_REPLY_AND_OUTBOX_CALLBACK,
+  //! We're still awaiting the AppMessage ack/nack, but the AppOutbox subsystem has indicated that
+  //! the data has been consumed.
+  OUT_AWAITING_REPLY,
+  //! We're still awaiting the callback from the AppOutbox subsystem to indicate the data has been
+  //! consumed, but we have already received the AppMessage ack/nack. This state is possible because
+  //! acking at a lower layer (i.e. PPoGATT) can happen with a slight delay.
+  OUT_AWAITING_OUTBOX_CALLBACK,
+} AppMessagePhaseOut;
+
+typedef struct AppMessageCtxInbox {
+  bool is_open;
+  void *user_context;
+  AppMessageInboxReceived received_callback;
+  AppMessageInboxDropped dropped_callback;
+} AppMessageCtxInbox;
+
+typedef struct AppMessageCtxOutbox {
+  DictionaryIterator iterator;
+  size_t transmission_size_limit;
+
+  AppMessageAppOutboxData *app_outbox_message;
+
+  AppMessageOutboxSent sent_callback;
+  AppMessageOutboxFailed failed_callback;
+  void *user_context;
+
+  AppTimer *ack_nack_timer;
+
+  struct PACKED {
+    AppMessagePhaseOut phase:8;
+    uint8_t transaction_id;
+    uint16_t not_ready_throttle_ms;       // used for throttling app task when outbox is not ready
+    AppMessageResult result:16;
+  };
+} AppMessageCtxOutbox;
+
+typedef struct AppMessageCtx {
+  AppMessageCtxInbox inbox;
+  AppMessageCtxOutbox outbox;
+} AppMessageCtx;
+
+_Static_assert(sizeof(AppMessageCtx) <= 112,
+               "AppMessageCtx must not exceed 112 bytes!");
+
+typedef struct {
+  CommSession *session;
+  //! To give us some room for future changes. This structure ends up in a buffer that is sized by
+  //! the app, so we can't easily increase the size of this once shipped.
+  uint8_t padding[8];
+  uint8_t data[];
+} AppMessageReceiverHeader;
+
+#ifndef UNITTEST
+_Static_assert(sizeof(AppMessageReceiverHeader) == 12,
+               "The size of AppMessageReceiverHeader cannot grow beyond 12 bytes!");
+#endif
+
+void app_message_init(void);
+
+AppMessageResult app_message_inbox_open(AppMessageCtxInbox *inbox, size_t size_inbound);
+
+void app_message_inbox_close(AppMessageCtxInbox *inbox);
+
+typedef struct AppInboxConsumerInfo AppInboxConsumerInfo;
+
+void app_message_inbox_receive(CommSession *session, AppMessagePush *push_message, size_t length,
+                               AppInboxConsumerInfo *consumer_info);
+
+AppMessageResult app_message_outbox_open(AppMessageCtxOutbox *outbox, size_t size_outbound);
+
+void app_message_outbox_close(AppMessageCtxOutbox *outbox);
+
+void app_message_out_handle_ack_nack_received(const AppMessageHeader *header);
+
+void app_message_inbox_send_ack_nack_reply(CommSession *session, const uint8_t transaction_id,
+                                           AppMessageCmd cmd);
+
+void app_message_inbox_handle_dropped_messages(uint32_t num_drops);
+
+void app_message_app_protocol_msg_callback(CommSession *session,
+                                           const uint8_t* data, size_t length,
+                                           AppInboxConsumerInfo *consumer_info);
+
+void app_message_app_protocol_system_nack_callback(CommSession *session,
+                                                   const uint8_t* data, size_t length);