contentLister/src/timedids.c File Reference

lister - Handle timed-iDS connection More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <linux/rtc.h>
#include <fcntl.h>
#include <gtk/gtk.h>
#include <liberregxml/erregapi.h>
#include <libermanifest/ermanifest.h>
#include "contentListerLog.h"
#include "system.h"
#include "gtkPincodeScreen.h"
#include "erConnect.h"
#include "control.h"
#include "button.h"
#include "displayUpdate.h"
#include "timedids.h"

Go to the source code of this file.

Defines
#define	SECONDS_OF_DAY   86400
Functions
static void	handle_wakeup ()
static void	handle_normal_startup ()
static regTimedIds_t *	read_timedids_settings ()
static void	create_timedids_trigger ()
static int	get_current_tz_offset ()
void	timed_ids_init ()
gboolean	on_timedids_connect_after_wakeup (gpointer p)
void	timed_ids_handle_recreate_timer (gint interval)
void	timed_ids_handle_connmgr_quit ()
void	timed_ids_handle_reread_settings ()
void	timed_ids_final ()
timedids_connect_reason	get_timedids_connect_reason ()
void	set_timedids_connect_reason (timedids_connect_reason connReason)
Variables
static regTimedIds_t *	g_timedids_settings = NULL
static timedids_connect_reason	g_connect_reason = connect_undefined
static guint	g_timeout_source_id = 0
static int	g_current_tzoffset = 0

---

Detailed Description

lister - Handle timed-iDS connection

<File description>="">

Definition in file timedids.c.

---

Define Documentation

#define SECONDS_OF_DAY   86400

Definition at line 55 of file timedids.c.

---

Function Documentation

void create_timedids_trigger

(

)

[static]

Definition at line 194 of file timedids.c.

{
    time_t utc_second = time(NULL);
    int local_second = (utc_second + g_current_tzoffset) % SECONDS_OF_DAY;

    int i, time_left = 0;
    for (i=0; i<g_timedids_settings->timeCnt; i++)
    {
        if (g_timedids_settings->timeSet[i] > local_second)
        {
            time_left = g_timedids_settings->timeSet[i] - local_second;
            break;
        }
    }

    if (i == g_timedids_settings->timeCnt)
    {
        time_left = SECONDS_OF_DAY + g_timedids_settings->timeSet[0] - local_second;
    }

    g_timeout_source_id = g_timeout_add(time_left*1000,
            on_idle_connect_start_background, (gpointer)connect_timed_ids_background);
}

Here is the call graph for this function:

int get_current_tz_offset

(

)

[static]

Definition at line 377 of file timedids.c.

{
    FILE* fp = fopen(TZ_FILE, "rb");

    if (NULL == fp)
    {
        CL_ERRORPRINTF("Can't open %s, use default timezone settings.", TZ_FILE);
        return 0;
    }

    fseek(fp, sizeof(struct tzhead), SEEK_SET);
    
    int offset;
    if (fread(&offset, sizeof(int), 1, fp) != 1)
    {
        CL_ERRORPRINTF("Error reading %s, use default timezone settings.", TZ_FILE);
        fclose(fp);
        return 0;
    }
    
    fclose(fp);
    
    return GINT32_FROM_BE(offset);
}

timedids_connect_reason get_timedids_connect_reason

(

)

Definition at line 402 of file timedids.c.

{
    return g_connect_reason;
}

void handle_normal_startup

(

)

[static]

Definition at line 166 of file timedids.c.

{
    CL_LOGPRINTF("entry");
    
    int rtc, ret;

    // Open device
    rtc = open ("/dev/rtc", O_RDWR);
    if (rtc == -1)
    {
        CL_ERRORPRINTF("Can NOT open /dev/rtc");
        return;
    }
    
    // First, disable RTC alarm interrupt
    ret = ioctl(rtc, RTC_AIE_OFF, 0);
    if (ret == -1)
    {
        CL_ERRORPRINTF("Can NOT disable RTC alarm interrupt");
        return;
    }

    close(rtc);

    // Second, create a time-out event instead
    create_timedids_trigger();
}

Here is the call graph for this function:

void handle_wakeup

