gboolean libgnokii_signal_info_api(pegang *unit)
{
gn_data data;
gn_error error;
//prepare a place on memory
gn_data_clear(&data);
//sinyalling
//paramter requirement of GN_OP_GetRFLevel
printf("initiating get antena sinyal...\n");
gn_rf_unit rfunit = GN_RF_Percentage;
float rflevel;
data.rf_unit = &rfunit;
data.rf_level = &rflevel;
if((error = gn_sm_functions(GN_OP_GetRFLevel, &data, state)) == GN_ERR_NONE)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(unit->info_dialog_main->progressbar_sinyal),(float)rflevel/100);
printf("sinyal = %f\n",(float)rflevel/100);
return TRUE;
}
else
{
down(unit);
return FALSE;
}
}
gn_error enterchar(gn_data *data, struct gn_statemachine *state)
{
unsigned char ch;
gn_error error = GN_ERR_NONE;
gn_data_clear(data);
console_raw();
while ((error = GN_ERR_NONE) && (read(0, &ch, 1) > 0)) {
switch (ch) {
case '\r':
break;
case '\n':
data->key_code = GN_KEY_MENU;
presskey(data, state);
break;
#ifdef WIN32
case '\033':
#else
case '\e':
#endif
data->key_code = GN_KEY_NAMES;
presskey(data, state);
break;
default:
data->character = ch;
error = gn_sm_functions(GN_OP_EnterChar, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Error entering char: %s\n"), gn_error_print(error));
break;
}
}
return error;
}
// get number of entries in this phone memory type (internal/SIM-card)
static gn_error read_phone_memstat( gn_memory_type memtype, gn_memory_status *memstat )
{
gn_error error;
gn_data_clear(&data);
memset(memstat, 0, sizeof(*memstat));
memstat->memory_type = memtype;
data.memory_status = memstat;
error = gn_sm_functions(GN_OP_GetMemoryStatus, &data, &state);
GNOKII_CHECK_ERROR(error);
if (error != GN_ERR_NONE) {
switch (memtype) {
case GN_MT_SM:
// use at least 100 entries
memstat->used = 0;
memstat->free = 100;
break;
default:
case GN_MT_ME:
// Phone doesn't support ME (5110)
memstat->used = memstat->free = 0;
break;
}
}
GNOKII_DEBUG( QString("\n\nMobile phone memory status: Type: %1, used=%2, free=%3, total=%4\n\n")
.arg(memtype).arg(memstat->used).arg(memstat->free).arg(memstat->used+memstat->free) );
return error;
}
// refinement of this function needed..into the TODO list
static VALUE gn_lib_get_phone_information(void)
{
gn_data *data = &state->sm_data;
const char *unknown = _("Unknown");
gn_error error;
gn_data_clear(data);
data->model = state->config.m_model;
data->manufacturer = state->config.m_manufacturer;
data->revision = state->config.m_revision;
data->imei = state->config.m_imei;
error = gn_sm_functions(GN_OP_Identify, data, state);
if (!data->model[0])
snprintf(data->model, GN_MODEL_MAX_LENGTH, "%s", unknown);
if (!data->manufacturer[0])
snprintf(data->manufacturer, GN_MANUFACTURER_MAX_LENGTH, "%s", unknown);
if (!data->revision[0])
snprintf(data->revision, GN_REVISION_MAX_LENGTH, "%s", unknown);
if (!data->imei[0])
snprintf(data->imei, GN_IMEI_MAX_LENGTH, "%s", unknown);
printf("\n MODEL = %s \n IMEI = %s \n REVISION = %s\n MANUFACTURER =%s\n",data->model,data->imei,data->revision,data->manufacturer);
printf("%d", gn_sms_send(data,state));
return INT2NUM(error);
}
/* Writes profiles to phone */
gn_error setprofile(gn_data *data, struct gn_statemachine *state)
{
int n;
gn_profile p;
gn_error error = GN_ERR_NONE;
char line[256], ch;
gn_data_clear(data);
data->profile = &p;
while (fgets(line, sizeof(line), stdin)) {
n = strlen(line);
if (n > 0 && line[n-1] == '\n') {
line[--n] = 0;
}
n = sscanf(line, "%d;%39[^;];%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d%c",
&p.number, p.name, &p.default_name, &p.keypad_tone,
&p.lights, &p.call_alert, &p.ringtone, &p.volume,
&p.message_tone, &p.vibration, &p.warning_tone,
&p.caller_groups, &p.automatic_answer, &ch);
if (n != 13) {
fprintf(stderr, _("Input line format isn't valid\n"));
return GN_ERR_WRONGDATAFORMAT;
}
error = gn_sm_functions(GN_OP_SetProfile, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Cannot set profile: %s\n"), gn_error_print(error));
return error;
}
}
return error;
}
gn_error getlocksinfo(gn_data *data, struct gn_statemachine *state)
{
gn_locks_info locks_info[4];
gn_error error;
char *locks_names[] = {"MCC+MNC", "GID1", "GID2", "MSIN"};
int i;
gn_data_clear(data);
data->locks_info = locks_info;
if ((error = gn_sm_functions(GN_OP_GetLocksInfo, data, state)) != GN_ERR_NONE) {
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
for (i = 0; i < 4; i++) {
fprintf(stdout, _("%7s : %10s, %7s, %6s, counter %d\n"),
locks_names[i],
locks_info[i].data,
locks_info[i].userlock ? "user" : "factory",
locks_info[i].closed ? "CLOSED" : "open",
locks_info[i].counter);
}
return GN_ERR_NONE;
}
gn_error presskeysequence(gn_data *data, struct gn_statemachine *state)
{
gn_error error = GN_ERR_NONE;
unsigned char *syms = "0123456789#*PGR+-UDMN";
gn_key_code keys[] = {GN_KEY_0, GN_KEY_1, GN_KEY_2, GN_KEY_3,
GN_KEY_4, GN_KEY_5, GN_KEY_6, GN_KEY_7,
GN_KEY_8, GN_KEY_9, GN_KEY_HASH,
GN_KEY_ASTERISK, GN_KEY_POWER, GN_KEY_GREEN,
GN_KEY_RED, GN_KEY_INCREASEVOLUME,
GN_KEY_DECREASEVOLUME, GN_KEY_UP, GN_KEY_DOWN,
GN_KEY_MENU, GN_KEY_NAMES};
unsigned char ch, *pos;
gn_data_clear(data);
console_raw();
while (read(0, &ch, 1) > 0) {
if ((pos = strchr(syms, toupper(ch))) != NULL)
data->key_code = keys[pos - syms];
else
continue;
error = presskey(data, state);
}
return error;
}
gn_error deleteringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_error error;
int i, start, end;
memset(&ringtone, 0, sizeof(ringtone));
gn_data_clear(data);
data->ringtone = &ringtone;
start = gnokii_atoi(optarg);
if (errno || start < 0)
return deleteringtone_usage(stderr, -1);
end = parse_end_value_option(argc, argv, optind, start);
if (errno || end < 0)
return deleteringtone_usage(stderr, -1);
for (i = start; i <= end; i++) {
ringtone.location = i;
if ((error = gn_sm_functions(GN_OP_DeleteRingtone, data, state)) == GN_ERR_NONE)
fprintf(stderr, _("Ringtone %d deleted\n"), i);
else
fprintf(stderr, _("Failed to delete ringtone %d: %s\n"), i, gn_error_print(error));
}
return GN_ERR_NONE;
}
/* Deleting all ToDo notes */
gn_error deletealltodos(gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_data_clear(data);
error = gn_sm_functions(GN_OP_DeleteAllToDos, data, state);
if (error == GN_ERR_NONE)
fprintf(stderr, _("Successfully deleted all ToDo notes!\n"));
else
fprintf(stderr, _("Failed to delete ToDo note: %s\n"), gn_error_print(error));
return error;
}
/* Select the specified profile */
gn_error setactiveprofile(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_profile p;
gn_error error;
gn_data_clear(data);
data->profile = &p;
p.number = gnokii_atoi(optarg);
if (errno || p.number < 0)
return setactiveprofile_usage(stderr, -1);
error = gn_sm_functions(GN_OP_SetActiveProfile, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Cannot set active profile to %d: %s\n"), p.number, gn_error_print(error));
return error;
}
/* If initialised in debug mode, stdin/out is used instead
of ptys for interface. */
bool gn_atem_initialise(int read_fd, int write_fd, struct gn_statemachine *vmsm)
{
PtyRDFD = read_fd;
PtyWRFD = write_fd;
gn_data_clear(&data);
memset(&sms, 0, sizeof(sms));
memset(&callinfo, 0, sizeof(callinfo));
data.sms = &sms;
data.call_info = &callinfo;
data.manufacturer = manufacturer;
data.model = model;
data.revision = revision;
data.imei = imei;
sm = vmsm;
/* Initialise command buffer variables */
CurrentCmdBuffer = 0;
CurrentCmdBufferIndex = 0;
/* Initialise registers */
gn_atem_registers_init();
/* Initial parser is AT routine */
Parser = gn_atem_at_parse;
/* Setup defaults for AT*C interpreter. */
SMSNumber = 1;
SMSType = GN_MT_ME;
/* Default message format is PDU */
MessageFormat = PDU_MODE;
/* Set the call passup so that we get notified of incoming calls */
data.call_notification = gn_atem_call_passup;
gn_sm_functions(GN_OP_SetCallNotification, &data, sm);
/* query model, revision and imei */
if (gn_sm_functions(GN_OP_Identify, &data, sm) != GN_ERR_NONE)
return false;
/* We're ready to roll... */
gn_atem_initialised = true;
return (true);
}
gn_error changesecuritycode(char *type, gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_security_code security_code;
char newcode2[10];
memset(&security_code, 0, sizeof(security_code));
if (!strcmp(type, "PIN"))
security_code.type = GN_SCT_Pin;
else if (!strcmp(type, "PUK"))
security_code.type = GN_SCT_Puk;
else if (!strcmp(type, "PIN2"))
security_code.type = GN_SCT_Pin2;
else if (!strcmp(type, "PUK2"))
security_code.type = GN_SCT_Puk2;
/* FIXME: Entering of security_code does not work :-(
else if (!strcmp(type, "security_code"))
security_code.type = GN_SCT_security_code;
*/
else
return changesecuritycode_usage(stderr, -1);
get_password(_("Enter your code: "), security_code.code, sizeof(security_code.code));
get_password(_("Enter new code: "), security_code.new_code, sizeof(security_code.new_code));
get_password(_("Retype new code: "), newcode2, sizeof(newcode2));
if (strcmp(security_code.new_code, newcode2)) {
fprintf(stderr, _("Error: new code differs\n"));
return GN_ERR_FAILED;
}
gn_data_clear(data);
data->security_code = &security_code;
error = gn_sm_functions(GN_OP_ChangeSecurityCode, data, state);
switch (error) {
case GN_ERR_NONE:
fprintf(stderr, _("Code changed.\n"));
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
break;
}
return error;
}
int KMobileGnokii::numCalendarEntries()
{
gn_data_clear(&data);
gn_calnote entry;
memset(&entry, 0, sizeof(entry));
data.calnote = &entry;
entry.location = 1;
data.calnote_list = &calnote_list;
gn_error error = gn_sm_functions(GN_OP_GetCalendarNote, &data, &state);
switch (error) {
case GN_ERR_NONE:
case GN_ERR_INVALIDLOCATION:
case GN_ERR_EMPTYLOCATION:
return calnote_list.number;
default:
GNOKII_CHECK_ERROR(error);
return 0;
}
}
gn_error getsecuritycodestatus(gn_data *data, struct gn_statemachine *state)
{
gn_security_code security_code;
gn_error err;
gn_data_clear(data);
data->security_code = &security_code;
err = gn_sm_functions(GN_OP_GetSecurityCodeStatus, data, state);
if (err == GN_ERR_NONE) {
fprintf(stdout, _("Security code status: "));
switch(security_code.type) {
case GN_SCT_SecurityCode:
fprintf(stdout, _("waiting for Security Code.\n"));
break;
case GN_SCT_Pin:
fprintf(stdout, _("waiting for PIN.\n"));
break;
case GN_SCT_Pin2:
fprintf(stdout, _("waiting for PIN2.\n"));
break;
case GN_SCT_Puk:
fprintf(stdout, _("waiting for PUK.\n"));
break;
case GN_SCT_Puk2:
fprintf(stdout, _("waiting for PUK2.\n"));
break;
case GN_SCT_None:
fprintf(stdout, _("nothing to enter.\n"));
break;
default:
fprintf(stdout, _("unknown\n"));
break;
}
} else
fprintf(stderr, _("Error: %s\n"), gn_error_print(err));
return err;
}
/* Queries the active profile */
gn_error getactiveprofile(gn_data *data, struct gn_statemachine *state)
{
gn_profile p;
gn_error error;
gn_data_clear(data);
data->profile = &p;
error = gn_sm_functions(GN_OP_GetActiveProfile, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Cannot get active profile: %s\n"), gn_error_print(error));
return error;
}
error = gn_sm_functions(GN_OP_GetProfile, data, state);
if (error != GN_ERR_NONE)
fprintf(stderr, _("Cannot get profile %d\n"), p.number);
else
fprintf(stdout, _("Active profile: %d (%s)\n"), p.number, p.name);
return error;
}
gn_error getnetworkinfo(gn_data *data, struct gn_statemachine *state)
{
gn_network_info networkinfo;
gn_error error;
int lac, cid;
char country[4] = {0, 0, 0, 0};
gn_data_clear(data);
memset(&networkinfo, 0, sizeof(networkinfo));
data->network_info = &networkinfo;
state->callbacks.reg_notification = NULL;
data->callback_data = NULL;
if ((error = gn_sm_functions(GN_OP_GetNetworkInfo, data, state)) != GN_ERR_NONE) {
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
/* Ugly, ugly, ... */
if (networkinfo.cell_id[2] == 0 && networkinfo.cell_id[3] == 0)
cid = (networkinfo.cell_id[0] << 8) + networkinfo.cell_id[1];
else
cid = (networkinfo.cell_id[0] << 24) + (networkinfo.cell_id[1] << 16) + (networkinfo.cell_id[2] << 8) + networkinfo.cell_id[3];
lac = (networkinfo.LAC[0] << 8) + networkinfo.LAC[1];
memcpy(country, networkinfo.network_code, 3);
fprintf(stdout, _("Network : %s (%s)\n"),
gn_network_name_get((char *)networkinfo.network_code),
gn_country_name_get((char *)country));
fprintf(stdout, _("Network code : %s\n"), (*networkinfo.network_code ? networkinfo.network_code : _("undefined")));
fprintf(stdout, _("LAC : %04x (%d)\n"), lac, lac);
fprintf(stdout, _("Cell id : %08x (%d)\n"), cid, cid);
return GN_ERR_NONE;
}
/* In this mode we get the code from the keyboard and send it to the mobile
phone. */
gn_error entersecuritycode(char *type, gn_data *data, struct gn_statemachine *state)
{
gn_error error;
gn_security_code security_code;
if (!strcmp(type, "PIN"))
security_code.type = GN_SCT_Pin;
else if (!strcmp(type, "PUK"))
security_code.type = GN_SCT_Puk;
else if (!strcmp(type, "PIN2"))
security_code.type = GN_SCT_Pin2;
else if (!strcmp(type, "PUK2"))
security_code.type = GN_SCT_Puk2;
else if (!strcmp(type, "SEC"))
security_code.type = GN_SCT_SecurityCode;
else
return entersecuritycode_usage(stderr, -1);
memset(&security_code.code, 0, sizeof(security_code.code));
get_password(_("Enter your code: "), security_code.code, sizeof(security_code.code));
gn_data_clear(data);
data->security_code = &security_code;
error = gn_sm_functions(GN_OP_EnterSecurityCode, data, state);
switch (error) {
case GN_ERR_NONE:
fprintf(stderr, _("Code ok.\n"));
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
break;
}
return error;
}
int KMobileGnokii::storeCalendarEntry( int index, const KCal::Event &event )
{
if (index < 0 || index >= GN_CALNOTE_MAX_NUMBER)
return KIO::ERR_DOES_NOT_EXIST;
gn_error error;
gn_calnote entry;
gn_data_clear(&data);
memset(&entry, 0, sizeof(entry));
entry.location = index+1;
data.calnote = &entry;
data.calnote_list = &calnote_list;
// read first
error = gn_sm_functions(GN_OP_GetCalendarNote, &data, &state);
// GNOKII_CHECK_ERROR(error);
QDateTime_2_timestamp( event.dtStart(), entry.time );
strncpy(entry.text, event.summary().utf8(), sizeof(entry.text)-1);
// type:
entry.type = GN_CALNOTE_MEETING;
if (event.categories().findIndex(i18n("MEETING")) != -1) {
entry.type = GN_CALNOTE_MEETING;
} else if (event.categories().findIndex(i18n("PHONE CALL")) != -1) {
entry.type = GN_CALNOTE_CALL;
strncpy(entry.phone_number, event.description().utf8(), sizeof(entry.phone_number)-1);
} else if (event.categories().findIndex(i18n("BIRTHDAY")) != -1) {
entry.type = GN_CALNOTE_BIRTHDAY;
} else { // assume i18n("REMINDER")
entry.type = GN_CALNOTE_REMINDER;
}
// alarm:
entry.alarm.enabled = 0;
if (event.isAlarmEnabled()) {
const KCal::Alarm *eventalarm = *event.alarms().at(0);
if (eventalarm) {
if (eventalarm->hasTime()) {
QDateTime_2_timestamp( eventalarm->time(), entry.alarm.timestamp );
} else
if (eventalarm->hasStartOffset()) {
QDateTime dt = event.dtStart();
dt = dt.addSecs(-eventalarm->startOffset().asSeconds());
QDateTime_2_timestamp( dt, entry.alarm.timestamp );
}
}
}
// recurrence:
switch (event.recurrence()->recurrenceType()) {
case KCal::Recurrence::rNone:
default:
entry.recurrence = GN_CALNOTE_NEVER;
break;
case KCal::Recurrence::rHourly:
entry.recurrence = (gn_calnote_recurrence) (event.recurrence()->frequency());
break;
case KCal::Recurrence::rDaily:
entry.recurrence = GN_CALNOTE_DAILY;
break;
case KCal::Recurrence::rWeekly:
entry.recurrence = (gn_calnote_recurrence) (GN_CALNOTE_WEEKLY * event.recurrence()->frequency());
break;
case KCal::Recurrence::rMonthlyPos:
case KCal::Recurrence::rMonthlyDay:
entry.recurrence = GN_CALNOTE_MONTHLY;
break;
case KCal::Recurrence::rYearlyMonth:
case KCal::Recurrence::rYearlyDay:
case KCal::Recurrence::rYearlyPos:
entry.recurrence = GN_CALNOTE_YEARLY;
break;
}
print_calnote( entry );
return 0; // XXX
error = gn_sm_functions(GN_OP_WriteCalendarNote, &data, &state);
GNOKII_CHECK_ERROR(error);
return 0;
}
gn_error setringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_raw_data rawdata;
gn_error error;
unsigned char buff[512];
char *filename = optarg;
int i, location;
bool raw = false;
char name[16] = "";
struct option options[] = {
{ "raw", no_argument, NULL, 'r'},
{ "name", required_argument, NULL, 'n'},
{ NULL, 0, NULL, 0}
};
while ((i = getopt_long(argc, argv, "rn:", options, NULL)) != -1) {
switch (i) {
case 'r':
raw = true;
break;
case 'n':
snprintf(name, sizeof(name), "%s", optarg);
break;
default:
return setringtone_usage(stderr, -1);
}
}
if (argc - optind > 2) {
/* There are too many arguments that don't start with '-' */
return setringtone_usage(stderr, -1);
}
memset(&ringtone, 0, sizeof(ringtone));
rawdata.data = buff;
rawdata.length = sizeof(buff);
gn_data_clear(data);
data->ringtone = &ringtone;
data->raw_data = &rawdata;
errno = 0;
location = (argc > optind + 1) ? gnokii_atoi(argv[optind + 1]) : -1;
if (errno)
return setringtone_usage(stderr, -1);
if (!filename) {
fprintf(stderr, _("Internal gnokii error: null filename\n"));
return GN_ERR_FAILED;
}
if (raw) {
FILE *f;
if ((f = fopen(filename, "rb")) == NULL) {
fprintf(stderr, _("Failed to load ringtone.\n"));
return GN_ERR_FAILED;
}
rawdata.length = fread(rawdata.data, 1, rawdata.length, f);
fclose(f);
ringtone.location = location;
if (*name)
snprintf(ringtone.name, sizeof(ringtone.name), "%s", name);
else
snprintf(ringtone.name, sizeof(ringtone.name), "GNOKII");
error = gn_sm_functions(GN_OP_SetRawRingtone, data, state);
} else {
if ((error = gn_file_ringtone_read(filename, &ringtone))) {
fprintf(stderr, _("Failed to load ringtone.\n"));
return error;
}
ringtone.location = location;
if (*name) snprintf(ringtone.name, sizeof(ringtone.name), "%s", name);
error = gn_sm_functions(GN_OP_SetRingtone, data, state);
}
if (error == GN_ERR_NONE)
fprintf(stderr, _("Send succeeded!\n"));
else
fprintf(stderr, _("Send failed: %s\n"), gn_error_print(error));
return error;
}
gn_error playringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_tone tone;
gn_error error;
char *filename = optarg;
int i, ulen;
struct timeval dt;
#if (defined HAVE_TIMEOPS) && (defined HAVE_GETTIMEOFDAY)
struct timeval t1, t2;
#endif
int volume = 5;
struct option options[] = {
{ "volume", required_argument, NULL, 'v'},
{ NULL, 0, NULL, 0}
};
while ((i = getopt_long(argc, argv, "v:", options, NULL)) != -1) {
switch (i) {
case 'v':
volume = gnokii_atoi(optarg);
if (errno || volume < 0)
return playringtone_usage(stderr, -1);
break;
default:
return playringtone_usage(stderr, -1);
}
}
if (argc > optind) {
/* There are too many arguments that don't start with '-' */
return playringtone_usage(stderr, -1);
}
memset(&ringtone, 0, sizeof(ringtone));
memset(&tone, 0, sizeof(tone));
gn_data_clear(data);
data->ringtone = &ringtone;
data->tone = &tone;
if (!filename) {
fprintf(stderr, _("Internal gnokii error: null filename\n"));
return GN_ERR_FAILED;
}
if ((error = gn_file_ringtone_read(filename, &ringtone))) {
fprintf(stderr, _("Failed to load ringtone: %s\n"), gn_error_print(error));
return error;
}
#if (defined HAVE_TIMEOPS) && (defined HAVE_GETTIMEOFDAY)
gettimeofday(&t1, NULL);
tone.frequency = 0;
tone.volume = 0;
gn_sm_functions(GN_OP_PlayTone, data, state);
gettimeofday(&t2, NULL);
timersub(&t2, &t1, &dt);
#else
dt.tv_sec = 0;
dt.tv_usec = 20000;
#endif
signal(SIGINT, interrupted);
for (i = 0; !bshutdown && i < ringtone.notes_count; i++) {
tone.volume = volume;
gn_ringtone_get_tone(&ringtone, i, &tone.frequency, &ulen);
if ((error = gn_sm_functions(GN_OP_PlayTone, data, state)) != GN_ERR_NONE) break;
if (ulen > 2 * dt.tv_usec + 20000)
usleep(ulen - 2 * dt.tv_usec - 20000);
tone.volume = 0;
if ((error = gn_sm_functions(GN_OP_PlayTone, data, state)) != GN_ERR_NONE) break;
usleep(20000);
}
tone.frequency = 0;
tone.volume = 0;
gn_sm_functions(GN_OP_PlayTone, data, state);
if (error == GN_ERR_NONE)
fprintf(stderr, _("Play succeeded!\n"));
else
fprintf(stderr, _("Play failed: %s\n"), gn_error_print(error));
return error;
}
gboolean libgnokii_sms_send_api(pegang *unit)
{
if(!holdgnokii_init)
{
printf("hold_gnokii_init aint initialized\n");
return FALSE;
}
//avoiding
if(unit->sms_send_encapsulation->no_dest == NULL || strlen(unit->sms_send_encapsulation->no_dest) < 2 || unit->sms_send_encapsulation->msg == NULL || strlen(unit->sms_send_encapsulation->msg) < 2)
{
return FALSE;
}
gn_sms sms;
gn_error error;
gn_data data;
int pos = 0;
//memset to zero
gn_sms_default_submit(&sms);
gn_data_clear(&data);
//set the dest number
snprintf(sms.remote.number,sizeof(sms.remote.number),"%s",unit->sms_send_encapsulation->no_dest);
sms.remote.type = libgnokii_nomorhp_tipe_api(unit->sms_send_encapsulation->no_dest);
if(sms.remote.type == GN_GSM_NUMBER_Alphanumeric)
{
printf("Invalid Phone Number\n");
return FALSE;
}
//set txt to be sent and length of it
error = libgnokii_bacatext_api(&sms.user_data[pos],unit);
sms.user_data[pos].type = GN_SMS_DATA_Text;
/*
if ((sms.dcs.u.general.alphabet != GN_SMS_DCS_8bit) && !gn_char_def_alphabet(sms.user_data[pos].u.text))
sms.dcs.u.general.alphabet = GN_SMS_DCS_UCS2;
sms.user_data[++pos].type = GN_SMS_DATA_None;
*/
//report the delivery
sms.delivery_report = 1;
//auto get sms center
data.message_center = calloc(1, sizeof(gn_sms_message_center)); //allocate only for one element of data->message_center and size of its element is sizeof(gn_sms_message_center)
data.message_center->id = 1;
error = gn_sm_functions(GN_OP_GetSMSCenter, &data, state);
if(error == GN_ERR_NONE)
{
snprintf(sms.smsc.number,sizeof(sms.smsc.number),"%s",data.message_center->smsc.number); // set to sms.smsc.number from data.sms.smsc.number
sms.smsc.type = data.message_center->smsc.type;
//g_slice_free(gn_sms_message_center,data->message_center); // free the ram
free(data.message_center);
}
if(!sms.smsc.number[0])
{
printf("failed once getting sms center number\n");
return FALSE;
}
if(!sms.smsc.type)
{
sms.smsc.type = GN_GSM_NUMBER_Unknown;
}
//now give the data.sms from what all we have in sms, and make sure before these data.sms has been freed...
data.sms = &sms;
//send the message
error = gn_sms_send(&data,state);
if(error == GN_ERR_NONE)
{
if(sms.parts > 1)
{
int j;
printf("sms sent with : %d parts, and reference number is : ", sms.parts);
for(j=0; j < sms.parts; j++)
{
printf("%d\n",sms.reference[j]);
}
}
else
{
printf("one sms sent with reference number : %d\n",sms.reference[0]);
}
}
else
{
printf("libgnokii error : %s\n",gn_error_print(error));
return FALSE;
}
free(sms.reference);
return TRUE;
}
gn_error getringtone(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_ringtone ringtone;
gn_raw_data rawdata;
gn_error error;
unsigned char buff[512];
char *filename = optarg;
int i;
bool raw = false;
struct option options[] = {
{ "raw", no_argument, NULL, 'r'},
{ NULL, 0, NULL, 0}
};
memset(&ringtone, 0, sizeof(ringtone));
rawdata.data = buff;
rawdata.length = sizeof(buff);
gn_data_clear(data);
data->ringtone = &ringtone;
data->raw_data = &rawdata;
while ((i = getopt_long(argc, argv, "r", options, NULL)) != -1) {
switch (i) {
case 'r':
raw = true;
break;
default:
return getringtone_usage(stderr, -1);
}
}
if (argc == optind) {
/* There are 0 arguments that don't start with '-' */
init_ringtone_list(data, state);
ringtone.location = ringtone_list.userdef_location;
} else if (argc - optind == 1) {
/* There is 1 argument that doesn't start with '-' */
ringtone.location = gnokii_atoi(argv[optind]);
if (errno || ringtone.location < 0)
return getringtone_usage(stderr, -1);
} else {
/* There are too many arguments that don't start with '-' */
return getringtone_usage(stderr, -1);
}
if (raw)
error = gn_sm_functions(GN_OP_GetRawRingtone, data, state);
else
error = gn_sm_functions(GN_OP_GetRingtone, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Getting ringtone %d failed: %s\n"), ringtone.location, gn_error_print(error));
goto out;
}
fprintf(stderr, _("Getting ringtone %d (\"%s\") succeeded!\n"), ringtone.location, ringtone.name);
if (!filename) {
fprintf(stderr, _("Internal gnokii error: null filename\n"));
error = GN_ERR_FAILED;
goto out;
}
if (raw) {
FILE *f;
if ((f = fopen(filename, "wb")) == NULL) {
fprintf(stderr, _("Failed to save ringtone.\n"));
error = -1;
goto out;
}
if (fwrite(rawdata.data, rawdata.length, 1, f) < 1) {
fprintf(stderr, _("Failed to write ringtone.\n"));
error = -1;
}
fclose(f);
} else {
if ((error = gn_file_ringtone_save(filename, &ringtone)) != GN_ERR_NONE) {
fprintf(stderr, _("Failed to save ringtone: %s\n"), gn_error_print(error));
/* return */
}
}
out:
return error;
}
/* Reads profile from phone and displays its' settings */
gn_error getprofile(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
int max_profiles;
int start, stop, i;
gn_profile p;
gn_ringtone_list rl;
gn_error error = GN_ERR_NOTSUPPORTED;
/* Hopefully is 64 larger as FB38_MAX* / FB61_MAX* */
char model[64] = "";
bool raw = false;
struct option options[] = {
{ "raw", no_argument, NULL, 'r'},
{ NULL, 0, NULL, 0}
};
while ((i = getopt_long(argc, argv, "r", options, NULL)) != -1) {
switch (i) {
case 'r':
raw = true;
break;
default:
return getprofile_usage(stderr, -1); /* FIXME */
}
}
gn_data_clear(data);
data->model = model;
while (gn_sm_functions(GN_OP_GetModel, data, state) != GN_ERR_NONE)
sleep(1);
p.number = 0;
memset(&rl, 0, sizeof(gn_ringtone_list));
gn_data_clear(data);
data->profile = &p;
data->ringtone_list = &rl;
error = gn_sm_functions(GN_OP_GetProfile, data, state);
switch (error) {
case GN_ERR_NONE:
break;
default:
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
max_profiles = 7; /* This is correct for 6110 (at least my). How do we get
the number of profiles? */
/* For N5110 */
/* FIXME: It should be set to 3 for N5130 and 3210 too */
if (!strcmp(model, "NSE-1"))
max_profiles = 3;
if (argc > optind) {
start = gnokii_atoi(argv[optind]);
if (errno || start < 0)
return getprofile_usage(stderr, -1);
stop = (argc > optind + 1) ? gnokii_atoi(argv[optind + 1]) : start;
if (errno || stop < 0)
return getprofile_usage(stderr, -1);
if (start > stop) {
fprintf(stderr, _("Starting profile number is greater than stop\n"));
return GN_ERR_FAILED;
}
if (start < 0) {
fprintf(stderr, _("Profile number must be value from 0 to %d!\n"), max_profiles - 1);
return GN_ERR_FAILED;
}
if (stop >= max_profiles) {
fprintf(stderr, _("This phone supports only %d profiles!\n"), max_profiles);
return GN_ERR_FAILED;
}
} else {
start = 0;
stop = max_profiles - 1;
}
gn_data_clear(data);
data->profile = &p;
data->ringtone_list = &rl;
for (i = start; i <= stop; i++) {
p.number = i;
if (p.number != 0) {
error = gn_sm_functions(GN_OP_GetProfile, data, state);
if (error != GN_ERR_NONE) {
fprintf(stderr, _("Cannot get profile %d\n"), i);
fprintf(stderr, _("Error: %s\n"), gn_error_print(error));
return error;
}
}
if (raw) {
fprintf(stdout, "%d;%s;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d\n",
p.number, p.name, p.default_name, p.keypad_tone,
p.lights, p.call_alert, p.ringtone, p.volume,
p.message_tone, p.vibration, p.warning_tone,
p.caller_groups, p.automatic_answer);
} else {
/* Translators: %d is the profile number, %s is the profile name. Example: 1. "Outdoors" */
fprintf(stdout, _("%d. \"%s\"\n"), p.number, p.name);
if (p.default_name == -1) fprintf(stdout, _(" (name defined)\n"));
fprintf(stdout, _("Incoming call alert: %s\n"), gn_profile_callalert_type2str(p.call_alert));
fprintf(stdout, _("Ringing tone: %s (%d)\n"), get_ringtone_name(p.ringtone, data, state), p.ringtone);
fprintf(stdout, _("Ringing volume: %s\n"), gn_profile_volume_type2str(p.volume));
fprintf(stdout, _("Message alert tone: %s\n"), gn_profile_message_type2str(p.message_tone));
fprintf(stdout, _("Keypad tones: %s\n"), gn_profile_keyvol_type2str(p.keypad_tone));
fprintf(stdout, _("Warning and game tones: %s\n"), gn_profile_warning_type2str(p.warning_tone));
/* FIXME: Light settings is only used for Car */
if (p.number == (max_profiles - 2)) fprintf(stdout, _("Lights: %s\n"), p.lights ? _("On") : _("Automatic"));
fprintf(stdout, _("Vibration: %s\n"), gn_profile_vibration_type2str(p.vibration));
/* FIXME: it will be nice to add here reading caller group name. */
if (max_profiles != 3) fprintf(stdout, _("Caller groups: 0x%02x\n"), p.caller_groups);
/* FIXME: Automatic answer is only used for Car and Headset. */
if (p.number >= (max_profiles - 2)) fprintf(stdout, _("Automatic answer: %s\n"), p.automatic_answer ? _("On") : _("Off"));
fprintf(stdout, "\n");
}
}
return error;
}
/* ToDo notes receiving. */
gn_error gettodo(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_todo_list todolist;
gn_todo todo;
gn_error error = GN_ERR_NONE;
bool vcal = false;
int i, first_location, last_location;
struct option options[] = {
{ "vCal", optional_argument, NULL, 'v'},
{ NULL, 0, NULL, 0}
};
first_location = gnokii_atoi(optarg);
if (errno || first_location < 0)
return gettodo_usage(stderr, -1);
last_location = parse_end_value_option(argc, argv, optind, first_location);
if (errno || last_location < 0)
return gettodo_usage(stderr, -1);
while ((i = getopt_long(argc, argv, "v", options, NULL)) != -1) {
switch (i) {
case 'v':
vcal = true;
break;
default:
return gettodo_usage(stderr, -1);
}
}
for (i = first_location; i <= last_location; i++) {
todo.location = i;
gn_data_clear(data);
data->todo = &todo;
data->todo_list = &todolist;
error = gn_sm_functions(GN_OP_GetToDo, data, state);
switch (error) {
case GN_ERR_NONE:
if (vcal) {
gn_todo2ical(stdout, &todo);
} else {
fprintf(stdout, _("%s: %s\n"), _("Todo"), todo.text);
fprintf(stdout, _("%s: %s\n"), _("Priority"), gn_todo_priority2str(todo.priority));
}
break;
default:
/* stop processing if the last note was specified as "end" */
if (last_location == INT_MAX) {
/* it's not an error if we read at least a note and the rest is empty */
if ((i > first_location) && ((error == GN_ERR_EMPTYLOCATION) || (error == GN_ERR_INVALIDLOCATION))) {
error = GN_ERR_NONE;
}
last_location = 0;
}
if (error != GN_ERR_NONE) {
fprintf(stderr, _("The ToDo note could not be read: %s\n"), gn_error_print(error));
}
}
}
return error;
}
static QString businit(void)
{
gn_error error;
char *aux;
if (gn_cfg_read(&BinDir)<0 || !gn_cfg_phone_load("", &state))
return i18n("GNOKII isn't yet configured.");
gn_data_clear(&data);
aux = gn_cfg_get(gn_cfg_info, "global", "use_locking");
// Defaults to 'no'
if (aux && !strcmp(aux, "yes")) {
lockfile = gn_device_lock(state.config.port_device);
if (lockfile == NULL) {
return i18n("Lock file error.\n "
"Please exit all other running instances of gnokii and try again.");
}
}
// Initialise the code for the GSM interface.
int old_dcd = state.config.require_dcd; // work-around for older gnokii versions
state.config.require_dcd = false;
error = gn_gsm_initialise(&state);
GNOKII_CHECK_ERROR(error);
state.config.require_dcd = old_dcd;
if (error != GN_ERR_NONE) {
busterminate();
return i18n("Mobile phone interface initialization failed:\n%1").arg(gn_error_print(error));
}
// model
gn_data_clear(&data);
data.model = model;
model[0] = 0;
error = gn_sm_functions(GN_OP_GetModel, &data, &state);
GNOKII_CHECK_ERROR(error);
if (model[0] == 0)
strcpy(model, i18n("unknown").utf8());
data.model = NULL;
// revision
data.revision = revision;
revision[0] = 0;
error = gn_sm_functions(GN_OP_GetRevision, &data, &state);
GNOKII_CHECK_ERROR(error);
data.revision = NULL;
// imei
data.imei = imei;
imei[0] = 0;
error = gn_sm_functions(GN_OP_GetImei, &data, &state);
GNOKII_CHECK_ERROR(error);
data.imei = NULL;
GNOKII_DEBUG( QString("Found mobile phone: Model: %1, Revision: %2, IMEI: %3\n")
.arg(model).arg(revision).arg(imei) );
PhoneProductId = QString("%1-%2-%3-%4").arg(APP).arg(model).arg(revision).arg(imei);
return QString::null;
}
/* ToDo notes writing */
gn_error writetodo(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
gn_todo todo;
gn_error error = GN_ERR_NONE;
int first_location, last_location, i;
FILE *f;
f = fopen(optarg, "r");
if (f == NULL) {
fprintf(stderr, _("Can't open file %s for reading!\n"), optarg);
return GN_ERR_FAILED;
}
first_location = gnokii_atoi(argv[optind]);
if (errno || first_location < 0) {
fclose(f);
return writetodo_usage(stderr, -1);
}
last_location = parse_end_value_option(argc, argv, optind + 1, first_location);
if (errno || last_location < 0) {
fclose(f);
return writetodo_usage(stderr, -1);
}
for (i = first_location; i <= last_location; i++) {
memset(&todo, 0, sizeof(todo));
gn_data_clear(data);
data->todo = &todo;
/* TODO: gn_ical2todo expects the pointer to begin file to
* iterate. Fix it to not rewind the file each time
*/
rewind(f);
error = gn_ical2todo(f, &todo, i);
#ifndef WIN32
if (error == GN_ERR_NOTIMPLEMENTED) {
switch (gn_vcal_file_todo_read(optarg, &todo, i)) {
case 0:
error = GN_ERR_NONE;
break;
default:
error = GN_ERR_FAILED;
break;
}
}
#endif
if (error != GN_ERR_NONE) {
/* when reading until 'end' it's not an error if it tried to read a non existant note */
if ((last_location == INT_MAX) && (error == GN_ERR_EMPTYLOCATION)) {
error = GN_ERR_NONE;
} else {
fprintf(stderr, _("Failed to load vCalendar file: %s\n"), gn_error_print(error));
}
fclose(f);
return error;
}
error = gn_sm_functions(GN_OP_WriteToDo, data, state);
if (error == GN_ERR_NONE) {
fprintf(stderr, _("Successfully written!\n"));
fprintf(stderr, _("Priority %d. %s\n"), data->todo->priority, data->todo->text);
} else
fprintf(stderr, _("Failed to write ToDo note: %s\n"), gn_error_print(error));
}
fclose(f);
return error;
}
int KMobileGnokii::readCalendarEntry( int index, KCal::Event &event )
{
if (index < 0 || index >= GN_CALNOTE_MAX_NUMBER)
return KIO::ERR_DOES_NOT_EXIST;
gn_data_clear(&data);
gn_calnote entry;
memset(&entry, 0, sizeof(entry));
entry.location = index+1;
data.calnote = &entry;
data.calnote_list = &calnote_list;
gn_error error = gn_sm_functions(GN_OP_GetCalendarNote, &data, &state);
GNOKII_CHECK_ERROR(error);
if (error != GN_ERR_NONE)
return gn_error2kio_error(error);
print_calnote( entry );
QDateTime dt_start = timestamp_2_QDateTime(entry.time);
QDateTime dt_end = dt_start.addSecs( 60*60 ); // XXX: assume one hour
event.setDtStart( dt_start );
event.setDtEnd( dt_end );
event.setSummary( QString::fromUtf8(entry.text) );
// type:
switch (entry.type) {
case GN_CALNOTE_MEETING:
event.setCategories(i18n("MEETING"));
break;
case GN_CALNOTE_CALL:
event.setCategories(i18n("PHONE CALL"));
event.setDescription(QString::fromUtf8(entry.phone_number));
break;
case GN_CALNOTE_BIRTHDAY:
event.setCategories(i18n("BIRTHDAY"));
break;
case GN_CALNOTE_REMINDER:
event.setCategories(i18n("REMINDER"));
break;
default:
kdWarning() << "unknown calendar GN_CALNOTE_XXXX type #" << entry.type << endl;
}
// alarm:
if (entry.alarm.enabled) {
QDateTime at = timestamp_2_QDateTime(entry.alarm.timestamp);
if (at.isValid() && dt_start.isValid()) {
int seconds = abs(at.secsTo(dt_start));
seconds %= 60*60*24; /* max. 1 day in advance... */
KCal::Alarm *eventalarm = event.newAlarm();
eventalarm->setStartOffset(KCal::Duration(seconds));
}
}
// recurrence:
switch (entry.recurrence) {
case GN_CALNOTE_NEVER:
break;
case GN_CALNOTE_DAILY:
event.recurrence()->setDaily(1,-1);
break;
case GN_CALNOTE_WEEKLY:
case GN_CALNOTE_2WEEKLY:
event.recurrence()->setDaily( 7 + (entry.recurrence==GN_CALNOTE_2WEEKLY ? 7:0) , -1);
break;
case GN_CALNOTE_MONTHLY:
event.recurrence()->setMonthly(KCal::Recurrence::rMonthlyPos, 1, -1);
break;
case GN_CALNOTE_YEARLY:
event.recurrence()->setYearly(KCal::Recurrence::rYearlyPos, 1, -1);
break;
default: // hourly
event.recurrence()->setHourly(entry.recurrence, -1);
break;
}
return 0;
}
