alarm_d.cxx

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

    for (idx = 0; idx < MAX_RECS; idx++)
	rec_array[idx] = -1;

    alarm_db_->Select(ALARM_DATABASE, rec_array, MAX_RECS);

    for (idx = 0; idx < MAX_RECS; idx++) {
	if (-1 == rec_array[idx])
	    continue;
	alarm_db_->Extract(ALARM_DATABASE, rec_array[idx], STATUS, c_value);
	if (0 != atoi(c_value)) {
	    DPRINT("status [%d]\n", atoi(c_value));
	    continue;
	}
	DPRINT("idx [%d]\n", idx);
	alarm_db_->Extract(ALARM_DATABASE, rec_array[idx], ALARM_TIME,
			   c_value);
	temp_value = strtol(c_value, NULL, 10);
	DPRINT("temp_value [%ld]\n", temp_value);
	if (temp_value < l_value) {
	    DPRINT("temp_value smaller than l_value\n");
	    l_value = temp_value;
	    DPRINT("set l_value [%ld]\n", l_value);
	    small_rec = rec_array[idx];
	}
    }
    if (-1 == small_rec)
	return 0;
    else {
	alarm_db_->Extract(ALARM_DATABASE, small_rec, RECNO, c_value);
	desc_.alarm_recno = atoi(c_value);
	alarm_db_->Extract(ALARM_DATABASE, small_rec, NAME, desc_.appname);
	alarm_db_->Extract(ALARM_DATABASE, small_rec, NAME_RECNO, c_value);
	desc_.recno = atoi(c_value);
	alarm_db_->Extract(ALARM_DATABASE, small_rec, DESCRIPTION,
			   desc_.desc);
	alarm_db_->Extract(ALARM_DATABASE, small_rec, START_TIME, c_value);
	desc_.start_time = strtol(c_value, NULL, 10);
	alarm_db_->Extract(ALARM_DATABASE, small_rec, END_TIME, c_value);
	desc_.end_time = strtol(c_value, NULL, 10);

	return l_value;
    }
}

void
Alarm_d::SetId()
{

    int temp_rec = 0;
    char buf[16];
    int num_recs = alarm_db_->NumRecs(ALARM_DATABASE);
    int idx = 0;

    id_ = 0;
    if (num_recs == MAX_RECS) {
	id_ = -1;
    } else {
	for (idx = 0; idx < num_recs; idx++) {
	    alarm_db_->Extract(ALARM_DATABASE, idx, RECNO, buf);
	    temp_rec = atoi(buf);
	    if (temp_rec > id_)
		id_ = temp_rec;
	}
    }
    if (INT_MAX == id_) {
	int rec_array[MAX_RECS];

	for (idx = 0; idx < MAX_RECS; idx++)
	    rec_array[idx] = -1;

	alarm_db_->Select(ALARM_DATABASE, rec_array, MAX_RECS);

	id_ = 0;
	for (idx = 0; idx < MAX_RECS; idx++) {
	    if (-1 == rec_array[idx])
		continue;

	    char record[MAXRECSIZ];

	    // try to reset the id of the recno starting at zero    
	    alarm_db_->Extract(ALARM_DATABASE, rec_array[idx], record);
	    put16(&record[cFields[RECNO].offset], id_);
	    alarm_db_->Edit(ALARM_DATABASE, rec_array[idx], record);
	    id_++;
	}
	if (INT_MAX == id_)
	    id_ = -1;
    }
    if (-1 == id_)
	error_ = ERROR_MAX_DB;

}

void
Alarm_d::MarkEntry(int flag)
{

    int rec_array[1];
    int status;
    char c_value[8];
    char buf[MAXRECSIZ];
    int flag_;

    sprintf(buf, "%d", desc_.alarm_recno);
    alarm_db_->Select(ALARM_DATABASE, buf, RECNO, rec_array, 1);
    alarm_db_->Extract(ALARM_DATABASE, rec_array[0], STATUS, c_value);
    status = atoi(c_value);

    flag_ = status | flag;

    alarm_db_->Extract(ALARM_DATABASE, rec_array[0], buf);
    put16(&buf[cFields[STATUS].offset], flag_);
    alarm_db_->Edit(ALARM_DATABASE, rec_array[0], buf);

}

// Remove alarm if it is already set in the database
void
Alarm_d::CheckAlarm(char *service, int recno)
{
    int rec_array[MAX_RECS];
    int idx = 0;
    char c_value[16];

    for (idx = 0; idx < MAX_RECS; idx++)
	rec_array[idx] = -1;

    alarm_db_->Select(ALARM_DATABASE, service, NAME, rec_array, MAX_RECS);
    for (idx = 0; idx < MAX_RECS; idx++) {
	if (-1 == rec_array[idx])
	    continue;
	alarm_db_->Extract(ALARM_DATABASE, rec_array[idx], NAME_RECNO,
			   c_value);
	if (recno == atoi(c_value))
	    alarm_db_->DeleteRec(ALARM_DATABASE, rec_array[idx]);
    }

}

