GSM-Gnokii
view release on metacpan or search on metacpan
CODE:
if (opt_v) warn ("PrintError (%d)\n", errno);
warn ("%s\n", gn_error_print (errno));
/* PrintError */
void
_Initialize (self)
HV *self;
PPCODE:
opt_v = SvIV (*hv_fetch (self, "verbose", 7, 0));
if (opt_v) warn ("initialize ({ ... })\n");
unless (gn_lib_init () == GN_ERR_NONE)
croak (_("Failed to initialize libgnokii.\n"));
hv_puts (self, "libgnokii_version", LIBGNOKII_VERSION_STRING);
XSRETURN (0);
/* _Initialise */
void
_Connect (self)
HV *self;
PPCODE:
gn_error err;
if (opt_v) warn ("connect ()\n");
err = gn_lib_phoneprofile_load_from_file (configfile, configmodel, &state);
unless (err == GN_ERR_NONE) {
set_errori (err);
if (configfile)
warn (_("File: %s\n"), configfile);
if (configmodel)
clear_err ();
data = &state->sm_data;
XS_RETURNi (1);
/* _Connect */
void
disconnect (self)
HvObject *self;
PPCODE:
if (opt_v) warn ("disconnect ()\n");
if (hv_exists (self, "connected", 9)) {
(void)hv_del (self, "connected");
busterminate ();
}
XSRETURN (0);
/* disconnect */
* ###########################################################################
*/
void
GetPhonebook (self, memtype, start, end)
HvObject *self;
char *memtype;
int start;
int end;
PPCODE:
gn_phonebook_entry entry;
int mt, i, j;
AV *pb;
if (opt_v) warn ("GetPhonebook (%s, %d, %d)\n", memtype, start, end);
clear_data ();
if (start < 0 || start > 255) {
set_errors ("phonebook location should be in valid range 0..255");
}
XS_RETURNr (pb);
/* GetPhonebook */
void
WritePhonebookEntry (self, pbh)
HvObject *self;
HV *pbh;
PPCODE:
gn_error err;
gn_phonebook_entry entry;
int mt, i;
SV **value;
char *str;
STRLEN l;
if (opt_v) warn ("WritePhonebookEntry ({ ... })\n");
unless (hv_gets (pbh, "memorytype", str, l)) {
if (gn_sm_func (self, GN_OP_WritePhonebook))
XS_RETURNi (entry.location);
XSRETURN_UNDEF;
/* WritePhonebookEntry */
void
GetSpeedDial (self, location)
HvObject *self;
int location;
PPCODE:
gn_speed_dial *speeddial;
if (opt_v) warn ("Get Speed Dial %d\n", location);
if (location < 0)
croak ("Speed dial number should be >= 0\n");
clear_data ();
Newxz (speeddial, 1, gn_speed_dial);
speeddial->number = location;
XSRETURN_UNDEF;
/* GetSpeedDial */
void
SetSpeedDial (self, memtype, location, number)
HvObject *self;
char *memtype;
int location;
int number;
PPCODE:
/* TODO: This funtion is untested */
gn_error err;
gn_speed_dial entry;
clear_data ();
Zero (&entry, 1, entry);
set_memtype (entry.memory_type, memtype);
entry.number = number;
entry.location = location;
data->speed_dial = &entry;
* WriteTodo ({ ... })
* DeleteAllTodos ()
*
* ###########################################################################
*/
void
GetDateTime (self)
HvObject *self;
PPCODE:
gn_timestamp date_time;
if (opt_v) warn ("GetDateTime ()\n");
clear_data ();
data->datetime = &date_time;
if (gn_sm_func (self, GN_OP_GetDateTime)) {
HV *dt = newHV ();
GSMDATE_TO_TM ("date", date_time, dt);
XS_RETURNr (dt);
}
XSRETURN_UNDEF;
/* GetDateTime */
void
SetDateTime (self, timestamp)
HvObject *self;
time_t timestamp;
PPCODE:
gn_error err;
gn_timestamp date;
/* TODO: This funtion is untested */
if (opt_v) warn ("SetDateTime (%ld)\n", (long)timestamp);
clear_data ();
Zero (&date, 1, date);
data->datetime = &date;
HASH_TO_GSMDT (data->datetime, ×tamp);
err = gn_sm_functions (GN_OP_SetDateTime, data, state);
set_errori (err);
XS_RETURNi (err);
/* SetDateTime */
void
GetAlarm (self)
HvObject *self;
PPCODE:
gn_calnote_alarm alrm;
if (opt_v) warn ("GetAlarm ()\n");
clear_data ();
data->alarm = &alrm;
if (gn_sm_functions (GN_OP_GetAlarm, data, state) == GN_ERR_NONE) {
char tm[8];
HV *ah = newHV ();
sprintf (tm, "%02d:%02d", alrm.timestamp.hour, alrm.timestamp.minute);
}
XSRETURN_UNDEF;
/* GetAlarm */
void
SetAlarm (self, hour, minute)
HvObject *self;
int hour;
int minute;
PPCODE:
gn_calnote_alarm at;
int err;
clear_data ();
if (hour < 0 || hour > 23) {
set_errors ("Alarm hour must be in [0..23]");
XSRETURN_UNDEF;
}
if (minute < 0 || minute > 59) {
set_errors ("Alarm minute must be in [0..59]");
set_errori (err);
XS_RETURNi (err);
/* SetAlarm */
void
GetCalendarNotes (self, start, end)
HvObject *self;
int start;
int end;
PPCODE:
gn_calnote_list calendarnoteslist;
gn_calnote calendarnote;
int i, err;
AV *cnl = newAV ();
if (opt_v) warn ("GetCalenderNotes (%d, %d)\n", start, end);
if (start < 0) {
set_errors ("calendarnote location should be in positive");
XSRETURN_UNDEF;
set_errori (err);
}
XS_RETURNr (cnl);
/* GetCalendarNotes */
void
WriteCalendarNote (self, calhash)
HvObject *self;
HV *calhash;
PPCODE:
gn_calnote calnote;
char *buf;
time_t t1, *t2;
gn_timestamp *timestamp;
int err;
SV **value;
clear_data ();
Zero (&calnote, 1, calnote);
set_errori (err);
XS_RETURNi (calnote.location);
/* WriteCalendarNote */
void
GetTodo (self, start, end)
HvObject *self;
int start;
int end;
PPCODE:
gn_todo_list todolist;
gn_todo todo;
int i, err;
AV *tdl = newAV ();
if (opt_v) warn ("GetTodo (%d, %d)\n", start, end);
if (start < 0) {
set_errors ("todo location should be positive");
XSRETURN_UNDEF;
set_errori (err);
}
XS_RETURNr (tdl);
/* GetTodo */
void
WriteTodo (self, todohash)
HvObject *self;
HV *todohash;
PPCODE:
gn_todo todo;
char *buf;
int err;
clear_data ();
Zero (&todo, 1, todo);
strcpy (todo.text, SvPV_nolen (*hv_fetch (todohash, "text", 4, 0)));
buf = SvPV_nolen (*hv_fetch (todohash, "priority", 8, 0));
if (!strcasecmp (buf, "low"))
todo.priority = GN_TODO_LOW;
data->todo = &todo;
err = gn_sm_functions (GN_OP_WriteToDo, data, state);
set_errori (err);
XS_RETURNi (todo.location);
/* WriteTodo */
void
DeleteAllTodos (self)
HvObject *self;
PPCODE:
int err;
clear_data ();
err = gn_sm_functions (GN_OP_DeleteAllToDos, data, state);
set_errori (err);
XS_RETURNi (err);
/* DeleteAllTodos */
/* ###########################################################################
* Profile/Status Functionality
* GetDir (memorytype, path, depth)
* GetFile (path)
*
* ###########################################################################
*/
void
Ping (self)
HvObject *self;
PPCODE:
gn_error err;
if (opt_v) warn ("Ping ()\n");
unless (can_ping)
XSRETURN_UNDEF;
clear_data ();
if (gn_sm_func (self, GN_OP_Ping))
XS_RETURNi (1);
XS_RETURNi (0);
/* Ping */
void
GetDisplayStatus (self)
HvObject *self;
PPCODE:
int status = 0;
if (opt_v) warn ("GetDisplayStatus ()\n");
clear_data ();
data->display_status = &status;
if (gn_sm_func (self, GN_OP_GetDisplayStatus)) {
HV *ds = newHV ();
hv_puti (ds, "call_in_progress", status & (1 << GN_DISP_Call_In_Progress) ? 1 : 0);
XS_RETURNr (ds);
}
XSRETURN_UNDEF;
/* GetDisplayStatus */
void
GetIMEI (self)
HvObject *self;
PPCODE:
char imei[64], model[64], rev[64], manufacturer[64];
if (opt_v) warn ("GetIMEI ()\n");
clear_data ();
Zero (imei, 64, char);
Zero (model, 64, char);
Zero (rev, 64, char);
Zero (manufacturer, 64, char);
data->imei = imei;
hv_puts (ih, "manufacturer", data->manufacturer);
XS_RETURNr (ih);
}
XSRETURN_UNDEF;
/* GetIMEI */
void
GetPowerStatus (self)
HvObject *self;
PPCODE:
gn_power_source powersource = -1;
float batterylevel = -1;
gn_battery_unit batt_units = GN_BU_Arbitrary;
HV *ps = newHV ();
if (opt_v) warn ("GetPowerStatus ()\n");
clear_data ();
data->battery_unit = &batt_units;
data->battery_level = &batterylevel;
hv_putn (ps, "level", batterylevel);
if (gn_sm_functions (GN_OP_GetPowersource, data, state) == GN_ERR_NONE)
hv_puts (ps, "source", gn_power_source2str (powersource));
XS_RETURNr (ps);
/* GetPowerStatus */
void
GetMemoryStatus (self)
HvObject *self;
PPCODE:
HV *ms = newHV ();
if (opt_v) warn ("GetMemoryStatus ()\n");
clear_data ();
data->memory_status = &SIMMemoryStatus;
if (gn_sm_functions (GN_OP_GetMemoryStatus, data, state) == GN_ERR_NONE) {
hv_puti (ms, "simused", SIMMemoryStatus.used);
hv_puti (ms, "simfree", SIMMemoryStatus.free);
}
XS_RETURNr (ms);
/* GetMemoryStatus */
void
GetProfiles (self, start, end)
HvObject *self;
int start;
int end;
PPCODE:
gn_profile profile;
gn_ringtone_list rtl;
char model[64] = "";
int i, max_profiles = 7;
HV *p;
AV *pl = newAV ();
if (opt_v) warn ("GetProfiles (%d, %d)\n", start, end);
warn ("GetProfile () @ %d\n", __LINE__);
hv_puts (p, "automatic_answer", profile.automatic_answer ? "On" : "Off");
av_addr (pl, p);
}
XS_RETURNr (pl);
/* GetProfiles */
void
GetSecurity (self)
HvObject *self;
PPCODE:
gn_security_code sc;
if (opt_v) warn ("GetSecurity ()\n");
clear_data ();
Zero (&sc, 1, sc);
sc.type = GN_SCT_SecurityCode;
data->security_code = ≻
if (gn_sm_functions (GN_OP_GetSecurityCodeStatus, data, state) == GN_ERR_NONE) {
char *key;
XS_RETURNr (si);
}
XSRETURN_UNDEF;
/* GetSecurity */
void
GetLogo (self, logodata)
HvObject *self;
HV *logodata;
PPCODE:
gn_bmp bitmap;
char *type;
if (opt_v) warn ("GetLogo ({ type => ... })\n");
clear_data ();
Zero (&bitmap, 1, gn_bmp);
type = SvPV_nolen (*hv_fetch (logodata, "type", 4, 0));
if (!strcmp (type, "text")) bitmap.type = GN_BMP_WelcomeNoteText;
hv_puti (l, "width", bitmap.width);
XS_RETURNr (l);
}
XSRETURN_UNDEF;
/* GetLogo */
void
GetRingtoneList (self)
HV *self;
PPCODE:
gn_ringtone_list ringtone_list;
if (opt_v) warn ("GetRingtoneList ()\n");
clear_data ();
Zero (&ringtone_list, 1, ringtone_list);
data->ringtone_list = &ringtone_list;
if (gn_sm_functions (GN_OP_GetRingtoneList, data, state) == GN_ERR_NONE) {
HV *rl = newHV ();
XS_RETURNr (rl);
}
XSRETURN_UNDEF;
/* GetRingtoneList */
void
GetRingtone (self, location)
HvObject *self;
int location;
PPCODE:
gn_ringtone ringtone;
gn_raw_data rawdata;
unsigned char buff[512];
if (opt_v) warn ("GetRingtone (%d)\n", location);
Zero (&ringtone, 1, ringtone);
rawdata.data = buff;
rawdata.length = sizeof (buff);
clear_data ();
}
XSRETURN_UNDEF;
/* GetRingtone */
void
GetDirTree (self, memorytype, depth)
HvObject *self;
char *memorytype;
int depth;
PPCODE:
char *mt;
gn_file_list fl;
HV *dt;
if (opt_v) warn ("GetDirTree (%s, %d)\n", memorytype, depth);
if (!strcmp (memorytype, "ME"))
mt = "A:";
else if (!strcmp (memorytype, "SM"))
mt = "B:";
XS_RETURNr (dt);
/* GetDirTree */
void
GetDir (self, memorytype, path, depth)
HvObject *self;
char *memorytype;
char *path;
int depth;
PPCODE:
char *mt;
gn_file_list fl;
HV *dt;
if (opt_v) warn ("GetDir (%s, %s, %d)\n", memorytype, path, depth);
if (!strcmp (memorytype, "ME"))
mt = "A:";
else if (!strcmp (memorytype, "SM"))
mt = "B:";
hv_putr (dt, "tree", walk_tree (self, mt, &fl, depth));
XS_RETURNr (dt);
/* GetDir */
void
GetFile (self, path)
HvObject *self;
char *path;
PPCODE:
gn_file fi;
HV *dt;
if (opt_v) warn ("GetFile (%s)\n", path);
clear_data ();
Zero (&fi, 1, fi);
snprintf (fi.name, sizeof (fi.name), "%s", path);
data->file = &fi;
*
* ###########################################################################
*/
void
GetSMSCenter (self, start, end)
HvObject *self;
int start;
int end;
PPCODE:
gn_sms_message_center messagecenter;
int i, err;
AV *scl = newAV ();
if (opt_v) warn ("GetSMSCenter (%d, %d)\n", start, end);
if (start < 1 || start > 5) {
set_errors ("messagecenter location should be in valid range 1..5");
XSRETURN_UNDEF;
}
else
set_errori (err);
}
XS_RETURNr (scl);
/* GetSMSCenter */
void
GetSMSFolderList (self)
HvObject *self;
PPCODE:
gn_sms_folder_list folderlist;
AV *fl;
int i;
if (opt_v) warn ("GetSMSFolderList ()\n");
clear_data ();
Zero (&folderlist, 1, folderlist);
data->sms_folder_list = &folderlist;
unless (gn_sm_func (self, GN_OP_GetSMSFolders))
av_addr (fl, f);
}
XS_RETURNr (fl);
/* GetSMSFolderList */
void
CreateSMSFolder (self, name)
HvObject *self;
char *name;
PPCODE:
gn_sms_folder folder;
int err;
if (strlen (name) >= GN_SMS_FOLDER_NAME_MAX_LENGTH) {
set_errors ("Folder name too long");
XSRETURN_UNDEF;
}
clear_data ();
Zero (&folder, 1, folder);
err = gn_sm_functions (GN_OP_CreateSMSFolder, data, state);
set_errori (err);
XS_RETURNi (err);
/* CreateSMSFolder */
void
DeleteSMSFolder (self, location)
HvObject *self;
int location;
PPCODE:
gn_sms_folder folder;
int err;
if (location <= 0 || location > GN_SMS_FOLDER_MAX_NUMBER) {
set_errori (GN_ERR_INVALIDLOCATION);
XSRETURN_UNDEF;
}
clear_data ();
folder.folder_id = location;
data->sms_folder = &folder;
err = gn_sm_functions (GN_OP_DeleteSMSFolder, data, state);
set_errori (err);
XS_RETURNi (err);
/* DeleteSMSFolder */
void
GetSMSStatus (self)
HvObject *self;
PPCODE:
gn_sms_status SMSStatus;
if (opt_v) warn ("GetSMSStatus ()\n");
clear_data ();
Zero (&SMSStatus, 1, gn_sms_status);
data->sms_status = &SMSStatus;
if (gn_sm_func (self, GN_OP_GetSMSStatus)) {
HV *ss = newHV ();
hv_puti (ss, "unread", SMSStatus.unread);
}
XSRETURN_UNDEF;
/* GetSMSStatus */
void
GetSMS (self, memtype, location)
HvObject *self;
char *memtype;
int location;
PPCODE:
gn_sms message;
gn_sms_folder folder;
gn_sms_folder_list folderlist;
int i;
if (opt_v) warn ("GetSMS (%s, %d)\n", memtype, location);
clear_data ();
Zero (&message, 1, message);
}
XSRETURN_UNDEF;
/* GetSMS */
void
DeleteSMS (self, memtype, location)
HvObject *self;
char *memtype;
int location;
PPCODE:
gn_error err;
gn_sms message;
gn_sms_folder folder;
gn_sms_folder_list folderlist;
if (opt_v) warn ("DeleteSMS (%s, %d)\n", memtype, location);
clear_data ();
Zero (&message, 1, message);
Zero (&folder, 1, folder);
err = gn_sms_delete (data, state);
set_errori (err);
XS_RETURNi (err);
/* DeleteSMS */
void
SendSMS (self, smshash)
HvObject *self;
HV *smshash;
PPCODE:
gn_sms sms;
SV **value;
char *str;
STRLEN l;
int err = GN_ERR_NONE;
if (opt_v) warn ("SendSMS ({ destination => ..., message => ... })\n");
/* Options in gnokii:
* smsc
* smscno
* WriteWapBookmark ({ ... })
* DeleteWapBookmark (location)
*
* ###########################################################################
*/
void
GetRF (self)
HvObject *self;
PPCODE:
float rflevel = -1;
gn_rf_unit rfunit = GN_RF_Arbitrary;
HV *rf = newHV ();;
if (opt_v) warn ("GetRF ()\n");
clear_data ();
data->rf_unit = &rfunit;
data->rf_level = &rflevel;
if (gn_sm_func (self, GN_OP_GetRFLevel)) {
hv_putn (rf, "level", rflevel);
hv_puti (rf, "unit", rfunit);
}
XS_RETURNr (rf);
/* GetRF */
void
GetNetworkInfo (self)
HvObject *self;
PPCODE:
gn_network_info NetworkInfo;
char buffer[10];
if (opt_v) warn ("GetNetworkInfo ()\n");
clear_data ();
data->network_info = &NetworkInfo;
if (gn_sm_func (self, GN_OP_GetNetworkInfo)) {
HV *ni = newHV ();
XS_RETURNr (ni);
}
XSRETURN_UNDEF;
/* GetNetworkInfo */
void
GetWapSettings (self, location)
HvObject *self;
int location;
PPCODE:
gn_wap_setting entry;
HV *ws;
if (opt_v) warn ("GetWapSettings (%d)\n", location);
clear_data ();
Zero (&entry, 1, entry);
entry.location = location;
data->wap_setting = &entry;
unless (gn_sm_func (self, GN_OP_GetWAPSetting))
hv_puts (ws, "sms_servicenr", entry.sms_service_number);
hv_puts (ws, "sms_servernr", entry.sms_server_number);
XS_RETURNr (ws);
/* GetWapSettings */
void
WriteWapSetting (self, wh)
HvObject *self;
HV *wh;
PPCODE:
gn_error err;
gn_wap_setting entry;
char *buf;
STRLEN l;
clear_data ();
/* TODO: This funtion is untested */
Zero (&entry, 1, entry);
hv_geti (wh, "location", entry.location);
err = gn_sm_functions (GN_OP_WriteWAPSetting, data, state);
set_errori (err);
XS_RETURNi (err);
/* WriteWapSetting */
void
ActivateWapSetting (self, location)
HvObject *self;
int location;
PPCODE:
gn_error err;
gn_wap_setting entry;
clear_data ();
Zero (&entry, 1, entry);
entry.location = location;
data->wap_setting = &entry;
err = gn_sm_functions (GN_OP_ActivateWAPSetting, data, state);
set_errori (err);
XS_RETURNi (err);
/* ActivateWapSetting */
void
GetWapBookmark (self, location)
HvObject *self;
int location;
PPCODE:
gn_wap_bookmark entry;
if (opt_v) warn ("GetWapBookmark (%d)\n", location);
clear_data ();
Zero (&entry, 1, entry);
entry.location = location;
data->wap_bookmark = &entry;
if (gn_sm_func (self, GN_OP_GetWAPBookmark)) {
HV *wbm = newHV ();
XS_RETURNr (wbm);
}
XSRETURN_UNDEF;
/* GetWapBookmark */
void
WriteWapBookmark (self, wh)
HvObject *self;
HV *wh;
PPCODE:
gn_wap_bookmark entry;
clear_data ();
Zero (&entry, 1, entry);
hv_geti (wh, "location", entry.location);
hv_getsl (wh, "name", WAP_NAME_MAX_LENGTH, entry.name);
hv_getsl (wh, "url", WAP_URL_MAX_LENGTH, entry.URL);
data->wap_bookmark = &entry;
if (gn_sm_func (self, GN_OP_WriteWAPBookmark))
XS_RETURNi (entry.location);
XSRETURN_UNDEF;
/* WriteWapBookmark */
void
DeleteWapBookmark (self, location)
HvObject *self;
int location;
PPCODE:
gn_error err;
gn_wap_bookmark entry;
clear_data ();
Zero (&entry, 1, entry);
entry.location = location;
data->wap_bookmark = &entry;
err = gn_sm_functions (GN_OP_DeleteWAPBookmark, data, state);
set_errori (err);
XS_RETURNi (err);
( run in 0.877 second using v1.01-cache-2.11-cpan-5511b514fd6 )