fuck it.

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

Author: Katharine

app/package.json

@@ -491,6 +491,11 @@
           "targetPlatforms": [
             "diorite"
           ]
+        },
+        {
+          "file": "images/skull.pdc",
+          "name": "IMAGE_SKULL",
+          "type": "raw"
         }
       ]
     }

app/resources/images/skull.pdc

@@ -17,6 +17,7 @@
 #include <pebble.h>
 #include "../../../image_manager/image_manager.h"
 #include "../../../util/memory/sdk.h"
+#include "../../../util/thinking_layer.h"
 
 #include "map.h"
 
@@ -26,6 +27,8 @@ static void prv_layer_update(Layer *layer, GContext *ctx);
 typedef struct {
   ConversationEntry* entry;
   GBitmap* bitmap;
+  ThinkingLayer* loading_layer;
+  GDrawCommandImage *skull_image;
 } MapWidgetData;
 
 static inline int prv_get_image_id(MapWidgetData *data) {
@@ -39,6 +42,8 @@ MapWidget* map_widget_create(GRect rect, ConversationEntry* entry) {
   MapWidgetData* data = layer_get_data(layer);
   data->entry = entry;
   data->bitmap = NULL;
+  data->loading_layer = thinking_layer_create(GRect(rect.size.w / 2 - THINKING_LAYER_WIDTH / 2, image_size.h / 2 - THINKING_LAYER_HEIGHT / 2, THINKING_LAYER_WIDTH, THINKING_LAYER_HEIGHT));
+  layer_add_child(layer, data->loading_layer);
   image_manager_register_callback(image_id, prv_image_updated, layer);
   layer_set_update_proc(layer, prv_layer_update);
   return layer;
@@ -54,6 +59,12 @@ void map_widget_destroy(MapWidget* layer) {
   if (data->bitmap) {
     gbitmap_destroy(data->bitmap);
   }
+  if (data->loading_layer) {
+    thinking_layer_destroy(data->loading_layer);
+  }
+  if (data->skull_image) {
+    gdraw_command_image_destroy(data->skull_image);
+  }
   int image_id = prv_get_image_id(data);
   image_manager_unregister_callback(image_id);
   layer_destroy(layer);
@@ -67,13 +78,26 @@ static void prv_image_updated(int image_id, ImageStatus status, void *context) {
   Layer *layer = context;
   MapWidgetData* data = layer_get_data(layer);
   if (status == ImageStatusCompleted) {
+    if (data->loading_layer) {
+      layer_remove_from_parent(data->loading_layer);
+      thinking_layer_destroy(data->loading_layer);
+      data->loading_layer = NULL;
+    }
     if (data->bitmap) {
       gbitmap_destroy(data->bitmap);
     }
     data->bitmap = image_manager_get_image(image_id);
     layer_mark_dirty(layer);
   } else if (status == ImageStatusDestroyed) {
+    if (data->loading_layer) {
+      layer_remove_from_parent(data->loading_layer);
+      thinking_layer_destroy(data->loading_layer);
+      data->loading_layer = NULL;
+    }
     data->bitmap = NULL;
+    if (!data->skull_image) {
+      data->skull_image = bgdraw_command_image_create_with_resource(RESOURCE_ID_IMAGE_SKULL);
+    }
     layer_mark_dirty(layer);
   }
 }
@@ -100,5 +124,9 @@ static void prv_layer_update(Layer *layer, GContext *ctx) {
   } else {
     graphics_context_set_fill_color(ctx, COLOR_FALLBACK(GColorLightGray, GColorWhite));
     graphics_fill_rect(ctx, image_rect, 0, GCornerNone);
+    if (data->skull_image) {
+      GSize skull_size = gdraw_command_image_get_bounds_size(data->skull_image);
+      gdraw_command_image_draw(ctx, data->skull_image, GPoint(image_rect.origin.x + image_rect.size.w / 2 - skull_size.w / 2, image_rect.origin.y + image_rect.size.h / 2 - skull_size.h / 2));
+    }
   }
 }

app/src/c/converse/segments/widgets/map.c

@@ -36,24 +36,19 @@ typedef struct {
 
 static void prv_inbox_received(DictionaryIterator *iterator, void *context);
 static ManagedImage *prv_find_image(int image_id);
-static int16_t prv_find_image_index(int image_id);
-static bool prv_image_id_compare(void *image_id, void *object);
-static void prv_destroy_image(ManagedImage *image);
-static bool prv_foreach_destroy(void *object, void *context);
+static void prv_destroy_image();
 static void prv_handle_new_image(int image_id, size_t size, DictionaryIterator *iterator);
 static void prv_handle_image_chunk(int image_id, size_t offset, DictionaryIterator *iterator);
 static void prv_handle_image_complete(int image_id);
-static bool prv_handle_memory_pressure(void *context);
 
+
+static ManagedImage s_managed_image = {0};
+static uint8_t s_image_storage[PBL_IF_COLOR_ELSE(3800, 1900)] = {0};
 static EventHandle *s_appmessage_handle;
-static LinkedRoot *s_image_list;
-static ManagedImage *s_cached_image_ref = NULL;
 
 void image_manager_init() {
-  s_image_list = linked_list_create_root();
   events_app_message_request_inbox_size(1024);
   s_appmessage_handle = events_app_message_register_inbox_received(prv_inbox_received, NULL);
-  memory_pressure_register_callback(prv_handle_memory_pressure, 0, NULL);
 }
 
 void image_manager_deinit() {
@@ -94,63 +89,32 @@ GSize image_manager_get_size(int image_id) {
 }
 
 void image_manager_destroy_image(int image_id) {
-  int16_t image_idx = prv_find_image_index(image_id);
-  if (image_idx < 0) {
+  if (s_managed_image.image_id != image_id) {
     return;
   }
-  ManagedImage *image = linked_list_get(s_image_list, image_idx);
-  prv_destroy_image(image);
-  linked_list_remove(s_image_list, image_idx);
+  prv_destroy_image();
 }
 
 void image_manager_destroy_all_images() {
-  linked_list_foreach(s_image_list, prv_foreach_destroy, NULL);
-  linked_list_clear(s_image_list);
+  prv_destroy_image();
 }
 
 static ManagedImage *prv_find_image(int image_id) {
-  if (s_cached_image_ref != NULL && s_cached_image_ref->image_id == image_id) {
-    return s_cached_image_ref;
-  }
-  int16_t idx = prv_find_image_index(image_id);
-  if (idx >= 0) {
-    return linked_list_get(s_image_list, idx);
+  if (s_managed_image.image_id != image_id) {
+    return NULL;
   }
-  return NULL;
-}
-
-static int16_t prv_find_image_index(int image_id) {
-  return linked_list_find_compare(s_image_list, &image_id, prv_image_id_compare);
+  return &s_managed_image;
 }
 
-static bool prv_image_id_compare(void *image_id, void *object) {
-  ManagedImage *image = object;
-  return image->image_id == *(int *)image_id;
-}
-
-static void prv_destroy_image(ManagedImage *image) {
-  image->status = ImageStatusDestroyed;
-  if (image->callback) {
-    image->callback(image->image_id, ImageStatusDestroyed, image->context);
-  }
-  if (image->bitmap) {
-    gbitmap_destroy(image->bitmap);
-    image->bitmap = NULL;
+static void prv_destroy_image() {
+  s_managed_image.status = ImageStatusDestroyed;
+  if (s_managed_image.callback) {
+    s_managed_image.callback(s_managed_image.image_id, ImageStatusDestroyed, s_managed_image.context);
   }
-  if (image->data) {
-    free(image->data);
-    image->data = NULL;
+  if (s_managed_image.bitmap) {
+    gbitmap_destroy(s_managed_image.bitmap);
+    s_managed_image.bitmap = NULL;
   }
-  if (s_cached_image_ref == image) {
-    s_cached_image_ref = NULL;
-  }
-  free(image);
-}
-
-static bool prv_foreach_destroy(void *object, void *context) {
-  ManagedImage *image = object;
-  prv_destroy_image(image);
-  return true;
 }
 
 static void prv_inbox_received(DictionaryIterator *iterator, void *context) {
@@ -183,19 +147,16 @@ static void prv_handle_new_image(int image_id, size_t size, DictionaryIterator *
   tuple = dict_find(iterator, MESSAGE_KEY_IMAGE_HEIGHT);
   int16_t height = tuple->value->int32;
   BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "New image: %d, size: %d, width: %d, height: %d", image_id, size, width, height);
-  ManagedImage *image = bmalloc(sizeof(ManagedImage));
-  if (!image) {
-    BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Failed to allocate memory for image");
-    return;
+  if (s_managed_image.image_id != 0) {
+    prv_destroy_image();
   }
-  image->image_id = image_id;
-  image->status = ImageStatusCreated;
-  image->callback = NULL;
-  image->data = bmalloc(size);
-  image->size = size;
-  image->bitmap = NULL;
-  image->image_size = GSize(width, height);
-  linked_list_append(s_image_list, image);
+  s_managed_image.image_id = image_id;
+  s_managed_image.status = ImageStatusCreated;
+  s_managed_image.callback = NULL;
+  s_managed_image.data = s_image_storage;
+  s_managed_image.size = size;
+  s_managed_image.bitmap = NULL;
+  s_managed_image.image_size = GSize(width, height);
 }
 
 static void prv_handle_image_chunk(int image_id, size_t offset, DictionaryIterator *iterator) {
@@ -245,15 +206,3 @@ static void prv_handle_image_complete(int image_id) {
     image->callback(image->image_id, ImageStatusCompleted, image->context);
   }
 }
-
-
-static bool prv_handle_memory_pressure(void *context) {
-  if (linked_list_count(s_image_list) == 0) {
-    return false;
-  }
-  BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Memory pressure! Destroying the oldest image.");
-  ManagedImage *image = linked_list_get(s_image_list, 0);
-  prv_destroy_image(image);
-  linked_list_remove(s_image_list, 0);
-  return true;
-}

app/src/c/image_manager/image_manager.c

@@ -23,19 +23,19 @@
 void *bmalloc(size_t size) {
   int heap_size = heap_bytes_free();
   BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "malloc request: %d; free: %d", size, heap_size);
-  void *ptr = malloc(size);
-  if (ptr) {
-    return ptr;
-  }
-  BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Out of memory! Need to allocate %d bytes; %d bytes free.", size, heap_size);
   while (true) {
-    void *ptr = malloc(size);
-    if (ptr) {
-      return ptr;
+    if (heap_bytes_free() > 750) {
+      void *ptr = malloc(size);
+      if (ptr) {
+        return ptr;
+      }
+      BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Out of memory! Need to allocate %d bytes; %d bytes free.", size, heap_size);
+    } else {
+      BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Low memory (%d byte free); trying to free some before allocating %d bytes.", heap_size, size);
     }
     if (!memory_pressure_try_free()) {
       BOBBY_LOG(APP_LOG_LEVEL_ERROR, "Failed to allocate memory: couldn't free enough heap.");
-      return NULL;
+      return malloc(size);
     }
     int new_heap_size = heap_bytes_free();
     BOBBY_LOG(APP_LOG_LEVEL_INFO, "Freed %d bytes, heap size is now %d. Retrying allocation of %d bytes.", heap_size - new_heap_size, new_heap_size, size);

app/src/c/util/memory/malloc.c

@@ -68,16 +68,16 @@ void memory_pressure_unregister_callback(MemoryPressureHandler handler) {
 
 bool memory_pressure_try_free() {
   BOBBY_LOG(APP_LOG_LEVEL_WARNING, "Memory emergency! Trying to free memory.");
-  int priority = 0;
   int count = linked_list_count(s_callback_list);
   if (count == 0) {
     BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "No memory freeing callbacks registered");
     return false;
   }
-  for (int p = 0; p < s_max_priority; ++p) {
+  for (int p = 0; p <= s_max_priority; ++p) {
+    BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "Trying priority level %d", p);
     for (int i = 0; i < count; ++i) {
       MemoryPressureCallbackEntry *entry = linked_list_get(s_callback_list, i);
-      if (entry->priority != priority) {
+      if (entry->priority != p) {
         continue;
       }
       BOBBY_LOG(APP_LOG_LEVEL_DEBUG, "Calling memory pressure callback %p with priority %d", entry->handler, entry->priority);