void
Alarm_d::RemoveEntry()
{
    int rec_array[1];
    char buf[16];

    sprintf(buf, "%d", desc_.alarm_recno);
    alarm_db_->Select(ALARM_DATABASE, buf, RECNO, rec_array, 1);
    alarm_db_->DeleteRec(ALARM_DATABASE, rec_array[0]);
    if (ERROR_MAX_DB & error_)
	error_ = error_ ^ ERROR_MAX_DB;
}

void
Alarm_d::ParseMsg(char *msg)
{

    DPRINT("Parsing msg: [%s]\n", msg);
    char *service = new char[MAX_LEN];
    char *msg_cmd = new char[MAX_LEN];
    char *app_name = new char[MAX_LEN];
    char buf[MAXRECSIZ];
    int err = 0;

    char *tmp = strtok(msg, TOKEN);
    strcpy(service, tmp);

    tmp = strtok(NULL, TOKEN);
    if (NULL == tmp)
	return;
    strcpy(msg_cmd, tmp);

    if (strcmp(msg_cmd, "SET") == 0) {
	char *c_recno = new char[16];
	char *desc = new char[DESC];
	char *c_start_time = new char[16];
	char *c_end_time = new char[16];
	char *c_alarm_time = new char[16];
	int recno;
	long start_time = 0;
	long end_time = 0;
	long alarm_time = 0;

	tmp = strtok(NULL, TOKEN);
	strcpy(c_recno, tmp);
	recno = strtol(c_recno, (char **) NULL, 10);
	if (ERANGE == errno)
	    err = -1;

	tmp = strtok(NULL, TOKEN);
	if (NULL == tmp)
	    err = -1;
	else
	    strcpy(desc, tmp);

	tmp = strtok(NULL, TOKEN);
	if (NULL == tmp)
	    err = -1;
	else {
	    strcpy(c_start_time, tmp);
	    start_time = strtol(c_start_time, NULL, 10);
	    if (ERANGE == errno)
		err = -1;
	}

	tmp = strtok(NULL, TOKEN);
	if (NULL == tmp)
	    err = -1;
	else {
	    strcpy(c_end_time, tmp);
	    end_time = strtol(c_end_time, NULL, 10);
	    if (ERANGE == errno)
		err = -1;
	}

	tmp = strtok(NULL, TOKEN);
	if (NULL == tmp)
	    err = -1;
	else {
	    strcpy(c_alarm_time, tmp);
	    alarm_time = strtol(c_alarm_time, NULL, 10);
	    if (ERANGE == errno)
		err = -1;
	}

	if (-1 == id_) {	// no room left in db can register alarm
	    err = -1;
	    SendErrorMsg(service);
	}
	if (0 == err) {
	    id_++;
	    memset(buf, 0, MAXRECSIZ);
	    put16(&buf[cFields[RECNO].offset], id_);
	    strcpy(&buf[cFields[NAME].offset], service);
	    put16(&buf[cFields[NAME_RECNO].offset], recno);
	    strcpy(&buf[cFields[DESCRIPTION].offset], desc);
	    put32(&buf[cFields[START_TIME].offset], start_time);
	    put32(&buf[cFields[END_TIME].offset], end_time);
	    put32(&buf[cFields[ALARM_TIME].offset], alarm_time);
	    put16(&buf[cFields[STATUS].offset], 0);

	    CheckAlarm(service, recno);
	    alarm_db_->Insert(ALARM_DATABASE, buf);
	}

	delete[]c_recno;
	delete[]desc;
	delete[]c_start_time;
	delete[]c_end_time;
	delete[]c_alarm_time;
	c_recno = desc = c_start_time = c_end_time = c_alarm_time = 0;

    }

    if (strcmp(msg_cmd, "DELETE") == 0) {
	DPRINT("recievced DELETE\n");
	char *c_recno = new char[16];
	int recno = 0;

	tmp = strtok(NULL, TOKEN);
	if (NULL == tmp)
	    err = -1;
	else {
	    strcpy(c_recno, tmp);
	    recno = strtol(c_recno, (char **) NULL, 10);
	    if (ERANGE == errno)
		err = -1;
	}

	DPRINT("err [%d]\n", err);
	if (0 == err) {
	    int rec_array[MAX_RECS];
	    int idx = 0;
	    int app_recno;
	    char c_app_recno[16];
	    char name[APP_NAME];

	    for (idx = 0; idx < MAX_RECS; idx++)
		rec_array[idx] = -1;

	    alarm_db_->Select(ALARM_DATABASE, rec_array, MAX_RECS);

	    for (idx = 0; idx < MAX_RECS; idx++) {
		if (-1 == rec_array[idx])
		    continue;

		alarm_db_->Extract(ALARM_DATABASE, rec_array[idx], NAME,
				   name);
		DPRINT("service [%s] name [%s]\n", service, name);
		if (0 == strcmp(name, service)) {
		    alarm_db_->Extract(ALARM_DATABASE, rec_array[idx],
				       NAME_RECNO, c_app_recno);
		    app_recno = strtol(c_app_recno, (char **) NULL, 10);
		    DPRINT("app_recno [%d]\n", app_recno);
		    if (ERANGE == errno)
			err = -1;
		    if ((0 == err) && (app_recno == recno)) {
			DPRINT("DeleteRec\n");
			alarm_db_->DeleteRec(ALARM_DATABASE, rec_array[idx]);
		    }
		}
	    }
	}
	delete[]c_recno;
	c_recno = 0;
    }
    delete[]service;
    delete[]msg_cmd;
    delete[]app_name;
    service = msg_cmd = app_name = 0;
}

