open_plugin.c access open_plugin_entry through a function

just a few updates to open_plugin save a bit of space by granting access through a getter function

Change-Id: I2c0eaa1ade867510798b213006064ee1c00aa016

3 files changed, 108 insertions, 58 deletions

diff --git a/apps/open_plugin.c b/apps/open_plugin.c
index 58c3058fce..49d727b4c9 100644
--- a/apps/open_plugin.c
+++ b/apps/open_plugin.c
@@ -32,11 +32,9 @@
 #include "logf.h"
 
 #define ROCK_EXT "rock"
-#define ROCK_LEN 5
+#define ROCK_LEN sizeof(ROCK_EXT)
 #define OP_EXT "opx"
-#define OP_LEN 4
-
-struct open_plugin_entry_t open_plugin_entry = {0};
+#define OP_LEN sizeof(OP_EXT)
 
 static const uint32_t open_plugin_csum = OPEN_PLUGIN_CHECKSUM;
 
@@ -44,7 +42,7 @@ static const int op_entry_sz = sizeof(struct open_plugin_entry_t);
 
 static const char* strip_rockbox_root(const char *path)
 {
-    int dlen = strlen(ROCKBOX_DIR);
+    int dlen = ROCKBOX_DIR_LEN;
     if (strncmp(path, ROCKBOX_DIR, dlen) == 0)
         path+= dlen;
     return path;
@@ -55,11 +53,14 @@ static inline void op_clear_entry(struct open_plugin_entry_t *entry)
     if (entry == NULL)
         return;
     memset(entry, 0, op_entry_sz);
-    entry->lang_id = -1;
+    entry->lang_id = OPEN_PLUGIN_LANG_INVALID;
 }
 
 static int op_entry_checksum(struct open_plugin_entry_t *entry)
 {
+/*Note: since we use langids as checksums everytime someone moves the lang file
+* around it could mess with our indexing so invalidate entries when this occurs
+*/
     if (entry == NULL || entry->checksum != open_plugin_csum +
         (entry->lang_id <= OPEN_PLUGIN_LANG_INVALID ? 0 : LANG_LAST_INDEX_IN_ARRAY))
     {
@@ -117,7 +118,7 @@ static int op_find_entry(int fd, struct open_plugin_entry_t *entry,
 #endif
        (ret > OPEN_PLUGIN_NOT_FOUND && op_entry_checksum(entry) <= 0))
     {
-        splash(HZ * 2, "OpenPlugin Invalid entry");
+        splashf(HZ * 2, "%s Invalid entry", str(LANG_OPEN_PLUGIN));
         ret = OPEN_PLUGIN_NOT_FOUND;
     }
     if (ret == OPEN_PLUGIN_NOT_FOUND)
@@ -215,7 +216,7 @@ static int op_update_dat(struct open_plugin_entry_t *entry, bool clear)
     return 0;
 }
 
-static int op_get_entry(uint32_t hash, int32_t lang_id,
+static int op_load_entry(uint32_t hash, int32_t lang_id,
                         struct open_plugin_entry_t *entry, const char *dat_file)
 {
     int opret = OPEN_PLUGIN_NOT_FOUND;
@@ -238,7 +239,8 @@ static int op_get_entry(uint32_t hash, int32_t lang_id,
         }
 
         /* if another entry is loaded; flush it to disk before we destroy it */
-        op_update_dat(&open_plugin_entry, true);
+
+        op_update_dat(open_plugin_get_entry(), true);
 
         logf("OP get_entry hash: %x lang id: %d db: %s", hash, lang_id, dat_file);
 
@@ -252,17 +254,41 @@ static int op_get_entry(uint32_t hash, int32_t lang_id,
     return opret;
 }
 
+/******************************************************************************/
+/******************************************************************************/
+/* ************************************************************************** */
+/* * PUBLIC INTERFACE FUNCTIONS * *********************************************/
+/* ************************************************************************** */
+/******************************************************************************/
+/******************************************************************************/
+
+/* open_plugin_get_entry()
+* returns the internal open_plugin_entry
+*/
+struct open_plugin_entry_t * open_plugin_get_entry(void)
+{
+    /* holds entry data to load/run/store */
+    static struct open_plugin_entry_t open_plugin_entry = {0};
+    return &open_plugin_entry;
+}
+
+/* open_plugin_add_path()
+* adds a plugin path and calling parameters to open_plugin_entry
+* hash of the key is created for later recall of the plugin path and parameters
+* returns hash of the key or 0 on error
+*/
 uint32_t open_plugin_add_path(const char *key, const char *plugin, const char *parameter)
 {
-    int len;
+    size_t len;
     uint32_t hash;
     int32_t lang_id;
     char *pos = "\0";
+    struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
 
     if(key == NULL)
     {
         logf("OP add_path No Key, *Clearing entry*");
-        op_clear_entry(&open_plugin_entry);
+        op_clear_entry(op_entry);
         return 0;
     }
 
@@ -271,37 +297,37 @@ uint32_t open_plugin_add_path(const char *key, const char *plugin, const char *p
     logf("OP add_path key: %s lang id: %d", skey, lang_id);
     open_plugin_get_hash(strip_rockbox_root(skey), &hash);
 
-    if(open_plugin_entry.hash != hash)
+    if(op_entry->hash != hash)
     {
         logf("OP add_path *Flush entry*");
         /* the entry in ram needs saved */
-        op_update_dat(&open_plugin_entry, true);
+        op_update_dat(op_entry, true);
     }
 
     if (plugin)
     {
-        open_plugin_entry.hash     = hash;
-        open_plugin_entry.lang_id  = lang_id;
-        open_plugin_entry.checksum = open_plugin_csum +
+        op_entry->hash     = hash;
+        op_entry->lang_id  = lang_id;
+        op_entry->checksum = open_plugin_csum +
             (lang_id <= OPEN_PLUGIN_LANG_INVALID ? 0 : LANG_LAST_INDEX_IN_ARRAY);
         /* name */
         if (path_basename(plugin, (const char **)&pos) == 0)
             pos = "\0";
 
-        len = strlcpy(open_plugin_entry.name, pos, OPEN_PLUGIN_NAMESZ);
+        len = strlcpy(op_entry->name, pos, OPEN_PLUGIN_NAMESZ);
         if (len > ROCK_LEN && strcasecmp(&(pos[len-ROCK_LEN]), "." ROCK_EXT) == 0)
         {
             /* path */
-            strmemccpy(open_plugin_entry.path, plugin, OPEN_PLUGIN_BUFSZ);
+            strmemccpy(op_entry->path, plugin, OPEN_PLUGIN_BUFSZ);
 
             if(!parameter)
                 parameter = "";
-            strmemccpy(open_plugin_entry.param, parameter, OPEN_PLUGIN_BUFSZ);
+            strmemccpy(op_entry->param, parameter, OPEN_PLUGIN_BUFSZ);
             goto retnhash;
         }
         else if (len > OP_LEN && strcasecmp(&(pos[len-OP_LEN]), "." OP_EXT) == 0)
         {
-            op_get_entry(0, OPEN_PLUGIN_LANG_IGNORE, &open_plugin_entry, plugin);
+            op_load_entry(0, OPEN_PLUGIN_LANG_IGNORE, op_entry, plugin);
             goto retnhash;
         }
     }
@@ -309,33 +335,37 @@ uint32_t open_plugin_add_path(const char *key, const char *plugin, const char *p
     logf("OP add_path Invalid, *Clearing entry*");
     if (lang_id != LANG_SHORTCUTS) /* from shortcuts menu */
         splashf(HZ * 2, str(LANG_OPEN_PLUGIN_NOT_A_PLUGIN), pos);
-    op_clear_entry(&open_plugin_entry);
+    op_clear_entry(op_entry);
     hash = 0;
 
 retnhash:
     logf("OP add_path name: %s %s %s",
-         open_plugin_entry.name,
-         open_plugin_entry.path,
-         open_plugin_entry.param);
+         op_entry->name, op_entry->path, op_entry->param);
     return hash;
 }
 
+/* open_plugin_browse()
+* allows fthe user to browse for a plugin to set to a supplied key
+* if key is a lang_id that is used otherwise a hash of the key is created
+* for later recall of the plugin path
+*/
 void open_plugin_browse(const char *key)
 {
-    logf("OP browse");
+    logf("%s", __func__);
     struct browse_context browse;
     char tmp_buf[OPEN_PLUGIN_BUFSZ+1];
-    open_plugin_get_entry(key, &open_plugin_entry);
+    open_plugin_load_entry(key);
+    struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
 
     logf("OP browse key: %s name: %s",
-        (key ? P2STR((unsigned char *)key):"No Key") ,open_plugin_entry.name);
-    logf("OP browse %s %s", open_plugin_entry.path, open_plugin_entry.param);
+        (key ? P2STR((unsigned char *)key):"No Key"), open_plugin_entry.name);
+    logf("OP browse %s %s", op_entry->path, op_entry->param);
 
-    if (open_plugin_entry.path[0] == '\0')
-        strcpy(open_plugin_entry.path, PLUGIN_DIR"/");
+    if (op_entry->path[0] == '\0')
+        strcpy(op_entry->path, PLUGIN_DIR"/");
 
     browse_context_init(&browse, SHOW_ALL, BROWSE_SELECTONLY, "",
-                         Icon_Plugin, open_plugin_entry.path, NULL);
+                         Icon_Plugin, op_entry->path, NULL);
 
     browse.buf = tmp_buf;
     browse.bufsize = OPEN_PLUGIN_BUFSZ;
@@ -344,45 +374,59 @@ void open_plugin_browse(const char *key)
         open_plugin_add_path(key, tmp_buf, NULL);
 }
 
-int open_plugin_get_entry(const char *key, struct open_plugin_entry_t *entry)
+/* open_plugin_load_entry()
+* recall of the plugin path and parameters based on supplied key
+* returns the index in OPEN_PLUGIN_DAT where the entry was found (>= 0)
+* if the entry was found but has not been saved returns OPEN_PLUGIN_NEEDS_FLUSHED 
+* otherwise returns OPEN_PLUGIN_NOT_FOUND (< 0) if key was not found
+*/
+int open_plugin_load_entry(const char *key)
 {
-    if (key == NULL || entry == NULL)
-        return OPEN_PLUGIN_NOT_FOUND;
+    if (key == NULL)
+        key = ID2P(LANG_OPEN_PLUGIN_NOT_A_PLUGIN); /* won't be found */
+
+    struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
     int opret;
     uint32_t hash = 0;
     int32_t lang_id = P2ID((unsigned char *)key);
     const char* skey = P2STR((unsigned char *)key); /* string|LANGPTR => string */
 
+    /*Note: P2ID() returns -1 if key isnt a valid lang_id */
     if (lang_id <= OPEN_PLUGIN_LANG_INVALID)
         open_plugin_get_hash(strip_rockbox_root(skey), &hash); /* in open_plugin.h */
 
-    opret = op_get_entry(hash, lang_id, entry, OPEN_PLUGIN_DAT);
+    opret = op_load_entry(hash, lang_id, op_entry, OPEN_PLUGIN_DAT);
     logf("OP entry hash: %x lang id: %d ret: %d key: %s", hash, lang_id, opret, skey);
 
     if (opret == OPEN_PLUGIN_NOT_FOUND && lang_id > OPEN_PLUGIN_LANG_INVALID)
     {   /* try rb defaults */
-        opret = op_get_entry(hash, lang_id, entry, OPEN_RBPLUGIN_DAT);
+        opret = op_load_entry(hash, lang_id, op_entry, OPEN_RBPLUGIN_DAT);
         logf("OP rb_entry hash: %x lang id: %d ret: %d key: %s", hash, lang_id, opret, skey);
         /* add to the user plugin.dat file if found */
-        op_update_dat(entry, false);
+        op_update_dat(op_entry, false);
 
     }
     logf("OP entry ret: %s", (opret == OPEN_PLUGIN_NOT_FOUND ? "Not Found":"Found"));
     return opret;
 }
 
+/* open_plugin_run()
+* recall of the plugin path and parameters based on supplied key
+* runs the plugin using plugin_load see plugin_load for return values
+*/
 int open_plugin_run(const char *key)
 {
     int ret = 0;
-    int opret = open_plugin_get_entry(key, &open_plugin_entry);
+    int opret = open_plugin_load_entry(key);
+    struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
     if (opret == OPEN_PLUGIN_NEEDS_FLUSHED)
-        op_update_dat(&open_plugin_entry, false);
-    const char *path = open_plugin_entry.path;
-    const char *param = open_plugin_entry.param;
+        op_update_dat(op_entry, false);
+    const char *path = op_entry->path;
+    const char *param = op_entry->param;
 
     logf("OP run key: %s ret: %d name: %s",
-        (key ? P2STR((unsigned char *)key):"No Key"), opret, open_plugin_entry.name);
-    logf("OP run: %s %s %s", open_plugin_entry.name, path, param);
+        (key ? P2STR((unsigned char *)key):"No Key"), opret, op_entry->name);
+    logf("OP run: %s %s %s", op_entry->name, path, param);
 
     if (param[0] == '\0')
         param = NULL;
@@ -392,24 +436,28 @@ int open_plugin_run(const char *key)
     ret = plugin_load(path, param);
 
     if (ret != GO_TO_PLUGIN)
-        op_clear_entry(&open_plugin_entry);
+        op_clear_entry(op_entry);
 
     return ret;
 }
 
+/* open_plugin_cache_flush()
+* saves the current open_plugin_entry to disk
+*/
 void open_plugin_cache_flush(void)
 {
-    logf("OP *cache flush*");
+    logf("%s", __func__);
+    struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
     /* start_in_screen == 0 is 'Previous Screen' it is actually
      *  defined as (GO_TO_PREVIOUS = -2) + 2 for *Legacy?* reasons AFAICT */
     if (global_settings.start_in_screen == 0 &&
         global_status.last_screen == GO_TO_PLUGIN &&
-        open_plugin_entry.lang_id > OPEN_PLUGIN_LANG_INVALID)
+        op_entry->lang_id > OPEN_PLUGIN_LANG_INVALID)
     {
         /* flush the last item as LANG_PREVIOUS_SCREEN if the user wants to resume */
-        open_plugin_entry.lang_id = LANG_PREVIOUS_SCREEN;
+        op_entry->lang_id = LANG_PREVIOUS_SCREEN;
     }
-    op_update_dat(&open_plugin_entry, true);
+    op_update_dat(op_entry, true);
 }
 
 #endif /* ndef __PCTOOL__ */
