---

reminders.c

Go to the documentation of this file.

/*
 * reminders.c:  Translate Palm datebook into REMIND format
 *
 * Copyright (c) 1996, Kenneth Albanowski
 *
 * This program 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.
 *
 * This program 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, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

/*
 * rwil extension of reminders.c: Turning alarms in to real world information
 * 1/17/2002
 *
 * This extension to a Palm datebook reading program extracts all appointments
 * with alarms and queues them in an rwi device.  When an alarm goes off, the
 * rwi device is triggered and the brightness of the device will be interpolated
 * over the length of the alarm.  Some testing feedback is printed on the console
 * for all appointments with alarms found and queued.
*/   

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "pi-source.h"
#include "pi-socket.h"
#include "pi-datebook.h"
#include "pi-dlp.h"
#include "pi-header.h"

//header for rwil commands
#include "procrwil.h"

volatile int value=0;

char *Weekday[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
char *Month[12]  = { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"};

//The callback function is executed when a device finishes its assigned
//task.  The value variable stores the number of items queued for the
//rwil.
void SuccessCallback(rwil_device dev)
{
        value--;
        printf("Callback\n");
}


int main(int argc, char *argv[])
{
        rwil_handle rwi_handle; //a handle is necessary
        rwil_device rwi_device; //create the device to be used by rwil 
        struct tm start_time;
        struct pi_sockaddr addr;
        int db;
        int sd;
        int i;
        struct PilotUser U;
        int ret;
        unsigned char buffer[0xffff];
        char *progname = argv[0];
        char *device = argv[1];

        PalmHeader(progname);
        
        rwi_handle=rwil_init(); //we must initialize the handle
        rwi_device=rwil_create(rwi_handle,'A',1);
        //the device must be created and have the handle passed in
        //the A and 1 in this case is the location of the device we
        //are operating upon.  This is hardcoded for demo purposes
        rwil_success_callback(SuccessCallback); 
        //attach the callback function we created to rwil's built
        //in callback

        if (argc != 2) {
                fprintf(stderr, "   Usage: %s %s\n\n", argv[0], TTYPrompt);
                exit(2);
        }
        if (!(sd = pi_socket(PI_AF_SLP, PI_SOCK_STREAM, PI_PF_PADP))) {
                perror("pi_socket");
                exit(1);
        }

        addr.pi_family = PI_AF_SLP;
        strncpy(addr.pi_device, device, sizeof(addr.pi_device));

        ret = pi_bind(sd, (struct sockaddr *) &addr, sizeof(addr));
        if (ret == -1) {
                fprintf(stderr, "\n   Unable to bind to port %s\n",
                        device);
                perror("   pi_bind");
                fprintf(stderr, "\n");
                exit(1);
        }

        printf
            ("   Port: %s\n\n  Please press the HotSync button now...\n",
             device);

        ret = pi_listen(sd, 1);
        if (ret == -1) {
                fprintf(stderr, "\n   Error listening on %s\n", device);
                perror("   pi_listen");
                fprintf(stderr, "\n");
                exit(1);
        }

        sd = pi_accept(sd, 0, 0);
        if (sd == -1) {
                fprintf(stderr, "\n   Error accepting data on %s\n",
                        device);
                perror("   pi_accept");
                fprintf(stderr, "\n");
                exit(1);
        }

        fprintf(stderr, "Connected...\n");

        dlp_ReadUserInfo(sd, &U);

        dlp_OpenConduit(sd);

        if (dlp_OpenDB(sd, 0, 0x80 | 0x40, "DatebookDB", &db) < 0) {
                puts("Unable to open DatebookDB");
                dlp_AddSyncLogEntry(sd, "Unable to open DatebookDB.\n");
                pi_close(sd);
                exit(1);
        }

        for (i = 0;; i++) {
                struct Appointment a;
                int attr;
                int j;
                char delta[80];
                char satisfy[256];


                int len =
                    dlp_ReadRecordByIndex(sd, db, i, buffer, 0, 0, &attr,
                                          0);
              
                if (len < 0)
                        break;

                if ((attr & dlpRecAttrDeleted)
                    || (attr & dlpRecAttrArchived))
                        continue;

                unpack_Appointment(&a, buffer, len);
                strcpy(delta, "+7 ");
                satisfy[0] = 0;



                if(a.advance){

                start_time=a.begin;
               

                printf("Year    is: %d\n", start_time.tm_year);
                printf("Month   is: %d\n", start_time.tm_mon);
                printf("Day Mon is: %d\n", start_time.tm_mday);
                printf("Hours   is: %d\n", start_time.tm_hour);
                printf("Minutes is: %d\n", start_time.tm_min);
                printf("Seconds is: %d\n", start_time.tm_sec);
                printf("Alarm   is: %d\n", a.advance);
                printf("Start Time: %d\n", mktime(&start_time)-a.advance*60);
                printf("End Time  : %d\n", mktime(&start_time));
                printf("Time      : %d\n", time(0));
                value++;
                rwil_interpolatebright(rwi_device, 0, 100, mktime(&start_time)-a.advance*60, mktime(&start_time), 5);
                //the interpolatebright function queue's a group of actions that will cause the device's brightness (or power)
                //to go from a designated start to end level over a period of time.  Here the device starts at 0 and will
                //finish at 100% power.  The starting time is determined by the time of the appointment and alarm in the Palm device.
                //The interpolate will begin when the alarm for the appointment goes off and will end when the appointment
                //has arrived.  Here the alarm is in minutes, which is converted to seconds and subtracted from the actual appointment time
                //Therefore an appointment at 3:30pm with an alarm 5 minutes before will cause the interpolate to start at 3:25 and finish
                //at 3:30 with 100%. The number of steps used in the interpolation in this call is 5.
                value++; //queue has increased
                rwil_off(rwi_device, time(0)); 
                }
                
                free_Appointment(&a);

        }
        dlp_CloseDB(sd, db);

        dlp_AddSyncLogEntry(sd, "Read datebook from Palm.\n");

        pi_close(sd);
        while(value) 
        //continue executing program while value is not zero (the queue is not empty)
        //if the program cannot end before rwil is finished and ready
          {}
       
        
        rwil_destroy(rwi_device);
        rwil_shutdown(rwi_handle);
        return 0;
}

---