int
Alarm_d::ReadMsg()
{
    unsigned short ret;
    int err;
    char msg[MAX_LEN];
    int len = MAX_LEN;

    status_ = STATUS_READ;
    err = ClGetMessage(msg, &len, &ret);
    status_ = STATUS_CLEAR;
    if (0 > err)
	return -1;

    ParseMsg(msg);
    return 0;
}

void
Alarm_d::SendErrorMsg(char *service)
{

    int fd = ClFindApp((unsigned char *) (service));
    char msg[255];
    int len = sizeof(msg);

    sprintf(msg, "%s^INITIATE^0", ALARM_D);
    status_ = STATUS_WRITE_ERR;
    ClSendMessage(fd, msg, len);
    status_ = STATUS_CLEAR;
    sprintf(msg, "%s^ERROR^%d", ALARM_D, error_);
    status_ = STATUS_WRITE_ERR;
    ClSendMessage(fd, msg, len);
    status_ = STATUS_CLEAR;

}

int
Alarm_d::SendMsg()
{
    int err = 0;
    int flags;
    int len = sizeof(desc_.msg);
    char msg[255];

    desc_.fd = ClFindApp((unsigned char *) (desc_.appname));

    DPRINT("desc_.fd [%d]\n", desc_.fd);
    if (0 >= desc_.fd) {

	flags = 0;
	DPRINT("Trying to start [%s]\n", desc_.appname);
	desc_.fd = ClStartApp((unsigned char *) (desc_.appname),
			      (unsigned char *) NULL, flags, 5);
	if (0 >= desc_.fd) {
	    DPRINT("Unable to start [%s]\n", desc_.appname);
	    MarkEntry(ERROR_START);
	    return -1;
	}
    }
#ifdef CONFIG_NANOX
    // force the app to raise
    DPRINT("Show [%s]\n", desc_.appname);
    scrtopShowApp(desc_.appname);
#endif

    sprintf(msg, "%s^INITIATE^0", ALARM_D);

    status_ = STATUS_WRITE_MSG;
    ClSendMessage(desc_.fd, msg, sizeof(msg));
    status_ = STATUS_CLEAR;

    sprintf(desc_.msg, "%s^ALARM^%d^%s^%ld^%ld",
	    ALARM_D, desc_.recno, desc_.desc, desc_.start_time,
	    desc_.end_time);
    DPRINT("sending msg [%s]\n", desc_.msg);
    status_ = STATUS_WRITE_MSG;
    err = ClSendMessage(desc_.fd, desc_.msg, len);
    status_ = STATUS_CLEAR;
    if (0 > err) {
	DPRINT("Unable to send message\n");
	MarkEntry(ERROR_SEND);
	return -1;
    }
    RemoveEntry();
    return 0;

}

void
Alarm_d::OpenAlarmDatabase()
{
    if (!alarm_db_->Open(ALARM_DATABASE, &cFile, cFields, ALARM_INDEX)) {
	if (alarm_db_->Create(ALARM_DATABASE, &cFile, cFields, ALARM_INDEX)) {
	    if (!alarm_db_->
		Open(ALARM_DATABASE, &cFile, cFields, ALARM_INDEX)) {
		exit(-1);
	    }
	} else
	    exit(-1);
    }
}

Alarm_d::~Alarm_d()
{
    close(rtcfd_);
    close(fd_);
    CloseDB();
    delete alarm_db_;
    alarm_db_ = 0;
    unlink(path);
}