Reduce fragmentation by completely deleting old thoughts.

Signed-off-by: Katharine Berry <[email protected]>

Author: Katharine

app/src/c/converse/conversation.c

@@ -34,17 +34,20 @@ struct ConversationEntry {
 struct Conversation {
   ConversationEntry* entries;
   int deleted_entries;
+  int nulled_entries;
   int entry_count;
   int entry_allocated;
   char thread_id[37];
 };
 
 static ConversationEntry* prv_create_entry(Conversation* conversation);
 void prv_destroy_entry(ConversationEntry *entry);
+const char* prv_type_to_string(EntryType type);
 
 Conversation* conversation_create() {
   Conversation *conversation = bmalloc(sizeof(Conversation));
   conversation->deleted_entries = 0;
+  conversation->nulled_entries = 0;
   conversation->entry_count = 0;
   conversation->entry_allocated = 30;
   conversation->entries = bmalloc(sizeof(ConversationEntry) * conversation->entry_allocated);
@@ -62,6 +65,9 @@ void conversation_destroy(Conversation* conversation) {
 
 void prv_destroy_entry(ConversationEntry *entry) {
   switch (entry->type) {
+    case EntryTypeDeleted:
+      // Nothing to do here.
+      break;
     case EntryTypePrompt:
       free(entry->content.prompt->prompt);
       free(entry->content.prompt);
@@ -132,6 +138,7 @@ void prv_destroy_entry(ConversationEntry *entry) {
       free(entry->content.widget);
       break;
   }
+  entry->type = EntryTypeDeleted;
 }
 
 static ConversationEntry* prv_create_entry(Conversation* conversation) {
@@ -141,6 +148,7 @@ static ConversationEntry* prv_create_entry(Conversation* conversation) {
     ++conversation->entry_allocated;
     conversation->entries = new_entries;
   }
+  memset(&conversation->entries[conversation->entry_count], 0, sizeof(ConversationEntry));
   return &conversation->entries[conversation->entry_count++];
 }
 
@@ -261,10 +269,29 @@ void conversation_add_widget(Conversation* conversation, ConversationWidget* wid
 }
 
 void conversation_delete_first_entry(Conversation* conversation) {
-  prv_destroy_entry(&conversation->entries[conversation->deleted_entries]);
+  ConversationEntry* entry = &conversation->entries[conversation->deleted_entries];
+  while (entry->type == EntryTypeDeleted && conversation->deleted_entries < conversation->entry_count) {
+    conversation->deleted_entries++;
+    conversation->nulled_entries--;
+    entry = &conversation->entries[conversation->deleted_entries];
+  }
+  prv_destroy_entry(entry);
   conversation->deleted_entries++;
 }
 
+
+void conversation_delete_last_thought(Conversation* conversation) {
+  BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "Deleting last thought");
+  for (int i = conversation->entry_count - 2; i >= conversation->deleted_entries; --i) {
+    ConversationEntry* entry = &conversation->entries[i];
+    if (entry->type == EntryTypeThought) {
+      BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "Deleting thought %d", i);
+      prv_destroy_entry(entry);
+      return;
+    }
+  }
+}
+
 ConversationEntry* conversation_entry_at_index(Conversation* conversation, int index) {
   if (index >= conversation->entry_count) {
     BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Caller asked for entry %d, but only %d exist.", index, conversation->entry_count);
@@ -293,6 +320,8 @@ ConversationEntry* conversation_get_last_of_type(Conversation* conversation, Ent
 
 const char* prv_type_to_string(EntryType type) {
   switch(type) {
+    case EntryTypeDeleted:
+      return "EntryTypeDeleted";
     case EntryTypePrompt:
       return "EntryTypePrompt";
     case EntryTypeResponse:
@@ -371,7 +400,7 @@ const char* conversation_get_thread_id(Conversation* conversation) {
 }
 
 int conversation_length(Conversation* conversation) {
-  return conversation->entry_count - conversation->deleted_entries;
+  return conversation->entry_count - conversation->deleted_entries - conversation->nulled_entries;
 }
 
 bool conversation_is_idle(Conversation* conversation) {
@@ -393,6 +422,7 @@ bool conversation_is_idle(Conversation* conversation) {
 
 static bool prv_entry_type_is_assistant(ConversationEntry* entry) {
   switch (entry->type) {
+    case EntryTypeDeleted:
     case EntryTypePrompt:
     case EntryTypeError:
     case EntryTypeThought:

app/src/c/converse/conversation.h

@@ -151,6 +151,7 @@ typedef struct {
 } ConversationWidget;
 
 typedef enum {
+  EntryTypeDeleted,
   EntryTypePrompt,
   EntryTypeResponse,
   EntryTypeThought,
@@ -180,6 +181,7 @@ ConversationEntry* conversation_peek(Conversation* conversation);
 ConversationEntry* conversation_get_last_of_type(Conversation* conversation, EntryType type);
 EntryType conversation_entry_get_type(ConversationEntry* entry);
 void conversation_delete_first_entry(Conversation* conversation);
+void conversation_delete_last_thought(Conversation* conversation);
 
 ConversationPrompt* conversation_entry_get_prompt(ConversationEntry* entry);
 ConversationResponse* conversation_entry_get_response(ConversationEntry* response);

app/src/c/converse/segments/segment_layer.c

@@ -35,6 +35,7 @@
 #define NAME_HEIGHT 20
 
 typedef enum {
+  SegmentTypeNone,
   SegmentTypeMessage,
   SegmentTypeInfo,
   SegmentTypeWeatherSingleDayWidget,
@@ -82,6 +83,8 @@ SegmentLayer* segment_layer_create(GRect rect, ConversationEntry* entry, bool as
     data->assistant_label_layer = NULL;
   }
   switch (data->type) {
+    case SegmentTypeNone:
+      break;
     case SegmentTypeMessage:
       data->message_layer = message_layer_create(child_frame, entry);
       break;
@@ -121,6 +124,8 @@ void segment_layer_destroy(SegmentLayer* layer) {
   BOBBY_LOG(APP_LOG_LEVEL_INFO, "destroying SegmentLayer %p.", layer);
   SegmentLayerData* data = layer_get_data(layer);
   switch (data->type) {
+    case SegmentTypeNone:
+      break;
     case SegmentTypeMessage:
       message_layer_destroy(data->message_layer);
       break;
@@ -160,6 +165,8 @@ ConversationEntry* segment_layer_get_entry(SegmentLayer* layer) {
 void segment_layer_update(SegmentLayer* layer) {
   SegmentLayerData* data = layer_get_data(layer);
   switch (data->type) {
+    case SegmentTypeNone:
+      break;
     case SegmentTypeMessage:
       message_layer_update(data->message_layer);
       break;
@@ -196,6 +203,8 @@ void segment_layer_update(SegmentLayer* layer) {
 
 static SegmentType prv_get_segment_type(ConversationEntry* entry) {
   switch (conversation_entry_get_type(entry)) {
+    case EntryTypeDeleted:
+      return SegmentTypeNone;
     case EntryTypePrompt:
     case EntryTypeResponse:
       return SegmentTypeMessage;
@@ -221,5 +230,5 @@ static SegmentType prv_get_segment_type(ConversationEntry* entry) {
       break;
   }
   BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Unknown entry type %d.", conversation_entry_get_type(entry));
-  return SegmentTypeMessage;
+  return SegmentTypeNone;
 }

app/src/c/converse/session_window.c

@@ -103,6 +103,9 @@ static void prv_destroy(SessionWindow *sw) {
   BOBBY_LOG(APP_LOG_LEVEL_INFO, "destroying SessionWindow %p.", sw);
   prv_cancel_timeout(sw);
   dictation_session_destroy(sw->dictation);
+  for (int i = sw->segments_deleted; i < sw->segment_count; ++i) {
+    segment_layer_destroy(sw->segment_layers[i]);
+  }
   conversation_manager_destroy(sw->manager);
   status_bar_layer_destroy(sw->status_layer);
   scroll_layer_destroy(sw->scroll_layer);
@@ -113,9 +116,6 @@ static void prv_destroy(SessionWindow *sw) {
     thinking_layer_destroy(sw->thinking_layer);
     sw->thinking_layer = NULL;
   }
-  for (int i = sw->segments_deleted; i < sw->segment_count; ++i) {
-    segment_layer_destroy(sw->segment_layers[i]);
-  }
   free(sw->segment_layers);
   window_destroy(sw->window);
   if (sw->starting_prompt) {
@@ -307,6 +307,7 @@ static void prv_conversation_manager_handler(bool entry_added, void* context) {
     }
     return;
   }
+  Conversation *conversation = conversation_manager_get_conversation(sw->manager);
   // If we have a new entry, we might just want to replace the old segment layer - we don't
   // keep old Thought segments around.
   if (sw->segment_count > sw->segments_deleted) {
@@ -320,9 +321,9 @@ static void prv_conversation_manager_handler(bool entry_added, void* context) {
       layer_remove_from_parent(last_layer);
       segment_layer_destroy(last_layer);
       sw->segment_layers[--sw->segment_count] = NULL;
+      conversation_delete_last_thought(conversation);
     }
   }
-  Conversation *conversation = conversation_manager_get_conversation(sw->manager);
   ConversationEntry* entry = conversation_peek(conversation);
   if (entry == NULL) {
     // ??????
@@ -370,6 +371,7 @@ static void prv_conversation_manager_handler(bool entry_added, void* context) {
       break;
     case EntryTypePrompt:
     case EntryTypeThought:
+    case EntryTypeDeleted:
       // nothing to do here.
       break;
   }
@@ -390,6 +392,10 @@ static void prv_conversation_entry_deleted_handler(int index, void* context) {
   SegmentLayer *to_delete = sw->segment_layers[sw->segments_deleted];
   int16_t removed_height = layer_get_frame(to_delete).size.h;
   for (int i = sw->segments_deleted + 1; i < sw->segment_count; ++i) {
+    if (sw->segment_layers[i] == NULL) {
+      BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Segment layer %d is NULL (not possible!?)", i);
+      continue;
+    }
     SegmentLayer *layer = sw->segment_layers[i];
     GRect frame = layer_get_frame(layer);
     frame.origin.y -= removed_height;