busy.c

Go to the documentation of this file.

/*
 * File Name: busy.c
 */

/*
 * This file is part of sysd.
 *
 * sysd is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * sysd is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>
#include <stdio.h>

// ereader include files, between < >

// local include files, between " "
#include "log.h"
#include "ipc.h"

#define UNUSED(x) (void)(x)


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------
 
typedef struct
{
    gint sender;
    GPid pid;
    gint fg_count;
    gint bg_count;
} busy_count_t;


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

enum 
{
    BACKGROUND,
    FOREGROUND
};

const gint dialog_delay  = 1000; // ms
const gint busyled_delay = 1000; // ms


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static GSList       *g_app_counters     = NULL;
static gchar        *g_message          = NULL;
static guint        g_dialog_source     = 0;
static guint        g_background_count  = 0;
static guint        g_foreground_count  = 0;


//============================================================================
// Local Function Definition
//============================================================================

static void          count_ref              (gint sender, gint mode);
static void          count_unref            (gint sender, gint mode);
static void          count_set_pid          (gint sender, GPid pid);
static void          count_remove_pid       (GPid pid);
static gint          ref_count              (gint mode);
static void          update                 (void);
static void          show_dialog            (gboolean on);
static gboolean      delay_dialog_cb        (gpointer data);


//============================================================================
// Functions Implementation
//============================================================================

gboolean busy_add_background(gint sender)
{
//    LOGPRINTF("entry");
    
    count_ref(sender, BACKGROUND);
    
    return TRUE;
}


gboolean busy_remove_background(gint sender)
{
//    LOGPRINTF("entry");
    
    count_unref(sender, BACKGROUND);

    return TRUE;
}


gboolean busy_add_foreground(gint sender, enum busy_dialog dialog_mode, const char *message)
{
    LOGPRINTF("entry");

    count_ref(sender, FOREGROUND);

    // replace message
    if (g_message)
    {
        g_free(g_message);
    }
    
    if (message)
    {
        g_message = g_strdup(message);
    }
    else
    {
        g_message = NULL;
    }
    
    if (dialog_mode == BUSY_DIALOG_DIRECT)
    {
        show_dialog(TRUE);
    }
    else if (dialog_mode == BUSY_DIALOG_DELAYED)
    {
        if (g_dialog_source == 0)
        {
            LOGPRINTF("delay %d ms before show busy DIALOG", dialog_delay);
            g_dialog_source = g_timeout_add(dialog_delay, delay_dialog_cb, NULL);
        }
        else
        {
            LOGPRINTF("already waiting for busy DIALOG");
        }
    }

    return TRUE;
}


gboolean busy_remove_foreground(gint sender)
{
//    LOGPRINTF("entry");

    count_unref(sender, FOREGROUND);
    
    return TRUE;
}


gboolean is_busy_foreground()
{
    if (g_foreground_count > 0)
    {
        return TRUE;
    }
    return FALSE;
}


gboolean is_busy_background()
{
    if (g_background_count > 0)
    {
        return TRUE;
    }
    return FALSE;
}


void busy_set_pid(gint sender, GPid pid)
{
//    LOGPRINTF("entry, sender [%d] pid [%d]", sender, pid);
    
    count_set_pid(sender, pid);
}


void busy_reset_pid(GPid pid)
{
//    LOGPRINTF("entry, pid [%d]", pid);
    
    count_remove_pid(pid);
}


//============================================================================
// Local Function Implementation
//============================================================================

static void show_dialog(gboolean on)
{
    static gboolean is_shown = FALSE;
    
    LOGPRINTF("entry: on [%d] is_shown [%d]", on, is_shown);

    if (on && !is_shown)
    {
        LOGPRINTF("show busy DIALOG!");
        ipc_show_busy(TRUE, g_message);
        is_shown = TRUE;
    }
    else if (!on && is_shown)
    {
        LOGPRINTF("hide busy DIALOG!");
        ipc_show_busy(FALSE, NULL);
        is_shown = FALSE;
    }
}


static gboolean delay_dialog_cb(gpointer data)
{
    UNUSED(data);
    LOGPRINTF("entry");

    if (ref_count(FOREGROUND) > 0)
    {
        show_dialog(TRUE);
    }
    else
    {
        LOGPRINTF("busy DIALOG not needed anymore");
    }
    
    g_dialog_source = 0;
    // remove source
    return FALSE;
}


static void count_set_pid(gint sender, GPid pid)
{
    LOGPRINTF("entry sender [%d] pid [%d]", sender, pid);
    
    GSList *busy_ptr = g_app_counters;
    busy_count_t *cur_busy = NULL;

    // get application from list
    while (busy_ptr)
    {
        cur_busy = (busy_count_t *) busy_ptr->data;

        if (cur_busy->sender == sender)
        {
            cur_busy->pid = pid;
            return;
        }
        busy_ptr = busy_ptr->next;
    }
    
    // application not yet in list, add now
    busy_count_t *busy = g_new0 (busy_count_t, 1);
    if (!busy)
    {
        ERRORPRINTF("mem alloc failed");
        return;
    }
    
    busy->sender = sender;
    busy->pid = pid;
    
    g_app_counters = g_slist_prepend(g_app_counters, busy);
    
    return;
}


static void count_ref(gint sender, gint mode)
{
    LOGPRINTF("entry sender [%d], %s", sender, mode == 0 ? "BACKGROUND" : "FOREGROUND");
    
    GSList *busy_ptr = g_app_counters;
    busy_count_t *cur_busy = NULL;

    // get application from list
    while (busy_ptr)
    {
        cur_busy = (busy_count_t *) busy_ptr->data;

        if (cur_busy->sender == sender)
        {
            // increment reference count
            if (mode == FOREGROUND)
            {
                cur_busy->fg_count++;
            }
            cur_busy->bg_count++;
            LOGPRINTF("sender [%d] bg_count [%d] fg_count [%d]", sender, cur_busy->bg_count, cur_busy->fg_count);

            update();
            return;
        }
        busy_ptr = busy_ptr->next;
    }
    
    // application not yet in list, add now
    busy_count_t *busy = g_new0 (busy_count_t, 1);
    if (!busy)
    {
        ERRORPRINTF("mem alloc failed");
        return;
    }
    
    busy->sender = sender;
    if (mode == FOREGROUND)
    {
        busy->fg_count = 1;
    }
    busy->bg_count = 1;
    
    g_app_counters = g_slist_prepend(g_app_counters, busy);
    
    LOGPRINTF("sender [%d] bg_count [%d] fg_count [%d]", sender, busy->bg_count, busy->fg_count);
    update();
    return;
}


static void count_unref(gint sender, gint mode)
{
    LOGPRINTF("entry sender [%d], mode [%d]", sender, mode);
    
    GSList *busy_ptr = g_app_counters;
    busy_count_t *cur_busy = NULL;

    // get application from list
    while (busy_ptr)
    {
        cur_busy = (busy_count_t *) busy_ptr->data;

        if (cur_busy->sender == sender)
        {
            // decrement reference count
            if (mode == FOREGROUND)
            {
                if (cur_busy->fg_count > 0)
                {
                    cur_busy->fg_count--;
                }
            }
            if (cur_busy->bg_count > 0)
            {
                cur_busy->bg_count--;
            }
            
            LOGPRINTF("sender [%d] bg_count [%d] fg_count [%d]", sender, cur_busy->bg_count, cur_busy->fg_count);
            
            update();
            return;
        }
        busy_ptr = busy_ptr->next;
    }
    
    return;
}


static void count_remove_pid(GPid pid)
{
    LOGPRINTF("entry pid [%d]", pid);
    
    GSList *busy_ptr = g_app_counters;
    busy_count_t *cur_busy = NULL;

    // get application from list
    while (busy_ptr)
    {
        cur_busy = (busy_count_t *) busy_ptr->data;
        if (cur_busy->pid == pid)
        {
            LOGPRINTF("found pid [%d] sender [%d] bg count [%d] fg count [%d]", cur_busy->pid, cur_busy->sender, cur_busy->bg_count, cur_busy->fg_count);
            g_app_counters = g_slist_delete_link(g_app_counters, busy_ptr);
            update();
            return;
        }
        busy_ptr = busy_ptr->next;
    }
    
    return;
}


static gint ref_count(gint mode)
{
//    LOGPRINTF("entry");
    
    gint count = 0;
    GSList *busy_ptr = g_app_counters;
    while (busy_ptr)
    {
        if (mode == FOREGROUND)
            count += ((busy_count_t *) busy_ptr->data)->fg_count;
        else
            count += ((busy_count_t *) busy_ptr->data)->bg_count;
        busy_ptr = busy_ptr->next;
    }
    
    if (mode == FOREGROUND)
      LOGPRINTF("foreground [%d]", count);
    else 
      LOGPRINTF("background [%d]", count);
    
    return count;
}


static gboolean do_update_rgb_led(gpointer data)
{
    UNUSED(data);
    sys_update_rgb_led();
    return FALSE;
}


static void update()
{
    LOGPRINTF("entry: background [%d] foreground [%d]", ref_count(BACKGROUND), ref_count(FOREGROUND));
    
    guint old_foreground_count = g_foreground_count;
    g_background_count = ref_count(BACKGROUND);
    g_foreground_count = ref_count(FOREGROUND);
    
    if (g_background_count == 0)
    {
        // reset idle because a screen update may follow
        // which resets the idle time anyhow
        sys_reset_idle_time();
    }

    if (g_foreground_count != old_foreground_count)
    {
        if (g_foreground_count == 1)
        {
            g_timeout_add(busyled_delay, do_update_rgb_led, NULL);
        }
        else if (g_foreground_count == 0)
        {
            if (g_dialog_source)
            {
                LOGPRINTF("stop busy dialog timer");
                g_source_remove(g_dialog_source);
                g_dialog_source = 0;
            }
            sys_update_rgb_led();
            show_dialog(FALSE);
        }
    }
}