diff --git a/apps/open_plugin.h b/apps/open_plugin.h
index 62e3662849..847a834c0c 100644
--- a/apps/open_plugin.h
+++ b/apps/open_plugin.h
@@ -64,7 +64,6 @@ struct open_plugin_entry_t
     offsetof(struct open_plugin_entry_t, lang_id)  + \
     offsetof(struct open_plugin_entry_t, checksum) + \
     offsetof(struct open_plugin_entry_t, name)     + \
-    /*offsetof(struct open_plugin_entry_t, key)+*/   \
     offsetof(struct open_plugin_entry_t, path)     + \
     offsetof(struct open_plugin_entry_t, param))
 
@@ -79,9 +78,9 @@ inline static void open_plugin_get_hash(const char *key, uint32_t *hash)
 }
 
 #ifndef PLUGIN
-extern struct open_plugin_entry_t open_plugin_entry;
+struct open_plugin_entry_t* open_plugin_get_entry(void);
 uint32_t open_plugin_add_path(const char *key, const char *plugin, const char *parameter);
-int open_plugin_get_entry(const char *key, struct open_plugin_entry_t *entry);
+int open_plugin_load_entry(const char *key);
 void open_plugin_browse(const char *key);
 int open_plugin_run(const char *key);
 void open_plugin_cache_flush(void); /* flush to disk */
