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; }