(

)

[static]

Definition at line 136 of file timedids.c.

{
    CL_LOGPRINTF("entry");

    // Block keys if iLiad is waken up by RTC alarm
    button_block_all_keys(TRUE);

    g_connect_reason = connect_after_wakeup;
}

Here is the call graph for this function:

gboolean on_timedids_connect_after_wakeup

(

gpointer

p

)

Definition at line 146 of file timedids.c.

{
    CL_LOGPRINTF("entry");

    // Launch connectionMgr to download contents (include software updates if needed)
    ctrl_disconnect_wait();
    if (g_timedids_settings->swUpdate)
    {
        ctrl_connect(connectScrDownloadHistory, connect_timed_ids_with_sw);
    }
    else
    {
        ctrl_connect(connectScrDownloadHistory, connect_timed_ids_content_only);
    }

    display_update_decrease_level(LISTER_EXPOSE_LEVEL);

    return FALSE;
}

Here is the call graph for this function:

regTimedIds_t * read_timedids_settings

(

)

[static]

Definition at line 70 of file timedids.c.

{
    CL_LOGPRINTF("entry");

    regTimedIds_t* theTimedIds = NULL;

    theTimedIds = erRegGetTimedIds();
    if (theTimedIds == NULL)
    {
        CL_ERRORPRINTF("erRegGetTimedIds returns NULL");
    }

    return theTimedIds;
}

Here is the call graph for this function:

void set_timedids_connect_reason

(

timedids_connect_reason

connReason

)

Definition at line 407 of file timedids.c.

{
    g_connect_reason = connReason;
}

void timed_ids_final

(

)

Definition at line 304 of file timedids.c.