diff --git a/apps/root_menu.c b/apps/root_menu.c
index 89afae8c25..49e579903f 100644
--- a/apps/root_menu.c
+++ b/apps/root_menu.c
@@ -760,9 +760,11 @@ static int load_plugin_screen(char *key)
 
     while(loops-- > 0) /* just to keep things from getting out of hand */
     {
-        int opret = open_plugin_get_entry(key, &open_plugin_entry);
-        char *path = open_plugin_entry.path;
-        char *param = open_plugin_entry.param;
+        
+        int opret = open_plugin_load_entry(key);
+        struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
+        char *path = op_entry->path;
+        char *param = op_entry->param;
         if (param[0] == '\0')
             param = NULL;
         if (path[0] == '\0' && key)
@@ -792,8 +794,8 @@ static int load_plugin_screen(char *key)
         if (opret != OPEN_PLUGIN_NEEDS_FLUSHED || last_screen != GO_TO_WPS)
         {
             /* Keep the entry in case of GO_TO_PREVIOUS */
-            open_plugin_entry.hash = 0; /*remove hash -- prevents flush to disk */
-            open_plugin_entry.lang_id = LANG_PREVIOUS_SCREEN;
+            op_entry->hash = 0; /*remove hash -- prevents flush to disk */
+            op_entry->lang_id = LANG_PREVIOUS_SCREEN;
             /*open_plugin_add_path(NULL, NULL, NULL);// clear entry */
         }
         break;
@@ -962,8 +964,9 @@ void root_menu(void)
                 char *key;
                 if (global_status.last_screen == GO_TO_SHORTCUTMENU)
                 {
-                    if (open_plugin_entry.lang_id == LANG_OPEN_PLUGIN)
-                        open_plugin_entry.lang_id = LANG_SHORTCUTS;
+                    struct open_plugin_entry_t *op_entry = open_plugin_get_entry();
+                    if (op_entry->lang_id == LANG_OPEN_PLUGIN)
+                        op_entry->lang_id = LANG_SHORTCUTS;
                     shortcut_origin = last_screen;
                     key = ID2P(LANG_SHORTCUTS);
                 }