{
    CL_LOGPRINTF("entry");
 
    if (g_timedids_settings->enable)
    {
        // Re-create RTC alarm interrupt
        time_t utc_second = time(NULL);
        int local_second = (utc_second + g_current_tzoffset) % SECONDS_OF_DAY;

        int i;
        for(i=0; i<g_timedids_settings->timeCnt; i++)
        {
            if (g_timedids_settings->timeSet[i] > local_second)
            {
                break;
            }
        }

        if (i == g_timedids_settings->timeCnt)
        {
            i = 0;
        }
        
        int utc_alarm = g_timedids_settings->timeSet[i] - g_current_tzoffset;
        if (utc_alarm < 0)
        {
            utc_alarm += SECONDS_OF_DAY;
        }
        else if (utc_alarm > SECONDS_OF_DAY)
        {
            utc_alarm -= SECONDS_OF_DAY;
        }

        struct rtc_time rtc_tm;
        memset(&rtc_tm, 0, sizeof(struct rtc_time));
        rtc_tm.tm_hour = utc_alarm / 3600;
        rtc_tm.tm_min  = utc_alarm / 60 % 60;
        rtc_tm.tm_sec  = utc_alarm % 60;
       
        // Open device
        int rtc, ret;
        rtc = open ("/dev/rtc", O_RDWR);
        if (rtc == -1)
        {
            CL_ERRORPRINTF("Can NOT open /dev/rtc");
            return;
        }

        // Re-set RTC alarm to the next timeset in registry
        ret = ioctl(rtc, RTC_ALM_SET, &rtc_tm);
        if (ret == -1)
        {
            CL_ERRORPRINTF("Can NOT set RTC alarm");
            return;
        }

        CL_WARNPRINTF("RTC Alarm is set to %02d:%02d:%02d\n", rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
        
        // Re-enable RTC alarm interrupt
        ret = ioctl(rtc, RTC_AIE_ON, 0);
        if (ret == -1)
        {
            CL_ERRORPRINTF("Can NOT enable RTC alarm interrupt");
            return;
        }

        close(rtc);
    }
    
    erRegFreeTimedIds(g_timedids_settings);
}

Here is the call graph for this function:

void timed_ids_handle_connmgr_quit

(

)

Definition at line 230 of file timedids.c.

{
    CL_LOGPRINTF("entry");
    switch (g_connect_reason)
    {
        case connect_after_wakeup:
            if (g_timedids_settings->switchOff)
            {
                // Shut down iLiad, and also create RTC alarm for the next trigger point
                ctrl_shutdown();
            }
            else
            {
                create_timedids_trigger();

                button_block_all_keys(FALSE);
            }
            break;
        case connect_when_running:
            // Create time-out event for the next trigger point
            create_timedids_trigger();
            break;
        default:
            break;
    }
}

Here is the call graph for this function:

void timed_ids_handle_recreate_timer

(

gint

interval

)

Definition at line 218 of file timedids.c.

{
    if (g_timeout_source_id > 0)
    {
        g_source_remove(g_timeout_source_id);
        g_timeout_source_id = 0;
    }

    g_timeout_source_id = g_timeout_add(interval * 60 * 1000,
            on_idle_connect_start_background, (gpointer)connect_timed_ids_background);
}

Here is the call graph for this function:

void timed_ids_handle_reread_settings

(

)

Definition at line 257 of file timedids.c.

{
    CL_LOGPRINTF("entry");

    // Re-read timed-iDS connection settings
    regTimedIds_t* stored_timedids_settings = NULL;
    if ((stored_timedids_settings = read_timedids_settings()) == NULL)
    {
        CL_ERRORPRINTF("Can NOT read timed-iDS connection settings");
        return;
    }

    int new_tzoffset = get_current_tz_offset();
    gboolean settings_changed = FALSE;

    if (memcmp(stored_timedids_settings, g_timedids_settings, sizeof(regTimedIds_t)) != 0)
    {
        // User changed timed-iDS connection settings
        *g_timedids_settings = *stored_timedids_settings;
        settings_changed = TRUE;
    }
    if (new_tzoffset != g_current_tzoffset)
    {
        // User changed timezone
        g_current_tzoffset = new_tzoffset;
        settings_changed = TRUE;
    }

    if (settings_changed)
    {
        // First, remove current time-out trigger
        if (g_timeout_source_id > 0)
        {
            g_source_remove(g_timeout_source_id);
            g_timeout_source_id = 0;
        }

        // Second, re-create time-out trigger if timed-iDS enabled
        if (g_timedids_settings->enable)
        {
            create_timedids_trigger();
        }
    }

    erRegFreeTimedIds(stored_timedids_settings);    
}

Here is the call graph for this function:

void timed_ids_init

(

)

Definition at line 85 of file timedids.c.

{
    CL_LOGPRINTF("entry");
    
    // Check if we are waken up by RTC alarm interrupt or not
    // Get settings from registry
    if ((g_timedids_settings = read_timedids_settings()) == NULL)
    {
        CL_ERRORPRINTF("Can NOT read timed-iDS connection settings");
        return;
    }

    // Get current timezone offset
    g_current_tzoffset = get_current_tz_offset();

    if (!g_timedids_settings->enable)
    {
        // Nothing to do
        return;
    }

    time_t utc_second = time(NULL);
    struct tm* tm_local =  localtime(&utc_second);
    int local_second = tm_local->tm_hour * 3600 + tm_local->tm_min * 60 + tm_local->tm_sec;
    
    gboolean wakeup_by_alarm = FALSE;
    int i;
    for (i=0; i<g_timedids_settings->timeCnt; i++)
    {
        // If current time is <90 seconds later than 1 alarm time,
        // then we think we are being waken up by alarm interrupt
        if (local_second > g_timedids_settings->timeSet[i] &&
            local_second - g_timedids_settings->timeSet[i] <= 90)
        {
            wakeup_by_alarm = TRUE;
            break;
        }
    }

    if (wakeup_by_alarm)
    {
        // The iLiad is waken up by RTC alarm interrupt
        handle_wakeup();
    }
    else
    {
        // Normal startup
        handle_normal_startup();
    }
}

Here is the call graph for this function:

---

Variable Documentation

timedids_connect_reason g_connect_reason = connect_undefined [static]

Definition at line 59 of file timedids.c.

int g_current_tzoffset = 0 [static]

Definition at line 61 of file timedids.c.

regTimedIds_t* g_timedids_settings = NULL [static]

Definition at line 58 of file timedids.c.

guint g_timeout_source_id = 0 [static]

Definition at line 60 of file timedids.c.