~ubuntu-branches/ubuntu/trusty/modem-manager-gui/trusty-backports : revision 1

1

/*

2

* mm07.c

3

*

4

5

*

6

* This program is free software: you can redistribute it and/or modify

7

* it under the terms of the GNU General Public License as published by

8

* the Free Software Foundation; either version 3 of the License, or

9

* (at your option) any later version.

10

*

11

* This program is distributed in the hope that it will be useful,

12

* but WITHOUT ANY WARRANTY; without even the implied warranty of

13

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14

* GNU General Public License for more details.

15

*

16

* You should have received a copy of the GNU General Public License

17

* along with this program. If not, see <http://www.gnu.org/licenses/>.

18

*/

19

20

21

#include <glib.h>

22

#include <glib/gi18n.h>

23

#include <gio/gio.h>

24

#include <gmodule.h>

25

#include <string.h>

26

#include <net/if.h>

27

#include <stdlib.h>

28

29

#include "../mmguicore.h"

30

#include "../smsdb.h"

31

32

#define MMGUI_MODULE_SERVICE_NAME "org.freedesktop.ModemManager1"

33

#define MMGUI_MODULE_IDENTIFIER 70

34

#define MMGUI_MODULE_DESCRIPTION "Modem Manager >= 0.7.0"

35

36

#define MMGUI_MODULE_ENABLE_OPERATION_TIMEOUT 20000

37

#define MMGUI_MODULE_SEND_SMS_OPERATION_TIMEOUT 35000

38

#define MMGUI_MODULE_SEND_USSD_OPERATION_TIMEOUT 25000

39

#define MMGUI_MODULE_NETWORKS_SCAN_OPERATION_TIMEOUT 60000

40

41

//Internal enumerations

42

//Modem state internal flags

43

typedef enum {

44

MODULE_INT_MODEM_STATE_FAILED = -1,

45

MODULE_INT_MODEM_STATE_UNKNOWN = 0,

46

MODULE_INT_MODEM_STATE_INITIALIZING = 1,

47

MODULE_INT_MODEM_STATE_LOCKED = 2,

48

MODULE_INT_MODEM_STATE_DISABLED = 3,

49

MODULE_INT_MODEM_STATE_DISABLING = 4,

50

MODULE_INT_MODEM_STATE_ENABLING = 5,

51

MODULE_INT_MODEM_STATE_ENABLED = 6,

52

MODULE_INT_MODEM_STATE_SEARCHING = 7,

53

MODULE_INT_MODEM_STATE_REGISTERED = 8,

54

MODULE_INT_MODEM_STATE_DISCONNECTING = 9,

55

MODULE_INT_MODEM_STATE_CONNECTING = 10,

56

MODULE_INT_MODEM_STATE_CONNECTED = 11

57

} ModuleIntModemState;

58

59

//Modem capability internal flags

60

typedef enum {

61

MODULE_INT_MODEM_CAPABILITY_NONE = 0,

62

MODULE_INT_MODEM_CAPABILITY_POTS = 1 << 0,

63

MODULE_INT_MODEM_CAPABILITY_CDMA_EVDO = 1 << 1,

64

MODULE_INT_MODEM_CAPABILITY_GSM_UMTS = 1 << 2,

65

MODULE_INT_MODEM_CAPABILITY_LTE = 1 << 3,

66

MODULE_INT_MODEM_CAPABILITY_LTE_ADVANCED = 1 << 4,

67

MODULE_INT_MODEM_CAPABILITY_IRIDIUM = 1 << 5,

68

} ModuleIntModemCapability;

69

70

//Modem registration internal flags

71

typedef enum {

72

MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_IDLE = 0,

73

MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_HOME = 1,

74

MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_SEARCHING = 2,

75

MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_DENIED = 3,

76

MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN = 4,

77

MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_ROAMING = 5,

78

} ModuleIntModem3gppRegistrationState;

79

80

//Modem USSD state internal flags

81

typedef enum {

82

MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_UNKNOWN = 0,

83

MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_IDLE = 1,

84

MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_ACTIVE = 2,

85

MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_USER_RESPONSE = 3,

86

} ModuleIntModem3gppUssdSessionState;

87

88

//Modem network availability internal flags

89

typedef enum {

90

MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_UNKNOWN = 0,

91

MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_AVAILABLE = 1,

92

MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_CURRENT = 2,

93

MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_FORBIDDEN = 3,

94

} ModuleIntModem3gppNetworkAvailability;

95

96

//Modem acess technology internal flags

97

typedef enum {

98

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_UNKNOWN = 0,

99

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_POTS = 1 << 0,

100

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GSM = 1 << 1,

101

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT = 1 << 2,

102

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GPRS = 1 << 3,

103

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EDGE = 1 << 4,

104

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_UMTS = 1 << 5,

105

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSDPA = 1 << 6,

106

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSUPA = 1 << 7,

107

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSPA = 1 << 8,

108

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS = 1 << 9,

109

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_1XRTT = 1 << 10,

110

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDO0 = 1 << 11,

111

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDOA = 1 << 12,

112

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDOB = 1 << 13,

113

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_LTE = 1 << 14,

114

MODULE_INT_MODEM_ACCESS_TECHNOLOGY_ANY = 0xFFFFFFFF,

115

} ModuleIntModemAccessTechnology;

116

117

//Location types internal flags

118

typedef enum {

119

MODULE_INT_MODEM_LOCATION_SOURCE_NONE = 0,

120

MODULE_INT_MODEM_LOCATION_SOURCE_3GPP_LAC_CI = 1 << 0,

121

MODULE_INT_MODEM_LOCATION_SOURCE_GPS_RAW = 1 << 1,

122

MODULE_INT_MODEM_LOCATION_SOURCE_GPS_NMEA = 1 << 2,

123

} ModuleIntModemLocationSource;

124

125

//SMS message state internal flags

126

typedef enum {

127

MODULE_INT_SMS_STATE_UNKNOWN = 0,

128

MODULE_INT_SMS_STATE_STORED = 1,

129

MODULE_INT_SMS_STATE_RECEIVING = 2,

130

MODULE_INT_SMS_STATE_RECEIVED = 3,

131

MODULE_INT_SMS_STATE_SENDING = 4,

132

MODULE_INT_SMS_STATE_SENT = 5,

133

} ModuleIntSmsState;

134

135

//SMS message internal type

136

typedef enum {

137

MODULE_INT_PDU_TYPE_UNKNOWN = 0,

138

MODULE_INT_PDU_TYPE_DELIVER = 1,

139

MODULE_INT_PDU_TYPE_SUBMIT = 2,

140

MODULE_INT_PDU_TYPE_STATUS_REPORT = 3

141

} ModuleIntSmsPduType;

142

143

//Private module variables

144

struct _mmguimoduledata {

145

//DBus connection

146

GDBusConnection *connection;

147

//DBus proxy objects

148

GDBusObjectManager *objectmanager;

149

GDBusProxy *cardproxy;

150

GDBusProxy *netproxy;

151

GDBusProxy *modemproxy;

152

GDBusProxy *smsproxy;

153

GDBusProxy *ussdproxy;

154

GDBusProxy *locationproxy;

155

GDBusProxy *timeproxy;

156

GDBusProxy *contactsproxy;

157

//Attached signal handlers

158

gulong netpropsignal;

159

gulong statesignal;

160

gulong modempropsignal;

161

gulong smssignal;

162

gulong locationpropsignal;

163

gulong timesignal;

164

//Partial SMS messages

165

GList *partialsms;

166

//Last error message

167

gchar *errormessage;

168

//Cancellable

169

GCancellable *cancellable;

170

//Operations timeouts

171

guint timeouts[MMGUI_DEVICE_OPERATIONS];

172

};

173

174

typedef struct _mmguimoduledata *moduledata_t;

175

176

static gboolean mmgui_module_device_enabled_from_state(gint state);

177

static gboolean mmgui_module_device_locked_from_state(gint state);

178

static gboolean mmgui_module_device_connected_from_state(gint state);

179

static gboolean mmgui_module_device_registered_from_state(gint state);

180

static enum _mmgui_device_types mmgui_module_device_type_from_caps(gint caps);

181

static enum _mmgui_reg_status mmgui_module_registration_status_translate(guint status);

182

static enum _mmgui_network_availability mmgui_module_network_availability_status_translate(guint status);

183

static enum _mmgui_access_tech mmgui_module_access_technology_translate(guint technology);

184

static enum _mmgui_device_modes mmgui_module_access_mode_translate(guint mode);

185

static gboolean mmgui_module_devices_update_device_mode(gpointer mmguicore, gint oldstate, gint newstate, guint changereason);

186

static gboolean mmgui_module_devices_update_location(gpointer mmguicore, mmguidevice_t device);

187

static gboolean mmgui_module_devices_enable_location(gpointer mmguicore, mmguidevice_t device, gboolean enable);

188

189

static mmguidevice_t mmgui_module_device_new(mmguicore_t mmguicore, const gchar *devpath);

190

191

static mmgui_sms_message_t mmgui_module_sms_retrieve(mmguicore_t mmguicore, const gchar *smspath);

192

static gint mmgui_module_sms_get_id(mmguicore_t mmguicore, const gchar *smspath);

193

194

195

static void mmgui_module_handle_error_message(mmguicore_t mmguicore, GError *error)

196

{

197

moduledata_t moduledata;

198

199

if ((mmguicore == NULL) || (error == NULL)) return;

200

201

moduledata = (moduledata_t)mmguicore->moduledata;

202

203

if (moduledata == NULL) return;

204

205

if (moduledata->errormessage != NULL) {

206

g_free(moduledata->errormessage);

207

}

208

209

if (error->message != NULL) {

210

moduledata->errormessage = g_strdup(error->message);

211

} else {

212

moduledata->errormessage = g_strdup("Unknown error");

213

}

214

215

g_warning("%s: %s", MMGUI_MODULE_DESCRIPTION, moduledata->errormessage);

216

}

217

218

static guint mmgui_module_get_object_path_index(const gchar *objectpath)

219

{

220

guint id;

221

gchar *objectpathid;

222

223

objectpathid = strrchr(objectpath, '/') + 1;

224

if ((objectpathid != NULL) && (objectpathid[0] != '\0')) {

225

id = atoi(objectpathid);

226

} else {

227

id = 0;

228

}

229

230

return id;

231

}

232

233

static void mmgui_signal_handler(GDBusProxy *proxy, const gchar *sender_name, const gchar *signal_name, GVariant *parameters, gpointer data)

234

{

235

mmguicore_t mmguicore;

236

moduledata_t moduledata;

237

gchar *statusstr;

238

gboolean statusflag;

239

gint oldstate, newstate;

240

guint changereason;

241

242

if (data == NULL) return;

243

244

mmguicore = (mmguicore_t)data;

245

moduledata = (moduledata_t)mmguicore->moduledata;

246

247

if (g_str_equal(signal_name, "Added")) {

248

g_variant_get(parameters, "(ob)", &statusstr, &statusflag);

249

if (statusflag) {

250

/*Message received from network*/

251

moduledata->partialsms = g_list_prepend(moduledata->partialsms, g_strdup(statusstr));

252

}

253

} else if (g_str_equal(signal_name, "StateChanged")) {

254

g_variant_get(parameters, "(iiu)", &oldstate, &newstate, &changereason);

255

/*Send signals if needed*/

256

mmgui_module_devices_update_device_mode(mmguicore, oldstate, newstate, changereason);

257

}

258

259

g_debug("SIGNAL: %s (%s) argtype: %s\n", signal_name, sender_name, g_variant_get_type_string(parameters));

260

}

261

262

static void mmgui_property_change_handler(GDBusProxy *proxy, GVariant *changed_properties, GStrv invalidated_properties, gpointer data)

263

{

264

mmguicore_t mmguicore;

265

mmguidevice_t device;

266

GVariantIter *iter;

267

GVariant *item;

268

const gchar *key;

269

GVariant *value;

270

guint statevalue;

271

gboolean stateflag;

272

273

if ((changed_properties == NULL) || (data == NULL)) return;

274

275

mmguicore = (mmguicore_t)data;

276

277

if (mmguicore->device == NULL) return;

278

device = mmguicore->device;

279

280

if (g_variant_n_children(changed_properties) > 0) {

281

g_variant_get(changed_properties, "a{sv}", &iter);

282

while (g_variant_iter_loop(iter, "{&sv}", &key, &value)) {

283

if (g_str_equal(key, "SignalQuality")) {

284

g_variant_get(value, "(ub)", &statevalue, &stateflag);

285

if (statevalue != device->siglevel) {

286

device->siglevel = statevalue;

287

if (mmguicore->eventcb != NULL) {

288

(mmguicore->eventcb)(MMGUI_EVENT_SIGNAL_LEVEL_CHANGE, mmguicore, mmguicore->device);

289

}

290

}

291

} else if (g_str_equal(key, "AccessTechnologies")) {

292

statevalue = mmgui_module_access_mode_translate(g_variant_get_uint32(value));

293

if (statevalue != device->mode) {

294

device->mode = statevalue;

295

if (mmguicore->eventcb != NULL) {

296

(mmguicore->eventcb)(MMGUI_EVENT_NETWORK_MODE_CHANGE, mmguicore, mmguicore->device);

297

}

298

}

299

300

} else if (g_str_equal(key, "Location")) {

301

if (mmgui_module_devices_update_location(mmguicore, mmguicore->device)) {

302

if (mmguicore->eventcb != NULL) {

303

(mmguicore->eventcb)(MMGUI_EVENT_LOCATION_CHANGE, mmguicore, mmguicore->device);

304

}

305

}

306

}

307

g_debug("Property changed: %s\n", key);

308

}

309

g_variant_iter_free(iter);

310

}

311

}

312

313

static void mmgui_objectmanager_added_signal_handler(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data)

314

{

315

mmguicore_t mmguicore;

316

const gchar *devpath;

317

mmguidevice_t device;

318

319

if ((user_data == NULL) || (object == NULL)) return;

320

321

mmguicore = (mmguicore_t)user_data;

322

323

if (mmguicore->eventcb != NULL) {

324

devpath = g_dbus_object_get_object_path(object);

325

g_debug("Device added: %s\n", devpath);

326

if (devpath != NULL) {

327

device = mmgui_module_device_new(mmguicore, devpath);

328

(mmguicore->eventcb)(MMGUI_EVENT_DEVICE_ADDED, mmguicore, device);

329

}

330

}

331

}

332

333

static void mmgui_objectmanager_removed_signal_handler(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data)

334

{

335

mmguicore_t mmguicore;

336

const gchar *devpath;

337

guint id;

338

339

if ((user_data == NULL) || (object == NULL)) return;

340

341

mmguicore = (mmguicore_t)user_data;

342

343

if (mmguicore->eventcb != NULL) {

344

devpath = g_dbus_object_get_object_path(object);

345

g_debug("Device removed: %s\n", devpath);

346

if (devpath != NULL) {

347

id = mmgui_module_get_object_path_index(devpath);

348

(mmguicore->eventcb)(MMGUI_EVENT_DEVICE_REMOVED, mmguicore, GUINT_TO_POINTER(id));

349

}

350

}

351

}

352

353

static gboolean mmgui_module_device_enabled_from_state(gint state)

354

{

355

gboolean enabled;

356

357

switch (state) {

358

case MODULE_INT_MODEM_STATE_FAILED:

359

case MODULE_INT_MODEM_STATE_UNKNOWN:

360

case MODULE_INT_MODEM_STATE_INITIALIZING:

361

case MODULE_INT_MODEM_STATE_LOCKED:

362

case MODULE_INT_MODEM_STATE_DISABLED:

363

case MODULE_INT_MODEM_STATE_DISABLING:

364

case MODULE_INT_MODEM_STATE_ENABLING:

365

enabled = FALSE;

366

break;

367

case MODULE_INT_MODEM_STATE_ENABLED:

368

case MODULE_INT_MODEM_STATE_SEARCHING:

369

case MODULE_INT_MODEM_STATE_REGISTERED:

370

case MODULE_INT_MODEM_STATE_DISCONNECTING:

371

case MODULE_INT_MODEM_STATE_CONNECTING:

372

case MODULE_INT_MODEM_STATE_CONNECTED:

373

enabled = TRUE;

374

break;

375

default:

376

enabled = FALSE;

377

break;

378

}

379

380

return enabled;

381

}

382

383

static gboolean mmgui_module_device_locked_from_state(gint state)

384

{

385

gboolean locked;

386

387

switch (state) {

388

case MODULE_INT_MODEM_STATE_FAILED:

389

case MODULE_INT_MODEM_STATE_UNKNOWN:

390

case MODULE_INT_MODEM_STATE_INITIALIZING:

391

locked = FALSE;

392

break;

393

case MODULE_INT_MODEM_STATE_LOCKED:

394

locked = TRUE;

395

break;

396

case MODULE_INT_MODEM_STATE_DISABLED:

397

case MODULE_INT_MODEM_STATE_DISABLING:

398

case MODULE_INT_MODEM_STATE_ENABLING:

399

case MODULE_INT_MODEM_STATE_ENABLED:

400

case MODULE_INT_MODEM_STATE_SEARCHING:

401

case MODULE_INT_MODEM_STATE_REGISTERED:

402

case MODULE_INT_MODEM_STATE_DISCONNECTING:

403

case MODULE_INT_MODEM_STATE_CONNECTING:

404

case MODULE_INT_MODEM_STATE_CONNECTED:

405

locked = FALSE;

406

break;

407

default:

408

locked = FALSE;

409

break;

410

}

411

412

return locked;

413

}

414

415

static gboolean mmgui_module_device_connected_from_state(gint state)

416

{

417

gboolean connected;

418

419

switch (state) {

420

case MODULE_INT_MODEM_STATE_FAILED:

421

case MODULE_INT_MODEM_STATE_UNKNOWN:

422

case MODULE_INT_MODEM_STATE_INITIALIZING:

423

case MODULE_INT_MODEM_STATE_LOCKED:

424

case MODULE_INT_MODEM_STATE_DISABLED:

425

case MODULE_INT_MODEM_STATE_DISABLING:

426

case MODULE_INT_MODEM_STATE_ENABLING:

427

case MODULE_INT_MODEM_STATE_ENABLED:

428

case MODULE_INT_MODEM_STATE_SEARCHING:

429

case MODULE_INT_MODEM_STATE_REGISTERED:

430

connected = FALSE;

431

break;

432

case MODULE_INT_MODEM_STATE_DISCONNECTING:

433

connected = TRUE;

434

break;

435

case MODULE_INT_MODEM_STATE_CONNECTING:

436

connected = FALSE;

437

break;

438

case MODULE_INT_MODEM_STATE_CONNECTED:

439

connected = TRUE;

440

break;

441

default:

442

connected = FALSE;

443

break;

444

}

445

446

return connected;

447

}

448

449

static gboolean mmgui_module_device_registered_from_state(gint state)

450

{

451

gboolean registered;

452

453

switch (state) {

454

case MODULE_INT_MODEM_STATE_FAILED:

455

case MODULE_INT_MODEM_STATE_UNKNOWN:

456

case MODULE_INT_MODEM_STATE_INITIALIZING:

457

case MODULE_INT_MODEM_STATE_LOCKED:

458

case MODULE_INT_MODEM_STATE_DISABLED:

459

case MODULE_INT_MODEM_STATE_DISABLING:

460

case MODULE_INT_MODEM_STATE_ENABLING:

461

case MODULE_INT_MODEM_STATE_ENABLED:

462

case MODULE_INT_MODEM_STATE_SEARCHING:

463

registered = FALSE;

464

break;

465

case MODULE_INT_MODEM_STATE_REGISTERED:

466

case MODULE_INT_MODEM_STATE_DISCONNECTING:

467

case MODULE_INT_MODEM_STATE_CONNECTING:

468

case MODULE_INT_MODEM_STATE_CONNECTED:

469

registered = TRUE;

470

break;

471

default:

472

registered = FALSE;

473

break;

474

}

475

476

return registered;

477

}

478

479

static enum _mmgui_device_types mmgui_module_device_type_from_caps(gint caps)

480

{

481

enum _mmgui_device_types type;

482

483

switch (caps) {

484

case MODULE_INT_MODEM_CAPABILITY_NONE:

485

case MODULE_INT_MODEM_CAPABILITY_POTS:

486

type = MMGUI_DEVICE_TYPE_GSM;

487

break;

488

case MODULE_INT_MODEM_CAPABILITY_CDMA_EVDO:

489

type = MMGUI_DEVICE_TYPE_CDMA;

490

break;

491

case MODULE_INT_MODEM_CAPABILITY_GSM_UMTS:

492

case MODULE_INT_MODEM_CAPABILITY_LTE:

493

case MODULE_INT_MODEM_CAPABILITY_LTE_ADVANCED:

494

case MODULE_INT_MODEM_CAPABILITY_IRIDIUM:

495

type = MMGUI_DEVICE_TYPE_GSM;

496

break;

497

default:

498

type = MMGUI_DEVICE_TYPE_GSM;

499

break;

500

}

501

502

return type;

503

}

504

505

static enum _mmgui_reg_status mmgui_module_registration_status_translate(guint status)

506

{

507

enum _mmgui_reg_status tstatus;

508

509

switch (status) {

510

case MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_IDLE:

511

tstatus = MMGUI_REG_STATUS_IDLE;

512

break;

513

case MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_HOME:

514

tstatus = MMGUI_REG_STATUS_HOME;

515

break;

516

case MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_SEARCHING:

517

tstatus = MMGUI_REG_STATUS_SEARCHING;

518

break;

519

case MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_DENIED:

520

tstatus = MMGUI_REG_STATUS_DENIED;

521

break;

522

case MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN:

523

tstatus = MMGUI_REG_STATUS_UNKNOWN;

524

break;

525

case MODULE_INT_MODEM_3GPP_REGISTRATION_STATE_ROAMING:

526

tstatus = MMGUI_REG_STATUS_ROAMING;

527

break;

528

default:

529

tstatus = MMGUI_REG_STATUS_UNKNOWN;

530

break;

531

}

532

533

return tstatus;

534

}

535

536

static enum _mmgui_network_availability mmgui_module_network_availability_status_translate(guint status)

537

{

538

guint tstatus;

539

540

switch (status) {

541

case MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_UNKNOWN:

542

tstatus = MMGUI_NA_UNKNOWN;

543

break;

544

case MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_AVAILABLE:

545

tstatus = MMGUI_NA_AVAILABLE;

546

break;

547

case MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_CURRENT:

548

tstatus = MMGUI_NA_CURRENT;

549

break;

550

case MODULE_INT_MODEM_3GPP_NETWORK_AVAILABILITY_FORBIDDEN:

551

tstatus = MMGUI_NA_FORBIDDEN;

552

break;

553

default:

554

tstatus = MMGUI_NA_UNKNOWN;

555

break;

556

}

557

558

return tstatus;

559

}

560

561

static enum _mmgui_access_tech mmgui_module_access_technology_translate(guint technology)

562

{

563

enum _mmgui_access_tech ttechnology;

564

565

switch (technology) {

566

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_UNKNOWN:

567

ttechnology = MMGUI_ACCESS_TECH_UNKNOWN;

568

break;

569

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_POTS:

570

ttechnology = MMGUI_ACCESS_TECH_UNKNOWN;

571

break;

572

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GSM:

573

ttechnology = MMGUI_ACCESS_TECH_GSM;

574

break;

575

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT:

576

ttechnology = MMGUI_ACCESS_TECH_GSM_COMPACT;

577

break;

578

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GPRS:

579

ttechnology = MMGUI_ACCESS_TECH_EDGE;

580

break;

581

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EDGE:

582

ttechnology = MMGUI_ACCESS_TECH_EDGE;

583

break;

584

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_UMTS:

585

ttechnology = MMGUI_ACCESS_TECH_UMTS;

586

break;

587

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSDPA:

588

ttechnology = MMGUI_ACCESS_TECH_HSDPA;

589

break;

590

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSUPA:

591

ttechnology = MMGUI_ACCESS_TECH_HSUPA;

592

break;

593

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSPA:

594

ttechnology = MMGUI_ACCESS_TECH_HSPA;

595

break;

596

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS:

597

ttechnology = MMGUI_ACCESS_TECH_HSPA_PLUS;

598

break;

599

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_1XRTT:

600

ttechnology = MMGUI_ACCESS_TECH_1XRTT;

601

break;

602

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDO0:

603

ttechnology = MMGUI_ACCESS_TECH_EVDO0;

604

break;

605

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDOA:

606

ttechnology = MMGUI_ACCESS_TECH_EVDOA;

607

break;

608

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDOB:

609

ttechnology = MMGUI_ACCESS_TECH_EVDOB;

610

break;

611

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_LTE:

612

ttechnology = MMGUI_ACCESS_TECH_LTE;

613

break;

614

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_ANY:

615

ttechnology = MMGUI_ACCESS_TECH_UNKNOWN;

616

break;

617

default:

618

ttechnology = MMGUI_ACCESS_TECH_UNKNOWN;

619

break;

620

}

621

622

return ttechnology;

623

}

624

625

static enum _mmgui_device_modes mmgui_module_access_mode_translate(guint mode)

626

{

627

enum _mmgui_device_modes tmode;

628

629

switch (mode) {

630

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_UNKNOWN:

631

tmode = MMGUI_DEVICE_MODE_UNKNOWN;

632

break;

633

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_POTS:

634

tmode = MMGUI_DEVICE_MODE_UNKNOWN;

635

break;

636

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GSM:

637

tmode = MMGUI_DEVICE_MODE_GSM;

638

break;

639

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT:

640

tmode = MMGUI_DEVICE_MODE_GSM_COMPACT;

641

break;

642

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_GPRS:

643

tmode = MMGUI_DEVICE_MODE_GPRS;

644

break;

645

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EDGE:

646

tmode = MMGUI_DEVICE_MODE_EDGE;

647

break;

648

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_UMTS:

649

tmode = MMGUI_DEVICE_MODE_UMTS;

650

break;

651

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSDPA:

652

tmode = MMGUI_DEVICE_MODE_HSDPA;

653

break;

654

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSUPA:

655

tmode = MMGUI_DEVICE_MODE_HSUPA;

656

break;

657

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSPA:

658

tmode = MMGUI_DEVICE_MODE_HSPA;

659

break;

660

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS:

661

tmode = MMGUI_DEVICE_MODE_HSPA_PLUS;

662

break;

663

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_1XRTT:

664

tmode = MMGUI_DEVICE_MODE_1XRTT;

665

break;

666

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDO0:

667

tmode = MMGUI_DEVICE_MODE_EVDO0;

668

break;

669

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDOA:

670

tmode = MMGUI_DEVICE_MODE_EVDOA;

671

break;

672

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_EVDOB:

673

tmode = MMGUI_DEVICE_MODE_EVDOB;

674

break;

675

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_LTE:

676

tmode = MMGUI_DEVICE_MODE_LTE;

677

break;

678

case MODULE_INT_MODEM_ACCESS_TECHNOLOGY_ANY:

679

tmode = MMGUI_DEVICE_MODE_UNKNOWN;

680

break;

681

default:

682

tmode = MMGUI_DEVICE_MODE_UNKNOWN;

683

break;

684

}

685

686

return tmode;

687

}

688

689

static mmguidevice_t mmgui_module_device_new(mmguicore_t mmguicore, const gchar *devpath)

690

{

691

mmguidevice_t device;

692

moduledata_t moduledata;

693

GDBusProxy *deviceproxy;

694

GError *error;

695

GVariant *deviceinfo;

696

gsize strsize;

697

guint statevalue;

698

gchar *blockstr;

699

700

if ((mmguicore == NULL) || (devpath == NULL)) return NULL;

701

702

moduledata = (moduledata_t)mmguicore->moduledata;

703

704

if (moduledata->connection == NULL) return NULL;

705

706

device = g_new0(struct _mmguidevice, 1);

707

708

device->id = mmgui_module_get_object_path_index(devpath);

709

device->objectpath = g_strdup(devpath);

710

711

device->operation = MMGUI_DEVICE_OPERATION_IDLE;

712

/*Zero values we can't get this moment*/

713

/*SMS*/

714

device->smscaps = MMGUI_SMS_CAPS_NONE;

715

device->smsdb = NULL;

716

/*Networks*/

717

/*Info*/

718

device->manufacturer = NULL;

719

device->model = NULL;

720

device->version = NULL;

721

device->operatorname = NULL;

722

device->operatorcode = NULL;

723

device->imei = NULL;

724

device->imsi = NULL;

725

device->port = NULL;

726

device->internalid = NULL;

727

device->persistentid = NULL;

728

device->sysfspath = NULL;

729

/*USSD*/

730

device->ussdcaps = MMGUI_USSD_CAPS_NONE;

731

device->ussdencoding = MMGUI_USSD_ENCODING_GSM7;

732

/*Location*/

733

device->locationcaps = MMGUI_LOCATION_CAPS_NONE;

734

memset(device->loc3gppdata, 0, sizeof(device->loc3gppdata));

735

memset(device->locgpsdata, 0, sizeof(device->locgpsdata));

736

/*Scan*/

737

device->scancaps = MMGUI_SCAN_CAPS_NONE;

738

/*Traffic*/

739

device->rxbytes = 0;

740

device->txbytes = 0;

741

device->sessiontime = 0;

742

device->speedchecktime = 0;

743

device->smschecktime = 0;

744

device->speedindex = 0;

745

device->connected = FALSE;

746

memset(device->speedvalues, 0, sizeof(device->speedvalues));

747

memset(device->interface, 0, sizeof(device->interface));

748

/*Contacts*/

749

device->contactscaps = MMGUI_CONTACTS_CAPS_NONE;

750

device->contactslist = NULL;

751

752

error = NULL;

753

754

deviceproxy = g_dbus_proxy_new_sync(moduledata->connection,

755

G_DBUS_PROXY_FLAGS_NONE,

756

NULL,

757

"org.freedesktop.ModemManager1",

758

devpath,

759

"org.freedesktop.ModemManager1.Modem",

760

NULL,

761

&error);

762

763

if ((deviceproxy == NULL) && (error != NULL)) {

764

mmgui_module_handle_error_message(mmguicore, error);

765

g_error_free(error);

766

g_object_unref(deviceproxy);

767

/*Fill default values*/

768

device->manufacturer = g_strdup(_("Unknown"));

769

device->model = g_strdup(_("Unknown"));

770

device->version = g_strdup(_("Unknown"));

771

device->port = g_strdup(_("Unknown"));

772

device->type = MMGUI_DEVICE_TYPE_GSM;

773

return device;

774

}

775

776

/*Device manufacturer*/

777

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "Manufacturer");

778

if (deviceinfo != NULL) {

779

strsize = 256;

780

device->manufacturer = g_strdup(g_variant_get_string(deviceinfo, &strsize));

781

g_variant_unref(deviceinfo);

782

} else {

783

device->manufacturer = g_strdup(_("Unknown"));

784

}

785

786

/*Device model*/

787

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "Model");

788

if (deviceinfo != NULL) {

789

strsize = 256;

790

device->model = g_strdup(g_variant_get_string(deviceinfo, &strsize));

791

g_variant_unref(deviceinfo);

792

} else {

793

device->model = g_strdup(_("Unknown"));

794

}

795

796

/*Device revision*/

797

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "Revision");

798

if (deviceinfo != NULL) {

799

strsize = 256;

800

device->version = g_strdup(g_variant_get_string(deviceinfo, &strsize));

801

g_variant_unref(deviceinfo);

802

} else {

803

device->version = g_strdup(_("Unknown"));

804

}

805

806

/*Device port*/

807

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "PrimaryPort");

808

if (deviceinfo != NULL) {

809

strsize = 256;

810

device->port = g_strdup(g_variant_get_string(deviceinfo, &strsize));

811

g_variant_unref(deviceinfo);

812

} else {

813

device->port = g_strdup("");

814

}

815

816

/*Need to get usb device serial for fallback traffic monitoring*/

817

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "Device");

818

if (deviceinfo != NULL) {

819

strsize = 256;

820

device->sysfspath = g_strdup(g_variant_get_string(deviceinfo, &strsize));

821

g_variant_unref(deviceinfo);

822

} else {

823

device->sysfspath = g_strdup("");

824

}

825

826

/*Device type (version 0.7.990 property)*/

827

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "ModemCapabilities");

828

if (deviceinfo != NULL) {

829

statevalue = g_variant_get_uint32(deviceinfo);

830

device->type = mmgui_module_device_type_from_caps(statevalue);

831

g_variant_unref(deviceinfo);

832

} else {

833

/*Device type (version 0.7.991 property)*/

834

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "CurrentCapabilities");

835

if (deviceinfo != NULL) {

836

statevalue = g_variant_get_uint32(deviceinfo);

837

device->type = mmgui_module_device_type_from_caps(statevalue);

838

g_variant_unref(deviceinfo);

839

} else {

840

device->type = MODULE_INT_MODEM_CAPABILITY_GSM_UMTS;

841

}

842

}

843

844

/*Is device enabled, blocked and registered*/

845

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "State");

846

if (deviceinfo != NULL) {

847

statevalue = g_variant_get_int32(deviceinfo);

848

device->enabled = mmgui_module_device_enabled_from_state(statevalue);

849

device->blocked = mmgui_module_device_locked_from_state(statevalue);

850

device->registered = mmgui_module_device_registered_from_state(statevalue);

851

g_variant_unref(deviceinfo);

852

} else {

853

device->enabled = TRUE;

854

device->blocked = FALSE;

855

device->registered = TRUE;

856

}

857

858

/*Internal Modem Manager identifier*/

859

deviceinfo = g_dbus_proxy_get_cached_property(deviceproxy, "DeviceIdentifier");

860

if (deviceinfo != NULL) {

861

strsize = 256;

862

device->internalid = g_strdup(g_variant_get_string(deviceinfo, &strsize));

863

g_variant_unref(deviceinfo);

864

} else {

865

device->internalid = NULL;

866

}

867

868

/*Persistent device identifier*/

869

blockstr = g_strdup_printf("%s_%s_%s", device->manufacturer, device->model, device->version);

870

device->persistentid = g_compute_checksum_for_string(G_CHECKSUM_MD5, (const gchar *)blockstr, -1);

871

g_free(blockstr);

872

873

g_object_unref(deviceproxy);

874

875

return device;

876

}

877

878

G_MODULE_EXPORT gboolean mmgui_module_init(mmguimodule_t module)

879

{

880

if (module == NULL) return FALSE;

881

882

module->type = MMGUI_MODULE_TYPE_MODEM_MANAGER;

883

module->requirement = MMGUI_MODULE_REQUIREMENT_SERVICE;

884

module->priority = MMGUI_MODULE_PRIORITY_NORMAL;

885

module->identifier = MMGUI_MODULE_IDENTIFIER;

886

module->functions = MMGUI_MODULE_FUNCTION_BASIC;

887

g_snprintf(module->servicename, sizeof(module->servicename), MMGUI_MODULE_SERVICE_NAME);

888

g_snprintf(module->description, sizeof(module->description), MMGUI_MODULE_DESCRIPTION);

889

890

return TRUE;

891

}

892

893

G_MODULE_EXPORT gboolean mmgui_module_open(gpointer mmguicore)

894

{

895

mmguicore_t mmguicorelc;

896

moduledata_t *moduledata;

897

GError *error;

898

899

if (mmguicore == NULL) return FALSE;

900

901

mmguicorelc = (mmguicore_t)mmguicore;

902

903

moduledata = (moduledata_t *)&mmguicorelc->moduledata;

904

905

(*moduledata) = g_new0(struct _mmguimoduledata, 1);

906

907

error = NULL;

908

909

(*moduledata)->connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);

910

911

(*moduledata)->errormessage = NULL;

912

913

if (((*moduledata)->connection == NULL) && (error != NULL)) {

914

mmgui_module_handle_error_message(mmguicorelc, error);

915

g_error_free(error);

916

g_free(mmguicorelc->moduledata);

917

return FALSE;

918

}

919

920

error = NULL;

921

922

(*moduledata)->objectmanager = g_dbus_object_manager_client_new_sync((*moduledata)->connection,

923

G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,

924

"org.freedesktop.ModemManager1",

925

"/org/freedesktop/ModemManager1",

926

NULL,

927

NULL,

928

NULL,

929

NULL,

930

&error);

931

932

g_signal_connect(G_OBJECT((*moduledata)->objectmanager), "object-added", G_CALLBACK(mmgui_objectmanager_added_signal_handler), mmguicore);

933

g_signal_connect(G_OBJECT((*moduledata)->objectmanager), "object-removed", G_CALLBACK(mmgui_objectmanager_removed_signal_handler), mmguicore);

934

935

if (((*moduledata)->objectmanager == NULL) && (error != NULL)) {

936

mmgui_module_handle_error_message(mmguicorelc, error);

937

g_error_free(error);

938

g_object_unref((*moduledata)->connection);

939

g_free(mmguicorelc->moduledata);

940

return FALSE;

941

}

942

/*Cancellable*/

943

(*moduledata)->cancellable = g_cancellable_new();

944

/*Operations timeouts*/

945

(*moduledata)->timeouts[MMGUI_DEVICE_OPERATION_ENABLE] = MMGUI_MODULE_ENABLE_OPERATION_TIMEOUT;

946

(*moduledata)->timeouts[MMGUI_DEVICE_OPERATION_SEND_SMS] = MMGUI_MODULE_SEND_SMS_OPERATION_TIMEOUT;

947

(*moduledata)->timeouts[MMGUI_DEVICE_OPERATION_SEND_USSD] = MMGUI_MODULE_SEND_USSD_OPERATION_TIMEOUT;

948

(*moduledata)->timeouts[MMGUI_DEVICE_OPERATION_SCAN] = MMGUI_MODULE_NETWORKS_SCAN_OPERATION_TIMEOUT;

949

950

return TRUE;

951

}

952

953

G_MODULE_EXPORT gboolean mmgui_module_close(gpointer mmguicore)

954

{

955

mmguicore_t mmguicorelc;

956

moduledata_t moduledata;

957

GError *error;

958

959

if (mmguicore == NULL) return FALSE;

960

mmguicorelc = (mmguicore_t)mmguicore;

961

moduledata = (moduledata_t)(mmguicorelc->moduledata);

962

963

//Close device

964

//Stop subsystems

965

966

if (moduledata != NULL) {

967

if (moduledata->errormessage != NULL) {

968

g_free(moduledata->errormessage);

969

}

970

971

if (moduledata->cancellable != NULL) {

972

g_object_unref(moduledata->cancellable);

973

moduledata->cancellable = NULL;

974

}

975

976

if (moduledata->objectmanager != NULL) {

977

g_object_unref(moduledata->objectmanager);

978

moduledata->objectmanager = NULL;

979

}

980

981

if (moduledata->connection != NULL) {

982

g_object_unref(moduledata->connection);

983

moduledata->connection = NULL;

984

}

985

986

g_free(moduledata);

987

}

988

989

return TRUE;

990

}

991

992

G_MODULE_EXPORT gchar *mmgui_module_last_error(gpointer mmguicore)

993

{

994

mmguicore_t mmguicorelc;

995

moduledata_t moduledata;

996

997

if (mmguicore == NULL) return NULL;

998

999

mmguicorelc = (mmguicore_t)mmguicore;

1000

moduledata = (moduledata_t)(mmguicorelc->moduledata);

1001

1002

return moduledata->errormessage;

1003

}

1004

1005

G_MODULE_EXPORT gboolean mmgui_module_interrupt_operation(gpointer mmguicore)

1006

{

1007

mmguicore_t mmguicorelc;

1008

moduledata_t moduledata;

1009

mmguidevice_t device;

1010

1011

if (mmguicore == NULL) return FALSE;

1012

mmguicorelc = (mmguicore_t)mmguicore;

1013

1014

if (mmguicorelc->moduledata == NULL) return FALSE;

1015

moduledata = (moduledata_t)mmguicorelc->moduledata;

1016

1017

if (mmguicorelc->device == NULL) return FALSE;

1018

device = mmguicorelc->device;

1019

1020

if (device->operation == MMGUI_DEVICE_OPERATION_IDLE) return FALSE;

1021

1022

if (moduledata->cancellable != NULL) {

1023

g_cancellable_cancel(moduledata->cancellable);

1024

return TRUE;

1025

} else {

1026

return FALSE;

1027

}

1028

}

1029

1030

G_MODULE_EXPORT gboolean mmgui_module_set_timeout(gpointer mmguicore, guint operation, guint timeout)

1031

{

1032

mmguicore_t mmguicorelc;

1033

moduledata_t moduledata;

1034

1035

if (mmguicore == NULL) return FALSE;

1036

mmguicorelc = (mmguicore_t)mmguicore;

1037

1038

if (mmguicorelc->moduledata == NULL) return FALSE;

1039

moduledata = (moduledata_t)mmguicorelc->moduledata;

1040

1041

if (timeout < 1000) timeout *= 1000;

1042

1043

if (operation < MMGUI_DEVICE_OPERATIONS) {

1044

moduledata->timeouts[operation] = timeout;

1045

return TRUE;

1046

} else {

1047

return FALSE;

1048

}

1049

}

1050

1051

G_MODULE_EXPORT guint mmgui_module_devices_enum(gpointer mmguicore, GSList **devicelist)

1052

{

1053

mmguicore_t mmguicorelc;

1054

moduledata_t moduledata;

1055

guint devnum;

1056

GList *objects, *object;

1057

const gchar *devpath;

1058

1059

if ((mmguicore == NULL) || (devicelist == NULL)) return 0;

1060

mmguicorelc = (mmguicore_t)mmguicore;

1061

1062

if (mmguicorelc->moduledata == NULL) return 0;

1063

moduledata = (moduledata_t)mmguicorelc->moduledata;

1064

1065

devnum = 0;

1066

1067

objects = g_dbus_object_manager_get_objects(moduledata->objectmanager);

1068

for (object = objects; object != NULL; object = object->next) {

1069

devpath = g_dbus_object_get_object_path(G_DBUS_OBJECT(object->data));

1070

g_debug("Device object path: %s\n", devpath);

1071

*devicelist = g_slist_prepend(*devicelist, mmgui_module_device_new(mmguicore, devpath));

1072

devnum++;

1073

}

1074

g_list_foreach(objects, (GFunc)g_object_unref, NULL);

1075

g_list_free(objects);

1076

1077

return devnum;

1078

}

1079

1080

G_MODULE_EXPORT gboolean mmgui_module_devices_state(gpointer mmguicore, enum _mmgui_device_state_request request)

1081

{

1082

mmguicore_t mmguicorelc;

1083

moduledata_t moduledata;

1084

mmguidevice_t device;

1085

GVariant *data;

1086

gint statevalue;

1087

gboolean res;

1088

1089

if (mmguicore == NULL) return FALSE;

1090

mmguicorelc = (mmguicore_t)mmguicore;

1091

1092

if (mmguicorelc->moduledata == NULL) return FALSE;

1093

moduledata = (moduledata_t)mmguicorelc->moduledata;

1094

1095

if (mmguicorelc->device == NULL) return FALSE;

1096

device = mmguicorelc->device;

1097

1098

if (moduledata->modemproxy == NULL) return FALSE;

1099

1100

data = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "State");

1101

if (data != NULL) {

1102

statevalue = g_variant_get_int32(data);

1103

g_variant_unref(data);

1104

} else {

1105

return FALSE;

1106

}

1107

1108

switch (request) {

1109

case MMGUI_DEVICE_STATE_REQUEST_ENABLED:

1110

/*Is device enabled*/

1111

res = mmgui_module_device_enabled_from_state(statevalue);

1112

if (device->operation != MMGUI_DEVICE_OPERATION_ENABLE) {

1113

device->enabled = res;

1114

}

1115

break;

1116

case MMGUI_DEVICE_STATE_REQUEST_LOCKED:

1117

/*Is device blocked*/

1118

res = mmgui_module_device_locked_from_state(statevalue);

1119

device->blocked = res;

1120

break;

1121

case MMGUI_DEVICE_STATE_REQUEST_REGISTERED:

1122

/*Is device registered in network*/

1123

res = mmgui_module_device_registered_from_state(statevalue);

1124

device->registered = res;

1125

break;

1126

case MMGUI_DEVICE_STATE_REQUEST_CONNECTED:

1127

/*Is device connected (modem manager state)*/

1128

res = mmgui_module_device_connected_from_state(statevalue);

1129

break;

1130

default:

1131

res = FALSE;

1132

break;

1133

}

1134

1135

return res;

1136

}

1137

1138

G_MODULE_EXPORT gboolean mmgui_module_devices_update_state(gpointer mmguicore)

1139

{

1140

mmguicore_t mmguicorelc;

1141

moduledata_t moduledata;

1142

mmguidevice_t device;

1143

gint messageid;

1144

GList *pslnode;

1145

GList *pslnext;

1146

gchar *pslpath;

1147

1148

if (mmguicore == NULL) return FALSE;

1149

mmguicorelc = (mmguicore_t)mmguicore;

1150

1151

if (mmguicorelc->moduledata == NULL) return FALSE;

1152

moduledata = (moduledata_t)mmguicorelc->moduledata;

1153

1154

if (mmguicorelc->device == NULL) return FALSE;

1155

device = mmguicorelc->device;

1156

1157

if (device->enabled) {

1158

//Search for completed messages in partial sms list

1159

if ((moduledata->partialsms != NULL) && (mmguicorelc->eventcb != NULL)) {

1160

pslnode = moduledata->partialsms;

1161

while (pslnode != NULL) {

1162

pslpath = (gchar *)pslnode->data;

1163

pslnext = g_list_next(pslnode);

1164

//If messageid is -1 then it is incomplete

1165

messageid = mmgui_module_sms_get_id(mmguicore, pslpath);

1166

if (messageid != -1) {

1167

//Free resources

1168

g_free(pslpath);

1169

//Remove list node

1170

moduledata->partialsms = g_list_delete_link(moduledata->partialsms, pslnode);

1171

//Send notification

1172

(mmguicorelc->eventcb)(MMGUI_EVENT_SMS_COMPLETED, mmguicore, GUINT_TO_POINTER((guint)messageid));

1173

}

1174

pslnode = pslnext;

1175

}

1176

}

1177

}

1178

1179

return TRUE;

1180

}

1181

1182

static gboolean mmgui_module_devices_update_device_mode(gpointer mmguicore, gint oldstate, gint newstate, guint changereason)

1183

{

1184

mmguicore_t mmguicorelc;

1185

moduledata_t moduledata;

1186

mmguidevice_t device;

1187

gboolean enabledsignal, blockedsignal, regsignal;

1188

gsize strsize;

1189

GVariant *data;

1190

1191

if (mmguicore == NULL) return FALSE;

1192

mmguicorelc = (mmguicore_t)mmguicore;

1193

1194

if (mmguicorelc->moduledata == NULL) return FALSE;

1195

moduledata = (moduledata_t)mmguicorelc->moduledata;

1196

1197

if (mmguicorelc->device == NULL) return FALSE;

1198

device = mmguicorelc->device;

1199

1200

/*Upadate state flags*/

1201

if (device->operation != MMGUI_DEVICE_OPERATION_ENABLE) {

1202

device->enabled = mmgui_module_device_enabled_from_state(newstate);

1203

}

1204

device->blocked = mmgui_module_device_locked_from_state(newstate);

1205

device->registered = mmgui_module_device_registered_from_state(newstate);

1206

/*Is enabled signal needed */

1207

if ((device->operation != MMGUI_DEVICE_OPERATION_ENABLE) && (mmgui_module_device_enabled_from_state(oldstate) != device->enabled)) {

1208

enabledsignal = TRUE;

1209

} else {

1210

enabledsignal = FALSE;

1211

}

1212

/*Is blocked signal needed */

1213

if (mmgui_module_device_locked_from_state(oldstate) != device->blocked) {

1214

blockedsignal = TRUE;

1215

} else {

1216

blockedsignal = FALSE;

1217

}

1218

/*Is registered signal needed */

1219

if (mmgui_module_device_registered_from_state(oldstate) != device->registered) {

1220

regsignal = TRUE;

1221

} else {

1222

regsignal = FALSE;

1223

}

1224

1225

/*Return if no signals will be sent*/

1226

if ((!enabledsignal) && (!blockedsignal) && (!regsignal)) return TRUE;

1227

1228

if (moduledata->netproxy != NULL) {

1229

//Operator information

1230

if (device->operatorcode != NULL) {

1231

g_free(device->operatorcode);

1232

device->operatorcode = NULL;

1233

}

1234

1235

if (device->operatorname != NULL) {

1236

g_free(device->operatorname);

1237

device->operatorname = NULL;

1238

}

1239

1240

//Registration state

1241

data = g_dbus_proxy_get_cached_property(moduledata->netproxy, "RegistrationState");

1242

if (data != NULL) {

1243

device->regstatus = mmgui_module_registration_status_translate(g_variant_get_uint32(data));

1244

g_variant_unref(data);

1245

} else {

1246

device->regstatus = MMGUI_REG_STATUS_UNKNOWN;

1247

}

1248

//Operator code

1249

data = g_dbus_proxy_get_cached_property(moduledata->netproxy, "OperatorCode");

1250

if (data != NULL) {

1251

strsize = 256;

1252

device->operatorcode = g_strdup(g_variant_get_string(data, &strsize));

1253

g_variant_unref(data);

1254

} else {

1255

device->operatorcode = NULL;

1256

}

1257

//Operator name

1258

data = g_dbus_proxy_get_cached_property(moduledata->netproxy, "OperatorName");

1259

if (data != NULL) {

1260

strsize = 256;

1261

device->operatorname = g_strdup(g_variant_get_string(data, &strsize));

1262

g_variant_unref(data);

1263

} else {

1264

device->operatorname = NULL;

1265

}

1266

}

1267

1268

if (moduledata->modemproxy != NULL) {

1269

if (device->enabled) {

1270

//Device identifier (IMEI)

1271

if (device->imei != NULL) {

1272

g_free(device->imei);

1273

device->imei = NULL;

1274

}

1275

1276

data = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "EquipmentIdentifier");

1277

if (data != NULL) {

1278

device->imei = g_strdup(g_variant_get_string(data, &strsize));

1279

g_variant_unref(data);

1280

} else {

1281

device->imei = NULL;

1282

}

1283

}

1284

}

1285

1286

if (moduledata->cardproxy != NULL) {

1287

if (device->type == MMGUI_DEVICE_TYPE_GSM) {

1288

if (device->enabled) {

1289

//IMSI

1290

if (device->imsi != NULL) {

1291

g_free(device->imsi);

1292

device->imsi = NULL;

1293

}

1294

//IMSI

1295

data = g_dbus_proxy_get_cached_property(moduledata->cardproxy, "Imsi");

1296

if (data != NULL) {

1297

strsize = 256;

1298

device->imsi = g_strdup(g_variant_get_string(data, &strsize));

1299

g_variant_unref(data);

1300

} else {

1301

device->imsi = NULL;

1302

}

1303

}

1304

} else if (device->type == MMGUI_DEVICE_TYPE_CDMA) {

1305

//No IMSI in CDMA

1306

if (device->imsi != NULL) {

1307

g_free(device->imsi);

1308

device->imsi = NULL;

1309

}

1310

}

1311

}

1312

1313

/*Enabled signal */

1314

if (enabledsignal) {

1315

if (mmguicorelc->eventcb != NULL) {

1316

(mmguicorelc->eventcb)(MMGUI_EVENT_DEVICE_ENABLED_STATUS, mmguicorelc, GUINT_TO_POINTER(device->enabled));

1317

}

1318

}

1319

/*Is blocked signal needed */

1320

if (blockedsignal) {

1321

if (mmguicorelc->eventcb != NULL) {

1322

(mmguicorelc->eventcb)(MMGUI_EVENT_DEVICE_BLOCKED_STATUS, mmguicorelc, GUINT_TO_POINTER(device->blocked));

1323

}

1324

}

1325

/*Is registered signal needed */

1326

if (regsignal) {

1327

if (mmguicorelc->eventcb != NULL) {

1328

(mmguicorelc->eventcb)(MMGUI_EVENT_NETWORK_REGISTRATION_CHANGE, mmguicorelc, device);

1329

}

1330

}

1331

1332

return TRUE;

1333

}

1334

1335

static gboolean mmgui_module_devices_update_location(gpointer mmguicore, mmguidevice_t device)

1336

{

1337

mmguicore_t mmguicorelc;

1338

moduledata_t moduledata;

1339

GVariant *data;

1340

GVariantIter *iter;

1341

guint32 locationtype;

1342

GVariant *locationdata;

1343

gchar *locationstring;

1344

gsize strlength;

1345

GError *error;

1346

1347

if ((mmguicore == NULL) || (device == NULL)) return FALSE;

1348

mmguicorelc = (mmguicore_t)mmguicore;

1349

1350

if (mmguicorelc->moduledata == NULL) return FALSE;

1351

moduledata = (moduledata_t)mmguicorelc->moduledata;

1352

1353

if ((!(device->locationcaps & MMGUI_LOCATION_CAPS_3GPP)) && (!(device->locationcaps & MMGUI_LOCATION_CAPS_GPS))) return FALSE;

1354

1355

error = NULL;

1356

1357

data = g_dbus_proxy_call_sync(moduledata->locationproxy,

1358

"GetLocation",

1359

NULL,

1360

0,

1361

-1,

1362

NULL,

1363

&error);

1364

1365

if ((data != NULL) && (error == NULL)) {

1366

g_variant_get(data, "(a{uv})", &iter);

1367

while (g_variant_iter_next(iter, "{uv}", &locationtype, &locationdata)) {

1368

if ((locationtype == MODULE_INT_MODEM_LOCATION_SOURCE_3GPP_LAC_CI) && (locationdata != NULL)) {

1369

//3GPP location

1370

strlength = 256;

1371

locationstring = g_strdup(g_variant_get_string(locationdata, &strlength));

1372

device->loc3gppdata[0] = (guint)strtol(strsep(&locationstring, ","), NULL, 10);

1373

device->loc3gppdata[1] = (guint)strtol(strsep(&locationstring, ","), NULL, 10);

1374

device->loc3gppdata[2] = (guint)strtol(strsep(&locationstring, ","), NULL, 16);

1375

device->loc3gppdata[3] = (guint)strtol(strsep(&locationstring, ","), NULL, 16);

1376

g_free(locationstring);

1377

g_variant_unref(locationdata);

1378

g_debug("3GPP location: %u, %u, %4x, %4x", device->loc3gppdata[0], device->loc3gppdata[1], device->loc3gppdata[2], device->loc3gppdata[3]);

1379

} else if ((locationtype == MODULE_INT_MODEM_LOCATION_SOURCE_GPS_RAW) && (locationdata != NULL)) {

1380

//GPS location

1381

locationdata = g_variant_lookup_value(data, "latitude", G_VARIANT_TYPE_STRING);

1382

if (locationdata != NULL) {

1383

strlength = 256;

1384

locationstring = (gchar *)g_variant_get_string(locationdata, &strlength);

1385

device->locgpsdata[0] = atof(locationstring);

1386

g_variant_unref(locationdata);

1387

} else {

1388

device->locgpsdata[0] = 0.0;

1389

}

1390

locationdata = g_variant_lookup_value(data, "longitude", G_VARIANT_TYPE_STRING);

1391

if (locationdata != NULL) {

1392

strlength = 256;

1393

locationstring = (gchar *)g_variant_get_string(locationdata, &strlength);

1394

device->locgpsdata[1] = atof(locationstring);

1395

g_variant_unref(locationdata);

1396

} else {

1397

device->locgpsdata[1] = 0.0;

1398

}

1399

locationdata = g_variant_lookup_value(data, "altitude", G_VARIANT_TYPE_STRING);

1400

if (locationdata != NULL) {

1401

strlength = 256;

1402

locationstring = (gchar *)g_variant_get_string(locationdata, &strlength);

1403

device->locgpsdata[2] = atof(locationstring);

1404

g_variant_unref(locationdata);

1405

} else {

1406

device->locgpsdata[2] = 0.0;

1407

}

1408

locationdata = g_variant_lookup_value(data, "utc-time", G_VARIANT_TYPE_STRING);

1409

if (locationdata != NULL) {

1410

strlength = 256;

1411

locationstring = (gchar *)g_variant_get_string(locationdata, &strlength);

1412

device->locgpsdata[3] = atof(locationstring);

1413

g_variant_unref(locationdata);

1414

} else {

1415

device->locgpsdata[3] = 0.0;

1416

}

1417

g_debug("GPS location: %2.3f, %2.3f, %2.3f, %6.0f", device->locgpsdata[0], device->locgpsdata[1], device->locgpsdata[2], device->locgpsdata[3]);

1418

}

1419

g_variant_unref(locationdata);

1420

}

1421

g_variant_unref(data);

1422

1423

return TRUE;

1424

} else {

1425

if (device->locationcaps & MMGUI_LOCATION_CAPS_3GPP) {

1426

memset(device->loc3gppdata, 0, sizeof(device->loc3gppdata));

1427

}

1428

if (device->locationcaps & MMGUI_LOCATION_CAPS_GPS) {

1429

memset(device->locgpsdata, 0, sizeof(device->locgpsdata));

1430

}

1431

1432

mmgui_module_handle_error_message(mmguicorelc, error);

1433

g_error_free(error);

1434

1435

return FALSE;

1436

}

1437

}

1438

1439

static gboolean mmgui_module_devices_enable_location(gpointer mmguicore, mmguidevice_t device, gboolean enable)

1440

{

1441

mmguicore_t mmguicorelc;

1442

moduledata_t moduledata;

1443

GVariant *properties;

1444

guint locationtypes, enabledtypes;

1445

GError *error;

1446

1447

if ((mmguicore == NULL) || (device == NULL)) return FALSE;

1448

mmguicorelc = (mmguicore_t)mmguicore;

1449

1450

if (mmguicorelc->moduledata == NULL) return FALSE;

1451

moduledata = (moduledata_t)mmguicorelc->moduledata;

1452

1453

if (!device->enabled) return FALSE;

1454

if (moduledata->locationproxy == NULL) return FALSE;

1455

1456

if ((enable) && ((device->locationcaps & MMGUI_LOCATION_CAPS_3GPP) || (device->locationcaps & MMGUI_LOCATION_CAPS_GPS))) return TRUE;

1457

if ((!enable) && ((!(device->locationcaps & MMGUI_LOCATION_CAPS_3GPP)) && (!(device->locationcaps & MMGUI_LOCATION_CAPS_GPS)))) return TRUE;

1458

1459

if (enable) {

1460

//Determine supported capabilities and turn on location engine

1461

properties = g_dbus_proxy_get_cached_property(moduledata->locationproxy, "Capabilities");

1462

if (properties != NULL) {

1463

locationtypes = g_variant_get_uint32(properties);

1464

if ((locationtypes & MODULE_INT_MODEM_LOCATION_SOURCE_3GPP_LAC_CI) || (locationtypes & MODULE_INT_MODEM_LOCATION_SOURCE_GPS_RAW)) {

1465

error = NULL;

1466

//Enable only needed capabilities

1467

enabledtypes = ((locationtypes & MODULE_INT_MODEM_LOCATION_SOURCE_3GPP_LAC_CI) | (locationtypes & MODULE_INT_MODEM_LOCATION_SOURCE_GPS_RAW));

1468

//Apply new settings

1469

g_dbus_proxy_call_sync(moduledata->locationproxy, "Setup", g_variant_new("(ub)", enabledtypes, TRUE), 0, -1, NULL, &error);

1470

//Set enabled properties

1471

if (error == NULL) {

1472

//3gpp location

1473

if (locationtypes & MODULE_INT_MODEM_LOCATION_SOURCE_3GPP_LAC_CI) {

1474

device->locationcaps |= MMGUI_LOCATION_CAPS_3GPP;

1475

}

1476

//GPS location

1477

if (locationtypes & MODULE_INT_MODEM_LOCATION_SOURCE_GPS_RAW) {

1478

device->locationcaps |= MMGUI_LOCATION_CAPS_GPS;

1479

}

1480

1481

return TRUE;

1482

} else {

1483

mmgui_module_handle_error_message(mmguicorelc, error);

1484

g_error_free(error);

1485

}

1486

}

1487

g_variant_unref(properties);

1488

}

1489

} else {

1490

error = NULL;

1491

g_dbus_proxy_call_sync(moduledata->locationproxy, "Setup", g_variant_new("(ub)", MODULE_INT_MODEM_LOCATION_SOURCE_NONE, FALSE), 0, -1, NULL, &error);

1492

if (error == NULL) {

1493

return TRUE;

1494

} else {

1495

mmgui_module_handle_error_message(mmguicorelc, error);

1496

g_error_free(error);

1497

}

1498

}

1499

1500

return FALSE;

1501

}

1502

1503

G_MODULE_EXPORT gboolean mmgui_module_devices_information(gpointer mmguicore)

1504

{

1505

mmguicore_t mmguicorelc;

1506

moduledata_t moduledata;

1507

mmguidevice_t device;

1508

GVariant *data;

1509

GError *error;

1510

gchar *blockstr;

1511

gsize strsize = 256;

1512

gint statevalue;

1513

gboolean stateflag;

1514

1515

if (mmguicore == NULL) return FALSE;

1516

mmguicorelc = (mmguicore_t)mmguicore;

1517

1518

if (mmguicorelc->moduledata == NULL) return FALSE;

1519

moduledata = (moduledata_t)mmguicorelc->moduledata;

1520

1521

if (mmguicorelc->device == NULL) return FALSE;

1522

device = mmguicorelc->device;

1523

1524

if (moduledata->modemproxy != NULL) {

1525

//Is device enabled and blocked

1526

data = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "State");

1527

if (data != NULL) {

1528

statevalue = g_variant_get_int32(data);

1529

device->enabled = mmgui_module_device_enabled_from_state(statevalue);

1530

device->blocked = mmgui_module_device_locked_from_state(statevalue);

1531

device->registered = mmgui_module_device_registered_from_state(statevalue);

1532

g_variant_unref(data);

1533

} else {

1534

device->enabled = FALSE;

1535

device->blocked = TRUE;

1536

}

1537

1538

if (device->enabled) {

1539

//Device identifier (IMEI)

1540

if (device->imei != NULL) {

1541

g_free(device->imei);

1542

device->imei = NULL;

1543

}

1544

1545

data = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "EquipmentIdentifier");

1546

if (data != NULL) {

1547

device->imei = g_strdup(g_variant_get_string(data, &strsize));

1548

g_variant_unref(data);

1549

} else {

1550

device->imei = NULL;

1551

}

1552

//Signal level

1553

data = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "SignalQuality");

1554

if (data != NULL) {

1555

g_variant_get(data, "(ub)", &statevalue, &stateflag);

1556

device->siglevel = statevalue;

1557

g_variant_unref(data);

1558

} else {

1559

device->siglevel = 0;

1560

}

1561

//Used access technology

1562

data = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "AccessTechnologies");

1563

if (data != NULL) {

1564

device->mode = mmgui_module_access_mode_translate(g_variant_get_uint32(data));

1565

g_variant_unref(data);

1566

} else {

1567

device->mode = MMGUI_DEVICE_MODE_UNKNOWN;

1568

}

1569

}

1570

}

1571

1572

if (moduledata->netproxy != NULL) {

1573

//Operator information

1574

if (device->operatorcode != NULL) {

1575

g_free(device->operatorcode);

1576

device->operatorcode = NULL;

1577

}

1578

1579

if (device->operatorname != NULL) {

1580

g_free(device->operatorname);

1581

device->operatorname = NULL;

1582

}

1583

1584

//Registration state

1585

data = g_dbus_proxy_get_cached_property(moduledata->netproxy, "RegistrationState");

1586

if (data != NULL) {

1587

device->regstatus = mmgui_module_registration_status_translate(g_variant_get_uint32(data));

1588

g_variant_unref(data);

1589

} else {

1590

device->regstatus = MMGUI_REG_STATUS_UNKNOWN;

1591

}

1592

//Operator code

1593

data = g_dbus_proxy_get_cached_property(moduledata->netproxy, "OperatorCode");

1594

if (data != NULL) {

1595

strsize = 256;

1596

device->operatorcode = g_strdup(g_variant_get_string(data, &strsize));

1597

g_variant_unref(data);

1598

} else {

1599

device->operatorcode = NULL;

1600

}

1601

//Operator name

1602

data = g_dbus_proxy_get_cached_property(moduledata->netproxy, "OperatorName");

1603

if (data != NULL) {

1604

strsize = 256;

1605

device->operatorname = g_strdup(g_variant_get_string(data, &strsize));

1606

g_variant_unref(data);

1607

} else {

1608

device->operatorname = NULL;

1609

}

1610

}

1611

1612

if (moduledata->cardproxy != NULL) {

1613

if (device->type == MMGUI_DEVICE_TYPE_GSM) {

1614

if (device->enabled) {

1615

//IMSI

1616

if (device->imsi != NULL) {

1617

g_free(device->imsi);

1618

device->imsi = NULL;

1619

}

1620

//IMSI

1621

data = g_dbus_proxy_get_cached_property(moduledata->cardproxy, "Imsi");

1622

if (data != NULL) {

1623

strsize = 256;

1624

device->imsi = g_strdup(g_variant_get_string(data, &strsize));

1625

g_variant_unref(data);

1626

} else {

1627

device->imsi = NULL;

1628

}

1629

}

1630

} else if (device->type == MMGUI_DEVICE_TYPE_CDMA) {

1631

//No IMSI in CDMA

1632

if (device->imsi != NULL) {

1633

g_free(device->imsi);

1634

device->imsi = NULL;

1635

}

1636

}

1637

}

1638

1639

//Update location

1640

mmgui_module_devices_update_location(mmguicore, device);

1641

1642

//Network time. This code makes ModemManager crash, so it commented out

1643

/*gchar *timev;

1644

1645

if (moduledata->timeproxy != NULL) {

1646

error = NULL;

1647

1648

data = g_dbus_proxy_call_sync(moduledata->timeproxy,

1649

"GetNetworkTime",

1650

NULL,

1651

0,

1652

-1,

1653

NULL,

1654

&error);

1655

1656

if ((data == NULL) && (error != NULL)) {

1657

mmgui_module_print_error_message(error);

1658

g_error_free(error);

1659

} else {

1660

g_variant_get(data, "(s)", &timev);

1661

//device->imsi = g_strdup(device->imsi);

1662

g_variant_unref(data);

1663

}

1664

}*/

1665

1666

return TRUE;

1667

}

1668

1669

G_MODULE_EXPORT gboolean mmgui_module_devices_open(gpointer mmguicore, mmguidevice_t device)

1670

{

1671

mmguicore_t mmguicorelc;

1672

moduledata_t moduledata;

1673

const gchar *simpath;

1674

GVariant *simdata;

1675

GError *error;

1676

gsize strlength;

1677

1678

if ((mmguicore == NULL) || (device == NULL)) return FALSE;

1679

mmguicorelc = (mmguicore_t)mmguicore;

1680

1681

if (mmguicorelc->moduledata == NULL) return FALSE;

1682

moduledata = (moduledata_t)mmguicorelc->moduledata;

1683

1684

if (device == NULL) return FALSE;

1685

if (device->objectpath == NULL) return FALSE;

1686

1687

error = NULL;

1688

1689

moduledata->netproxy = g_dbus_proxy_new_sync(moduledata->connection,

1690

G_DBUS_PROXY_FLAGS_NONE,

1691

NULL,

1692

"org.freedesktop.ModemManager1",

1693

device->objectpath,

1694

"org.freedesktop.ModemManager1.Modem.Modem3gpp",

1695

NULL,

1696

&error);

1697

1698

if ((moduledata->netproxy == NULL) && (error != NULL)) {

1699

device->scancaps = MMGUI_SCAN_CAPS_NONE;

1700

mmgui_module_handle_error_message(mmguicorelc, error);

1701

g_error_free(error);

1702

} else {

1703

device->scancaps = MMGUI_SCAN_CAPS_OBSERVE;

1704

moduledata->netpropsignal = g_signal_connect(moduledata->netproxy, "g-properties-changed", G_CALLBACK(mmgui_property_change_handler), mmguicore);

1705

}

1706

1707

error = NULL;

1708

1709

moduledata->modemproxy = g_dbus_proxy_new_sync(moduledata->connection,

1710

G_DBUS_PROXY_FLAGS_NONE,

1711

NULL,

1712

"org.freedesktop.ModemManager1",

1713

device->objectpath,

1714

"org.freedesktop.ModemManager1.Modem",

1715

NULL,

1716

&error);

1717

1718

if ((moduledata->modemproxy == NULL) && (error != NULL)) {

1719

mmgui_module_handle_error_message(mmguicorelc, error);

1720

g_error_free(error);

1721

} else {

1722

moduledata->statesignal = g_signal_connect(moduledata->modemproxy, "g-signal", G_CALLBACK(mmgui_signal_handler), mmguicore);

1723

moduledata->modempropsignal = g_signal_connect(moduledata->modemproxy, "g-properties-changed", G_CALLBACK(mmgui_property_change_handler), mmguicore);

1724

//Get path for SIM object

1725

simdata = g_dbus_proxy_get_cached_property(moduledata->modemproxy, "Sim");

1726

strlength = 256;

1727

simpath = g_variant_get_string(simdata, &strlength);

1728

//If SIM object exists

1729

if (simpath != NULL) {

1730

error = NULL;

1731

moduledata->cardproxy = g_dbus_proxy_new_sync(moduledata->connection,

1732

G_DBUS_PROXY_FLAGS_NONE,

1733

NULL,

1734

"org.freedesktop.ModemManager1",

1735

simpath,

1736

"org.freedesktop.ModemManager1.Sim",

1737

NULL,

1738

&error);

1739

1740

if ((moduledata->cardproxy == NULL) && (error != NULL)) {

1741

mmgui_module_handle_error_message(mmguicorelc, error);

1742

g_error_free(error);

1743

}

1744

} else {

1745

moduledata->cardproxy = NULL;

1746

}

1747

g_variant_unref(simdata);

1748

}

1749

1750

error = NULL;

1751

1752

moduledata->smsproxy = g_dbus_proxy_new_sync(moduledata->connection,

1753

G_DBUS_PROXY_FLAGS_NONE,

1754

NULL,

1755

"org.freedesktop.ModemManager1",

1756

device->objectpath,

1757

"org.freedesktop.ModemManager1.Modem.Messaging",

1758

NULL,

1759

&error);

1760

1761

if ((moduledata->smsproxy == NULL) && (error != NULL)) {

1762

device->smscaps = MMGUI_SMS_CAPS_NONE;

1763

mmgui_module_handle_error_message(mmguicorelc, error);

1764

g_error_free(error);

1765

} else {

1766

device->smscaps = MMGUI_SMS_CAPS_RECEIVE | MMGUI_SMS_CAPS_SEND;

1767

moduledata->smssignal = g_signal_connect(moduledata->smsproxy, "g-signal", G_CALLBACK(mmgui_signal_handler), mmguicore);

1768

}

1769

1770

error = NULL;

1771

1772

moduledata->ussdproxy = g_dbus_proxy_new_sync(moduledata->connection,

1773

G_DBUS_PROXY_FLAGS_NONE,

1774

NULL,

1775

"org.freedesktop.ModemManager1",

1776

device->objectpath,

1777

"org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd",

1778

NULL,

1779

&error);

1780

1781

if ((moduledata->ussdproxy == NULL) && (error != NULL)) {

1782

device->ussdcaps = MMGUI_USSD_CAPS_NONE;

1783

mmgui_module_handle_error_message(mmguicorelc, error);

1784

g_error_free(error);

1785

} else {

1786

device->ussdcaps = MMGUI_USSD_CAPS_SEND;

1787

}

1788

1789

error = NULL;

1790

1791

moduledata->locationproxy = g_dbus_proxy_new_sync(moduledata->connection,

1792

G_DBUS_PROXY_FLAGS_NONE,

1793

NULL,

1794

"org.freedesktop.ModemManager1",

1795

device->objectpath,

1796

"org.freedesktop.ModemManager1.Modem.Location",

1797

NULL,

1798

&error);

1799

1800

if ((moduledata->locationproxy == NULL) && (error != NULL)) {

1801

mmgui_module_handle_error_message(mmguicorelc, error);

1802

g_error_free(error);

1803

} else {

1804

if (mmgui_module_devices_enable_location(mmguicore, device, TRUE)) {

1805

moduledata->locationpropsignal = g_signal_connect(moduledata->locationproxy, "g-properties-changed", G_CALLBACK(mmgui_property_change_handler), mmguicore);

1806

}

1807

}

1808

1809

error = NULL;

1810

1811

moduledata->timeproxy = g_dbus_proxy_new_sync(moduledata->connection,

1812

G_DBUS_PROXY_FLAGS_NONE,

1813

NULL,

1814

"org.freedesktop.ModemManager1",

1815

device->objectpath,

1816

"org.freedesktop.ModemManager1.Modem.Time",

1817

NULL,

1818

&error);

1819

1820

if ((moduledata->timeproxy == NULL) && (error != NULL)) {

1821

mmgui_module_handle_error_message(mmguicorelc, error);

1822

g_error_free(error);

1823

} else {

1824

moduledata->timesignal = g_signal_connect(moduledata->timeproxy, "g-signal", G_CALLBACK(mmgui_signal_handler), mmguicore);

1825

}

1826

1827

error = NULL;

1828

1829

moduledata->contactsproxy = g_dbus_proxy_new_sync(moduledata->connection,

1830

G_DBUS_PROXY_FLAGS_NONE,

1831

NULL,

1832

"org.freedesktop.ModemManager1",

1833

device->objectpath,

1834

"org.freedesktop.ModemManager1.Modem.Contacts",

1835

NULL,

1836

&error);

1837

1838

if ((moduledata->contactsproxy == NULL) && (error != NULL)) {

1839

device->contactscaps = MMGUI_CONTACTS_CAPS_NONE;

1840

mmgui_module_handle_error_message(mmguicorelc, error);

1841

g_error_free(error);

1842

} else {

1843

//Test if we really have working conatacts API

1844

error = NULL;

1845

simdata = g_dbus_proxy_call_sync(moduledata->contactsproxy,

1846

"GetCount",

1847

NULL,

1848

0,

1849

-1,

1850

NULL,

1851

&error);

1852

1853

if ((error != NULL) && (simdata == NULL)) {

1854

device->contactscaps = MMGUI_CONTACTS_CAPS_NONE;

1855

mmgui_module_handle_error_message(mmguicorelc, error);

1856

g_error_free(error);

1857

} else {

1858

device->contactscaps = MMGUI_CONTACTS_CAPS_EXPORT | MMGUI_CONTACTS_CAPS_EDIT | MMGUI_CONTACTS_CAPS_EXTENDED;

1859

g_variant_unref(simdata);

1860

}

1861

}

1862

1863

//Update device information using created proxy objects

1864

mmgui_module_devices_information(mmguicore);

1865

1866

//Add fresh partial sms list

1867

moduledata->partialsms = NULL;

1868

1869

//Initialize SMS database

1870

1871

return TRUE;

1872

}

1873

1874

G_MODULE_EXPORT gboolean mmgui_module_devices_close(gpointer mmguicore)

1875

{

1876

mmguicore_t mmguicorelc;

1877

moduledata_t moduledata;

1878

GList *pslnode;

1879

GList *pslnext;

1880

gchar *pslpath;

1881

1882

if (mmguicore == NULL) return FALSE;

1883

mmguicorelc = (mmguicore_t)mmguicore;

1884

1885

if (mmguicorelc->moduledata == NULL) return FALSE;

1886

moduledata = (moduledata_t)mmguicorelc->moduledata;

1887

1888

//Close SMS database

1889

//Free resources

1890

//Change device pointer

1891

1892

//Free partial sms list

1893

if (moduledata->partialsms != NULL) {

1894

pslnode = moduledata->partialsms;

1895

while (pslnode != NULL) {

1896

pslpath = (gchar *)pslnode->data;

1897

pslnext = g_list_next(pslnode);

1898

if (pslpath) {

1899

g_free(pslpath);

1900

}

1901

pslnode = pslnext;

1902

}

1903

g_list_free(moduledata->partialsms);

1904

moduledata->partialsms = NULL;

1905

}

1906

1907

if (moduledata->cardproxy != NULL) {

1908

g_object_unref(moduledata->cardproxy);

1909

moduledata->cardproxy = NULL;

1910

}

1911

if (moduledata->netproxy != NULL) {

1912

if (g_signal_handler_is_connected(moduledata->netproxy, moduledata->netpropsignal)) {

1913

g_signal_handler_disconnect(moduledata->netproxy, moduledata->netpropsignal);

1914

}

1915

g_object_unref(moduledata->netproxy);

1916

moduledata->netproxy = NULL;

1917

}

1918

if (moduledata->modemproxy != NULL) {

1919

if (g_signal_handler_is_connected(moduledata->modemproxy, moduledata->statesignal)) {

1920

g_signal_handler_disconnect(moduledata->modemproxy, moduledata->statesignal);

1921

}

1922

if (g_signal_handler_is_connected(moduledata->modemproxy, moduledata->modempropsignal)) {

1923

g_signal_handler_disconnect(moduledata->modemproxy, moduledata->modempropsignal);

1924

}

1925

g_object_unref(moduledata->modemproxy);

1926

moduledata->modemproxy = NULL;

1927

}

1928

if (moduledata->smsproxy != NULL) {

1929

if (g_signal_handler_is_connected(moduledata->smsproxy, moduledata->smssignal)) {

1930

g_signal_handler_disconnect(moduledata->smsproxy, moduledata->smssignal);

1931

}

1932

g_object_unref(moduledata->smsproxy);

1933

moduledata->smsproxy = NULL;

1934

}

1935

if (moduledata->ussdproxy != NULL) {

1936

g_object_unref(moduledata->ussdproxy);

1937

moduledata->ussdproxy = NULL;

1938

}

1939

if (moduledata->locationproxy != NULL) {

1940

if (g_signal_handler_is_connected(moduledata->locationproxy, moduledata->locationpropsignal)) {

1941

g_signal_handler_disconnect(moduledata->locationproxy, moduledata->locationpropsignal);

1942

}

1943

g_object_unref(moduledata->locationproxy);

1944

moduledata->locationproxy = NULL;

1945

}

1946

if (moduledata->timeproxy != NULL) {

1947

if (g_signal_handler_is_connected(moduledata->timeproxy, moduledata->timesignal)) {

1948

g_signal_handler_disconnect(moduledata->timeproxy, moduledata->timesignal);

1949

}

1950

g_object_unref(moduledata->timeproxy);

1951

moduledata->timeproxy = NULL;

1952

}

1953

if (moduledata->contactsproxy != NULL) {

1954

g_object_unref(moduledata->contactsproxy);

1955

moduledata->contactsproxy = NULL;

1956

}

1957

1958

return TRUE;

1959

}

1960

1961

static gboolean mmgui_module_devices_restart_ussd(gpointer mmguicore)

1962

{

1963

mmguicore_t mmguicorelc;

1964

moduledata_t moduledata;

1965

mmguidevice_t device;

1966

GError *error;

1967

1968

if (mmguicore == NULL) return FALSE;

1969

mmguicorelc = (mmguicore_t)mmguicore;

1970

1971

if (mmguicorelc->moduledata == NULL) return FALSE;

1972

moduledata = (moduledata_t)mmguicorelc->moduledata;

1973

1974

if (mmguicorelc->device == NULL) return FALSE;

1975

device = mmguicorelc->device;

1976

1977

if (moduledata->ussdproxy != NULL) {

1978

device->ussdcaps = MMGUI_USSD_CAPS_NONE;

1979

g_object_unref(moduledata->ussdproxy);

1980

}

1981

1982

error = NULL;

1983

1984

moduledata->ussdproxy = g_dbus_proxy_new_sync(moduledata->connection,

1985

G_DBUS_PROXY_FLAGS_NONE,

1986

NULL,

1987

"org.freedesktop.ModemManager1",

1988

device->objectpath,

1989

"org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd",

1990

NULL,

1991

&error);

1992

1993

if ((moduledata->ussdproxy == NULL) && (error != NULL)) {

1994

device->ussdcaps = MMGUI_USSD_CAPS_NONE;

1995

mmgui_module_handle_error_message(mmguicorelc, error);

1996

g_error_free(error);

1997

return FALSE;

1998

} else {

1999

device->ussdcaps = MMGUI_USSD_CAPS_SEND;

2000

return TRUE;

2001

}

2002

}

2003

2004

static void mmgui_module_devices_enable_handler(GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)

2005

{

2006

mmguicore_t mmguicorelc;

2007

moduledata_t moduledata;

2008

GError *error;

2009

GVariant *data;

2010

gboolean newstate;

2011

guint32 statevalue;

2012

2013

mmguicorelc = (mmguicore_t)user_data;

2014

if (mmguicorelc == NULL) return;

2015

2016

if (mmguicorelc->moduledata == NULL) return;

2017

moduledata = (moduledata_t)mmguicorelc->moduledata;

2018

2019

error = NULL;

2020

2021

data = g_dbus_proxy_call_finish(proxy, res, &error);

2022

2023

if ((data == NULL) && (error != NULL)) {

2024

if ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable)))) {

2025

mmgui_module_handle_error_message(mmguicorelc, error);

2026

}

2027

g_error_free(error);

2028

newstate = FALSE;

2029

} else {

2030

g_variant_unref(data);

2031

newstate = mmguicorelc->device->enabled;

2032

//Update device state

2033

data = g_dbus_proxy_get_cached_property(proxy, "State");

2034

statevalue = g_variant_get_int32(data);

2035

mmguicorelc->device->enabled = mmgui_module_device_enabled_from_state(statevalue);

2036

g_variant_unref(data);

2037

//If device state changed - return TRUE

2038

if (newstate != mmguicorelc->device->enabled) {

2039

//Enable location API

2040

mmgui_module_devices_enable_location(mmguicorelc, mmguicorelc->device, TRUE);

2041

newstate = TRUE;

2042

} else {

2043

newstate = FALSE;

2044

}

2045

}

2046

2047

if (mmguicorelc->device != NULL) {

2048

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_IDLE;

2049

}

2050

2051

if ((mmguicorelc->eventcb != NULL) && ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable))))) {

2052

(mmguicorelc->eventcb)(MMGUI_EVENT_MODEM_ENABLE_RESULT, user_data, GUINT_TO_POINTER(newstate));

2053

}

2054

}

2055

2056

G_MODULE_EXPORT gboolean mmgui_module_devices_enable(gpointer mmguicore, gboolean enabled)

2057

{

2058

mmguicore_t mmguicorelc;

2059

moduledata_t moduledata;

2060

2061

if (mmguicore == NULL) return FALSE;

2062

mmguicorelc = (mmguicore_t)mmguicore;

2063

2064

if (mmguicorelc->moduledata == NULL) return FALSE;

2065

moduledata = (moduledata_t)mmguicorelc->moduledata;

2066

2067

if (moduledata->modemproxy == NULL) return FALSE;

2068

if (mmguicorelc->device == NULL) return FALSE;

2069

2070

//Device already in requested state

2071

if (mmguicorelc->device->enabled == enabled) return TRUE;

2072

2073

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_ENABLE;

2074

2075

if (moduledata->cancellable != NULL) {

2076

g_cancellable_reset(moduledata->cancellable);

2077

}

2078

2079

g_dbus_proxy_call(moduledata->modemproxy,

2080

"Enable",

2081

g_variant_new("(b)", enabled),

2082

G_DBUS_CALL_FLAGS_NONE,

2083

moduledata->timeouts[MMGUI_DEVICE_OPERATION_ENABLE],

2084

moduledata->cancellable,

2085

(GAsyncReadyCallback)mmgui_module_devices_enable_handler,

2086

mmguicore);

2087

2088

return TRUE;

2089

}

2090

2091

static time_t mmgui_module_str_to_time(const gchar *str)

2092

{

2093

guint i, len;

2094

gchar strbuf[3];

2095

struct tm btime;

2096

time_t timestamp;

2097

gint *fields[] = {&btime.tm_year, &btime.tm_mon, &btime.tm_mday,

2098

&btime.tm_hour, &btime.tm_min, &btime.tm_sec};

2099

2100

timestamp = time(NULL);

2101

2102

if (str == NULL) return timestamp;

2103

2104

len = strlen(str);

2105

2106

if (len > 12) {

2107

if (str[12] == '+') {

2108

//v.0.4.998 timestamp format

2109

for (i=0; i<6; i++) {

2110

strncpy(strbuf, str+(i*2), 2);

2111

strbuf[2] = '\0';

2112

*fields[i] = atoi(strbuf);

2113

}

2114

} else if (str[8] == ',') {

2115

//v.0.5.2 timestamp format

2116

for (i=0; i<6; i++) {

2117

strncpy(strbuf, str+(i*3), 2);

2118

strbuf[2] = '\0';

2119

*fields[i] = atoi(strbuf);

2120

}

2121

}

2122

btime.tm_year += 100;

2123

btime.tm_mon -= 1;

2124

timestamp = mktime(&btime);

2125

}

2126

2127

return timestamp;

2128

}

2129

2130

static mmgui_sms_message_t mmgui_module_sms_retrieve(mmguicore_t mmguicore, const gchar *smspath/*, gboolean listpartial*/)

2131

{

2132

moduledata_t moduledata;

2133

mmgui_sms_message_t message;

2134

GDBusProxy *smsproxy;

2135

GError *error;

2136

GVariant *value;

2137

gsize strlength;

2138

const gchar *valuestr;

2139

guint index, state;

2140

gboolean gottext;

2141

2142

if ((mmguicore == NULL) || (smspath == NULL)) return NULL;

2143

if (mmguicore->moduledata == NULL) return NULL;

2144

2145

moduledata = (moduledata_t)mmguicore->moduledata;

2146

2147

error = NULL;

2148

2149

smsproxy = g_dbus_proxy_new_sync(moduledata->connection,

2150

G_DBUS_PROXY_FLAGS_NONE,

2151

NULL,

2152

"org.freedesktop.ModemManager1",

2153

smspath,

2154

"org.freedesktop.ModemManager1.Sms",

2155

NULL,

2156

&error);

2157

2158

if ((smsproxy == NULL) && (error != NULL)) {

2159

mmgui_module_handle_error_message(mmguicore, error);

2160

g_error_free(error);

2161

//g_object_unref(smsproxy);

2162

return NULL;

2163

}

2164

2165

//SMS message state

2166

value = g_dbus_proxy_get_cached_property(smsproxy, "State");

2167

if (value != NULL) {

2168

state = g_variant_get_uint32(value);

2169

if (state != MODULE_INT_SMS_STATE_RECEIVED) {

2170

/*//Message is not fully received - skip it and add to list if needed

2171

if ((state == MODULE_INT_SMS_STATE_RECEIVING) && (listpartial)) {

2172

moduledata->partialsms = g_list_prepend(moduledata->partialsms, g_strdup(smspath));

2173

}*/

2174

g_variant_unref(value);

2175

g_object_unref(smsproxy);

2176

return NULL;

2177

}

2178

g_variant_unref(value);

2179

} else {

2180

//Something strange with this message - skip it

2181

g_object_unref(smsproxy);

2182

return NULL;

2183

}

2184

2185

//SMS message type

2186

value = g_dbus_proxy_get_cached_property(smsproxy, "PduType");

2187

if (value != NULL) {

2188

state = g_variant_get_uint32(value);

2189

if ((state == MODULE_INT_PDU_TYPE_UNKNOWN) || (state == MODULE_INT_PDU_TYPE_SUBMIT)) {

2190

//Only delivered messages and status reports needed this moment - maybe remove other?

2191

//TODO: remove message

2192

g_variant_unref(value);

2193

g_object_unref(smsproxy);

2194

return NULL;

2195

}

2196

g_variant_unref(value);

2197

} else {

2198

//Something strange with this message - skip it

2199

g_object_unref(smsproxy);

2200

return NULL;

2201

}

2202

2203

message = mmgui_smsdb_message_create();

2204

//Sender number

2205

value = g_dbus_proxy_get_cached_property(smsproxy, "Number");

2206

if (value != NULL) {

2207

strlength = 256;

2208

valuestr = g_variant_get_string(value, &strlength);

2209

mmgui_smsdb_message_set_number(message, valuestr);

2210

g_debug("SMS number: %s\n", valuestr);

2211

g_variant_unref(value);

2212

} else {

2213

mmgui_smsdb_message_set_number(message, _("Unknown"));

2214

}

2215

//Service center number

2216

value = g_dbus_proxy_get_cached_property(smsproxy, "SMSC");

2217

if (value != NULL) {

2218

strlength = 256;

2219

valuestr = g_variant_get_string(value, &strlength);

2220

mmgui_smsdb_message_set_service_number(message, valuestr);

2221

g_debug("SMS service number: %s\n", valuestr);

2222

g_variant_unref(value);

2223

} else {

2224

mmgui_smsdb_message_set_service_number(message, _("Unknown"));

2225

}

2226

//Decoded message text

2227

gottext = FALSE;

2228

value = g_dbus_proxy_get_cached_property(smsproxy, "Text");

2229

if (value != NULL) {

2230

strlength = 256*160;

2231

valuestr = g_variant_get_string(value, &strlength);

2232

g_debug("SMS text: %s\n", valuestr);

2233

mmgui_smsdb_message_set_text(message, valuestr, FALSE);

2234

gottext = TRUE;

2235

g_variant_unref(value);

2236

} else {

2237

value = g_dbus_proxy_get_cached_property(smsproxy, "Data");

2238

if (value != NULL) {

2239

strlength = g_variant_get_size(value);

2240

if (strlength > 0) {

2241

valuestr = g_variant_get_data(value);

2242

mmgui_smsdb_message_set_binary(message, TRUE);

2243

mmgui_smsdb_message_set_data(message, valuestr, strlength, FALSE);

2244

gottext = TRUE;

2245

}

2246

g_variant_unref(value);

2247

}

2248

}

2249

//Message timestamp

2250

value = g_dbus_proxy_get_cached_property(smsproxy, "Timestamp");

2251

if (value != NULL) {

2252

strlength = 256;

2253

valuestr = g_variant_get_string(value, &strlength);

2254

mmgui_smsdb_message_set_timestamp(message, mmgui_module_str_to_time(valuestr));

2255

g_debug("SMS timestamp: %lu\n", (gulong)message->timestamp);

2256

g_variant_unref(value);

2257

}

2258

//Message index

2259

index = mmgui_module_get_object_path_index(smspath);

2260

//Return message

2261

if (!gottext) {

2262

//Message has no text - skip it

2263

mmgui_smsdb_message_free(message);

2264

return NULL;

2265

} else {

2266

//Return message

2267

mmgui_smsdb_message_set_identifier(message, index, FALSE);

2268

g_debug("SMS index: %u\n", index);

2269

return message;

2270

}

2271

}

2272

2273

static gint mmgui_module_sms_get_id(mmguicore_t mmguicore, const gchar *smspath)

2274

{

2275

moduledata_t moduledata;

2276

GDBusProxy *smsproxy;

2277

GError *error;

2278

GVariant *value;

2279

gint state;

2280

2281

if ((mmguicore == NULL) || (smspath == NULL)) return -1;

2282

if (mmguicore->moduledata == NULL) return -1;

2283

2284

moduledata = (moduledata_t)mmguicore->moduledata;

2285

2286

error = NULL;

2287

2288

smsproxy = g_dbus_proxy_new_sync(moduledata->connection,

2289

G_DBUS_PROXY_FLAGS_NONE,

2290

NULL,

2291

"org.freedesktop.ModemManager1",

2292

smspath,

2293

"org.freedesktop.ModemManager1.Sms",

2294

NULL,

2295

&error);

2296

2297

if ((smsproxy == NULL) && (error != NULL)) {

2298

mmgui_module_handle_error_message(mmguicore, error);

2299

g_error_free(error);

2300

return -1;

2301

}

2302

//SMS message state

2303

value = g_dbus_proxy_get_cached_property(smsproxy, "State");

2304

if (value != NULL) {

2305

state = g_variant_get_uint32(value);

2306

if (state == MODULE_INT_SMS_STATE_RECEIVED) {

2307

g_variant_unref(value);

2308

g_object_unref(smsproxy);

2309

return mmgui_module_get_object_path_index(smspath);

2310

} else {

2311

g_variant_unref(value);

2312

g_object_unref(smsproxy);

2313

return -1;

2314

}

2315

g_variant_unref(value);

2316

} else {

2317

//Something strange with this message

2318

g_object_unref(smsproxy);

2319

return -1;

2320

}

2321

}

2322

2323

G_MODULE_EXPORT guint mmgui_module_sms_enum(gpointer mmguicore, GSList **smslist)

2324

{

2325

mmguicore_t mmguicorelc;

2326

moduledata_t moduledata;

2327

GError *error;

2328

GVariant *messages;

2329

guint msgnum;

2330

GVariantIter miterl1, miterl2;

2331

GVariant *mnodel1, *mnodel2;

2332

2333

gsize strlength;

2334

const gchar *smspath;

2335

2336

mmgui_sms_message_t message;

2337

2338

if ((mmguicore == NULL) || (smslist == NULL)) return 0;

2339

mmguicorelc = (mmguicore_t)mmguicore;

2340

2341

if (mmguicorelc->moduledata == NULL) return 0;

2342

moduledata = (moduledata_t)mmguicorelc->moduledata;

2343

2344

if (moduledata->smsproxy == NULL) return 0;

2345

if (mmguicorelc->device == NULL) return 0;

2346

if (!mmguicorelc->device->enabled) return 0;

2347

if (!(mmguicorelc->device->smscaps & MMGUI_SMS_CAPS_RECEIVE)) return 0;

2348

2349

error = NULL;

2350

2351

messages = g_dbus_proxy_call_sync(moduledata->smsproxy,

2352

"List",

2353

NULL,

2354

0,

2355

-1,

2356

NULL,

2357

&error);

2358

2359

if ((messages == NULL) && (error != NULL)) {

2360

mmgui_module_handle_error_message(mmguicorelc, error);

2361

g_error_free(error);

2362

return 0;

2363

}

2364

2365

msgnum = 0;

2366

2367

g_variant_iter_init(&miterl1, messages);

2368

while ((mnodel1 = g_variant_iter_next_value(&miterl1)) != NULL) {

2369

g_variant_iter_init(&miterl2, mnodel1);

2370

while ((mnodel2 = g_variant_iter_next_value(&miterl2)) != NULL) {

2371

strlength = 256;

2372

smspath = g_variant_get_string(mnodel2, &strlength);

2373

g_debug("SMS message object path: %s\n", smspath);

2374

if (smspath != NULL) {

2375

message = mmgui_module_sms_retrieve(mmguicorelc, smspath);

2376

if (message != NULL) {

2377

*smslist = g_slist_prepend(*smslist, message);

2378

msgnum++;

2379

}

2380

}

2381

g_variant_unref(mnodel2);

2382

}

2383

g_variant_unref(mnodel1);

2384

}

2385

2386

g_variant_unref(messages);

2387

2388

return msgnum;

2389

}

2390

2391

G_MODULE_EXPORT mmgui_sms_message_t mmgui_module_sms_get(gpointer mmguicore, guint index)

2392

{

2393

mmguicore_t mmguicorelc;

2394

moduledata_t moduledata;

2395

gchar *smspath;

2396

mmgui_sms_message_t message;

2397

2398

if (mmguicore == NULL) return NULL;

2399

mmguicorelc = (mmguicore_t)mmguicore;

2400

2401

if (mmguicorelc->moduledata == NULL) return NULL;

2402

moduledata = (moduledata_t)mmguicorelc->moduledata;

2403

2404

if (mmguicorelc->device == NULL) return NULL;

2405

if (!mmguicorelc->device->enabled) return NULL;

2406

if (!(mmguicorelc->device->smscaps & MMGUI_SMS_CAPS_RECEIVE)) return NULL;

2407

2408

smspath = g_strdup_printf("/org/freedesktop/ModemManager1/SMS/%u", index);

2409

2410

message = mmgui_module_sms_retrieve(mmguicorelc, smspath);

2411

2412

g_free(smspath);

2413

2414

return message;

2415

}

2416

2417

G_MODULE_EXPORT gboolean mmgui_module_sms_delete(gpointer mmguicore, guint index)

2418

{

2419

mmguicore_t mmguicorelc;

2420

moduledata_t moduledata;

2421

gchar *smspath;

2422

GError *error;

2423

2424

if (mmguicore == NULL) return FALSE;

2425

mmguicorelc = (mmguicore_t)mmguicore;

2426

2427

if (mmguicorelc->moduledata == NULL) return FALSE;

2428

moduledata = (moduledata_t)mmguicorelc->moduledata;

2429

2430

if (moduledata->smsproxy == NULL) return FALSE;

2431

if (mmguicorelc->device == NULL) return FALSE;

2432

if (!mmguicorelc->device->enabled) return FALSE;

2433

if (!(mmguicorelc->device->smscaps & MMGUI_SMS_CAPS_RECEIVE)) return FALSE;

2434

2435

smspath = g_strdup_printf("/org/freedesktop/ModemManager1/SMS/%u", index);

2436

2437

error = NULL;

2438

2439

g_dbus_proxy_call_sync(moduledata->smsproxy,

2440

"Delete",

2441

g_variant_new("(o)", smspath),

2442

0,

2443

-1,

2444

NULL,

2445

&error);

2446

2447

if (error != NULL) {

2448

mmgui_module_handle_error_message(mmguicorelc, error);

2449

g_error_free(error);

2450

g_free(smspath);

2451

return FALSE;

2452

}

2453

2454

g_free(smspath);

2455

2456

return TRUE;

2457

}

2458

2459

static void mmgui_module_sms_send_handler(GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)

2460

{

2461

mmguicore_t mmguicorelc;

2462

moduledata_t moduledata;

2463

GError *error;

2464

gboolean sent;

2465

const gchar *smspath;

2466

2467

if (user_data == NULL) return;

2468

mmguicorelc = (mmguicore_t)user_data;

2469

2470

if (mmguicorelc->moduledata == NULL) return;

2471

moduledata = (moduledata_t)mmguicorelc->moduledata;

2472

2473

error = NULL;

2474

2475

g_dbus_proxy_call_finish(proxy, res, &error);

2476

2477

//Operation result

2478

if (error != NULL) {

2479

if ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable)))) {

2480

mmgui_module_handle_error_message(mmguicorelc, error);

2481

}

2482

g_error_free(error);

2483

sent = FALSE;

2484

} else {

2485

sent = TRUE;

2486

}

2487

2488

smspath = g_dbus_proxy_get_object_path(proxy);

2489

if (smspath != NULL) {

2490

error = NULL;

2491

//Remove message from storage

2492

g_dbus_proxy_call_sync(moduledata->smsproxy,

2493

"Delete",

2494

g_variant_new("(o)", smspath),

2495

0,

2496

-1,

2497

NULL,

2498

&error);

2499

if (error != NULL) {

2500

mmgui_module_handle_error_message(mmguicorelc, error);

2501

g_error_free(error);

2502

}

2503

}

2504

2505

if (mmguicorelc->device != NULL) {

2506

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_IDLE;

2507

}

2508

2509

if ((mmguicorelc->eventcb != NULL) && ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable))))) {

2510

(mmguicorelc->eventcb)(MMGUI_EVENT_SMS_SENT, user_data, GUINT_TO_POINTER(sent));

2511

}

2512

}

2513

2514

G_MODULE_EXPORT gboolean mmgui_module_sms_send(gpointer mmguicore, gchar* number, gchar *text)

2515

{

2516

mmguicore_t mmguicorelc;

2517

moduledata_t moduledata;

2518

GVariantBuilder *builder;

2519

GVariant *array, *message, *smspathv;

2520

GError *error;

2521

gsize strlength;

2522

gchar *smspath;

2523

GDBusProxy *messageproxy;

2524

2525

if ((number == NULL) || (text == NULL)) return FALSE;

2526

2527

if (mmguicore == NULL) return FALSE;

2528

mmguicorelc = (mmguicore_t)mmguicore;

2529

2530

if (mmguicorelc->moduledata == NULL) return FALSE;

2531

moduledata = (moduledata_t)mmguicorelc->moduledata;

2532

2533

if (moduledata->smsproxy == NULL) return FALSE;

2534

if (mmguicorelc->device == NULL) return FALSE;

2535

if (!mmguicorelc->device->enabled) return FALSE;

2536

if (!(mmguicorelc->device->smscaps & MMGUI_SMS_CAPS_SEND)) return FALSE;

2537

2538

builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);

2539

g_variant_builder_add_parsed(builder, "{'number', <%s>}", number);

2540

g_variant_builder_add_parsed(builder, "{'text', <%s>}", text);

2541

array = g_variant_builder_end(builder);

2542

2543

builder = g_variant_builder_new(G_VARIANT_TYPE_TUPLE);

2544

g_variant_builder_add_value(builder, array);

2545

message = g_variant_builder_end(builder);

2546

2547

error = NULL;

2548

2549

//Create new message

2550

smspathv = g_dbus_proxy_call_sync(moduledata->smsproxy,

2551

"Create",

2552

message,

2553

0,

2554

-1,

2555

NULL,

2556

&error);

2557

2558

if ((smspathv == NULL) && (error != NULL)) {

2559

mmgui_module_handle_error_message(mmguicorelc, error);

2560

g_error_free(error);

2561

return FALSE;

2562

}

2563

2564

//Created SMS object path

2565

g_variant_get(smspathv, "(o)", &smspath);

2566

if (smspath == NULL) {

2567

g_debug("Failed to obtain object path for saved SMS message\n");

2568

return FALSE;

2569

}

2570

2571

error = NULL;

2572

2573

//Create message proxy

2574

messageproxy = g_dbus_proxy_new_sync(moduledata->connection,

2575

G_DBUS_PROXY_FLAGS_NONE,

2576

NULL,

2577

"org.freedesktop.ModemManager1",

2578

smspath,

2579

"org.freedesktop.ModemManager1.Sms",

2580

NULL,

2581

&error);

2582

2583

if ((messageproxy == NULL) && (error != NULL)) {

2584

mmgui_module_handle_error_message(mmguicorelc, error);

2585

g_error_free(error);

2586

g_free(smspath);

2587

return FALSE;

2588

}

2589

2590

g_free(smspath);

2591

2592

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_SEND_SMS;

2593

2594

if (moduledata->cancellable != NULL) {

2595

g_cancellable_reset(moduledata->cancellable);

2596

}

2597

2598

//Send message

2599

g_dbus_proxy_call(messageproxy,

2600

"Send",

2601

NULL,

2602

G_DBUS_CALL_FLAGS_NONE,

2603

moduledata->timeouts[MMGUI_DEVICE_OPERATION_SEND_SMS],

2604

moduledata->cancellable,

2605

(GAsyncReadyCallback)mmgui_module_sms_send_handler,

2606

mmguicore);

2607

2608

return TRUE;

2609

}

2610

2611

G_MODULE_EXPORT gboolean mmgui_module_ussd_cancel_session(gpointer mmguicore)

2612

{

2613

mmguicore_t mmguicorelc;

2614

moduledata_t moduledata;

2615

GError *error;

2616

2617

if (mmguicore == NULL) return FALSE;

2618

mmguicorelc = (mmguicore_t)mmguicore;

2619

2620

if (mmguicorelc->moduledata == NULL) return FALSE;

2621

moduledata = (moduledata_t)mmguicorelc->moduledata;

2622

2623

if (moduledata->ussdproxy == NULL) return FALSE;

2624

if (mmguicorelc->device == NULL) return FALSE;

2625

if (!mmguicorelc->device->enabled) return FALSE;

2626

if (!(mmguicorelc->device->ussdcaps & MMGUI_USSD_CAPS_SEND)) return FALSE;

2627

2628

error = NULL;

2629

2630

g_dbus_proxy_call_sync(moduledata->ussdproxy,

2631

"Cancel",

2632

NULL,

2633

0,

2634

-1,

2635

NULL,

2636

&error);

2637

2638

if (error != NULL) {

2639

mmgui_module_handle_error_message(mmguicorelc, error);

2640

g_error_free(error);

2641

return FALSE;

2642

}

2643

2644

return TRUE;

2645

}

2646

2647

G_MODULE_EXPORT enum _mmgui_ussd_state mmgui_module_ussd_get_state(gpointer mmguicore)

2648

{

2649

mmguicore_t mmguicorelc;

2650

moduledata_t moduledata;

2651

GVariant *session;

2652

guint state;

2653

enum _mmgui_ussd_state stateid;

2654

2655

stateid = MMGUI_USSD_STATE_UNKNOWN;

2656

2657

if (mmguicore == NULL) return stateid;

2658

mmguicorelc = (mmguicore_t)mmguicore;

2659

2660

if (mmguicorelc->moduledata == NULL) return stateid;

2661

moduledata = (moduledata_t)mmguicorelc->moduledata;

2662

2663

if (moduledata->ussdproxy == NULL) return stateid;

2664

if (mmguicorelc->device == NULL) return stateid;

2665

if (!mmguicorelc->device->enabled) return stateid;

2666

if (!(mmguicorelc->device->ussdcaps & MMGUI_USSD_CAPS_SEND)) return stateid;

2667

2668

session = g_dbus_proxy_get_cached_property(moduledata->ussdproxy, "State");

2669

2670

if (session == NULL) return stateid;

2671

2672

state = g_variant_get_uint32(session);

2673

2674

switch (state) {

2675

case MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_UNKNOWN:

2676

stateid = MMGUI_USSD_STATE_UNKNOWN;

2677

break;

2678

case MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_IDLE:

2679

stateid = MMGUI_USSD_STATE_IDLE;

2680

break;

2681

case MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_ACTIVE:

2682

stateid = MMGUI_USSD_STATE_ACTIVE;

2683

break;

2684

case MODULE_INT_MODEM_3GPP_USSD_SESSION_STATE_USER_RESPONSE:

2685

stateid = MMGUI_USSD_STATE_USER_RESPONSE;

2686

break;

2687

default:

2688

stateid = MMGUI_USSD_STATE_UNKNOWN;

2689

break;

2690

}

2691

2692

g_variant_unref(session);

2693

2694

return stateid;

2695

}

2696

2697

static void mmgui_module_ussd_send_handler(GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)

2698

{

2699

mmguicore_t mmguicorelc;

2700

moduledata_t moduledata;

2701

GError *error;

2702

GVariant *result;

2703

gchar *answer;

2704

2705

mmguicorelc = (mmguicore_t)user_data;

2706

if (mmguicorelc == NULL) return;

2707

2708

if (mmguicorelc->moduledata == NULL) return;

2709

moduledata = (moduledata_t)mmguicorelc->moduledata;

2710

2711

error = NULL;

2712

answer = NULL;

2713

2714

result = g_dbus_proxy_call_finish(proxy, res, &error);

2715

2716

if ((result == NULL) && (error != NULL)) {

2717

/*For some reason after timeout ussd does not work - restart it*/

2718

mmgui_module_devices_restart_ussd(mmguicorelc);

2719

if ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable)))) {

2720

mmgui_module_handle_error_message(mmguicorelc, error);

2721

}

2722

g_error_free(error);

2723

} else {

2724

g_variant_get(result, "(s)", &answer);

2725

answer = g_strdup(answer);

2726

g_variant_unref(result);

2727

}

2728

2729

if (mmguicorelc->device != NULL) {

2730

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_IDLE;

2731

}

2732

2733

if ((mmguicorelc->eventcb != NULL) && ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable))))) {

2734

(mmguicorelc->eventcb)(MMGUI_EVENT_USSD_RESULT, user_data, answer);

2735

}

2736

}

2737

2738

G_MODULE_EXPORT gboolean mmgui_module_ussd_send(gpointer mmguicore, gchar *request, enum _mmgui_ussd_validation validationid)

2739

{

2740

mmguicore_t mmguicorelc;

2741

moduledata_t moduledata;

2742

enum _mmgui_ussd_state sessionstate;

2743

GVariant *ussdreq;

2744

gchar *command;

2745

2746

if ((mmguicore == NULL) || (request == NULL)) return FALSE;

2747

mmguicorelc = (mmguicore_t)mmguicore;

2748

2749

if (mmguicorelc->moduledata == NULL) return FALSE;

2750

moduledata = (moduledata_t)mmguicorelc->moduledata;

2751

2752

if (moduledata->ussdproxy == NULL) return FALSE;

2753

if (mmguicorelc->device == NULL) return FALSE;

2754

if (!mmguicorelc->device->enabled) return FALSE;

2755

if (!(mmguicorelc->device->ussdcaps & MMGUI_USSD_CAPS_SEND)) return FALSE;

2756

2757

sessionstate = mmgui_module_ussd_get_state(mmguicore);

2758

2759

if ((sessionstate == MMGUI_USSD_STATE_UNKNOWN) ||

2760

(sessionstate == MMGUI_USSD_STATE_ACTIVE)) {

2761

mmgui_module_ussd_cancel_session(mmguicore);

2762

}

2763

2764

ussdreq = g_variant_new("(s)", request);

2765

2766

if (sessionstate == MMGUI_USSD_STATE_IDLE) {

2767

command = "Initiate";

2768

} else if (sessionstate == MMGUI_USSD_STATE_USER_RESPONSE) {

2769

if (validationid == MMGUI_USSD_VALIDATION_REQUEST) {

2770

mmgui_module_ussd_cancel_session(mmguicore);

2771

command = "Initiate";

2772

} else {

2773

command = "Respond";

2774

}

2775

}

2776

2777

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_SEND_USSD;

2778

2779

if (moduledata->cancellable != NULL) {

2780

g_cancellable_reset(moduledata->cancellable);

2781

}

2782

2783

g_dbus_proxy_call(moduledata->ussdproxy,

2784

command,

2785

ussdreq,

2786

G_DBUS_CALL_FLAGS_NONE,

2787

moduledata->timeouts[MMGUI_DEVICE_OPERATION_SEND_USSD],

2788

moduledata->cancellable,

2789

(GAsyncReadyCallback)mmgui_module_ussd_send_handler,

2790

mmguicore);

2791

2792

return TRUE;

2793

}

2794

2795

static mmgui_scanned_network_t mmgui_module_network_retrieve(GVariant *networkv)

2796

{

2797

mmgui_scanned_network_t network;

2798

GVariant *value;

2799

gsize strlength;

2800

const gchar *valuestr;

2801

guint i;

2802

2803

if (networkv == NULL) return NULL;

2804

2805

network = g_new0(struct _mmgui_scanned_network, 1);

2806

//Mobile operator code (MCCMNC)

2807

value = g_variant_lookup_value(networkv, "operator-code", G_VARIANT_TYPE_STRING);

2808

if (value != NULL) {

2809

strlength = 256;

2810

valuestr = g_variant_get_string(value, &strlength);

2811

network->operator_num = atoi(valuestr);

2812

g_variant_unref(value);

2813

} else {

2814

network->operator_num = 0;

2815

}

2816

//Network access technology

2817

value = g_variant_lookup_value(networkv, "access-technology", G_VARIANT_TYPE_UINT32);

2818

if (value != NULL) {

2819

network->access_tech = mmgui_module_access_technology_translate(g_variant_get_uint32(value));

2820

g_variant_unref(value);

2821

} else {

2822

network->access_tech = MMGUI_ACCESS_TECH_GSM;

2823

}

2824

//Long-format name of operator

2825

value = g_variant_lookup_value(networkv, "operator-long", G_VARIANT_TYPE_STRING);

2826

if (value != NULL) {

2827

strlength = 256;

2828

valuestr = g_variant_get_string(value, &strlength);

2829

network->operator_long = g_strdup(valuestr);

2830

g_variant_unref(value);

2831

} else {

2832

network->operator_long = g_strdup(_("Unknown"));

2833

}

2834

//Short-format name of operator

2835

value = g_variant_lookup_value(networkv, "operator-short", G_VARIANT_TYPE_STRING);

2836

if (value != NULL) {

2837

strlength = 256;

2838

valuestr = g_variant_get_string(value, &strlength);

2839

network->operator_short = g_strdup(valuestr);

2840

g_variant_unref(value);

2841

} else {

2842

network->operator_short = g_strdup(_("Unknown"));

2843

}

2844

//Network availability status (this is a critical parameter, so entry will be skipped if value is unknown)

2845

value = g_variant_lookup_value(networkv, "status", G_VARIANT_TYPE_UINT32);

2846

if (value != NULL) {

2847

network->status = mmgui_module_network_availability_status_translate(g_variant_get_uint32(value));

2848

g_variant_unref(value);

2849

return network;

2850

} else {

2851

if (network->operator_long != NULL) g_free(network->operator_long);

2852

if (network->operator_short != NULL) g_free(network->operator_short);

2853

g_free(network);

2854

return NULL;

2855

}

2856

}

2857

2858

static void mmgui_module_networks_scan_handler(GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)

2859

{

2860

mmguicore_t mmguicorelc;

2861

moduledata_t moduledata;

2862

GError *error;

2863

GVariant *result;

2864

GSList *networks;

2865

GVariantIter niterl1, niterl2, niterl3;

2866

GVariant *nnodel1, *nnodel2, *nnodel3;

2867

mmgui_scanned_network_t network;

2868

2869

mmguicorelc = (mmguicore_t)user_data;

2870

if (mmguicorelc == NULL) return;

2871

2872

if (mmguicorelc->moduledata == NULL) return;

2873

moduledata = (moduledata_t)mmguicorelc->moduledata;

2874

2875

error = NULL;

2876

networks = NULL;

2877

2878

result = g_dbus_proxy_call_finish(proxy, res, &error);

2879

2880

if ((result == NULL) && (error != NULL)) {

2881

if ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable)))) {

2882

mmgui_module_handle_error_message(mmguicorelc, error);

2883

}

2884

g_error_free(error);

2885

} else {

2886

g_variant_iter_init(&niterl1, result);

2887

while ((nnodel1 = g_variant_iter_next_value(&niterl1)) != NULL) {

2888

g_variant_iter_init(&niterl2, nnodel1);

2889

while ((nnodel2 = g_variant_iter_next_value(&niterl2)) != NULL) {

2890

network = mmgui_module_network_retrieve(nnodel2);

2891

if (network != NULL) {

2892

networks = g_slist_prepend(networks, network);

2893

}

2894

g_variant_unref(nnodel2);

2895

}

2896

g_variant_unref(nnodel1);

2897

}

2898

g_variant_unref(result);

2899

}

2900

2901

if (mmguicorelc->device != NULL) {

2902

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_IDLE;

2903

}

2904

2905

if ((mmguicorelc->eventcb != NULL) && ((moduledata->cancellable == NULL) || ((moduledata->cancellable != NULL) && (!g_cancellable_is_cancelled(moduledata->cancellable))))) {

2906

(mmguicorelc->eventcb)(MMGUI_EVENT_SCAN_RESULT, user_data, networks);

2907

}

2908

}

2909

2910

G_MODULE_EXPORT gboolean mmgui_module_networks_scan(gpointer mmguicore)

2911

{

2912

mmguicore_t mmguicorelc;

2913

moduledata_t moduledata;

2914

2915

if (mmguicore == NULL) return FALSE;

2916

mmguicorelc = (mmguicore_t)mmguicore;

2917

2918

if (mmguicorelc->moduledata == NULL) return FALSE;

2919

moduledata = (moduledata_t)mmguicorelc->moduledata;

2920

2921

if (moduledata->netproxy == NULL) return FALSE;

2922

if (mmguicorelc->device == NULL) return FALSE;

2923

if (!mmguicorelc->device->enabled) return FALSE;

2924

if (!(mmguicorelc->device->scancaps & MMGUI_SCAN_CAPS_OBSERVE)) return FALSE;

2925

2926

mmguicorelc->device->operation = MMGUI_DEVICE_OPERATION_SCAN;

2927

2928

if (moduledata->cancellable != NULL) {

2929

g_cancellable_reset(moduledata->cancellable);

2930

}

2931

2932

g_dbus_proxy_call(moduledata->netproxy,

2933

"Scan",

2934

NULL,

2935

G_DBUS_CALL_FLAGS_NONE,

2936

moduledata->timeouts[MMGUI_DEVICE_OPERATION_SCAN],

2937

moduledata->cancellable,

2938

(GAsyncReadyCallback)mmgui_module_networks_scan_handler,

2939

mmguicore);

2940

2941

return TRUE;

2942

}

2943

2944

static mmgui_contact_t mmgui_module_contact_retrieve(GVariant *contactv)

2945

{

2946

mmgui_contact_t contact;

2947

GVariant *value;

2948

gsize strlength;

2949

const gchar *valuestr;

2950

2951

if (contactv == NULL) return NULL;

2952

2953

contact = g_new0(struct _mmgui_contact, 1);

2954

//Full name of the contact

2955

value = g_variant_lookup_value(contactv, "name", G_VARIANT_TYPE_STRING);

2956

if (value != NULL) {

2957

strlength = 256;

2958

valuestr = g_variant_get_string(value, &strlength);

2959

contact->name = g_strdup(valuestr);

2960

g_variant_unref(value);

2961

} else {

2962

contact->name = g_strdup(_("Unknown"));

2963

}

2964

//Telephone number

2965

value = g_variant_lookup_value(contactv, "number", G_VARIANT_TYPE_STRING);

2966

if (value != NULL) {

2967

strlength = 256;

2968

valuestr = g_variant_get_string(value, &strlength);

2969

contact->number = g_strdup(valuestr);

2970

g_variant_unref(value);

2971

} else {

2972

contact->number = g_strdup(_("Unknown"));

2973

}

2974

//Email address

2975

value = g_variant_lookup_value(contactv, "email", G_VARIANT_TYPE_STRING);

2976

if (value != NULL) {

2977

strlength = 256;

2978

valuestr = g_variant_get_string(value, &strlength);

2979

contact->email = g_strdup(valuestr);

2980

g_variant_unref(value);

2981

} else {

2982

contact->email = g_strdup(_("Unknown"));

2983

}

2984

//Group this contact belongs to

2985

value = g_variant_lookup_value(contactv, "group", G_VARIANT_TYPE_STRING);

2986

if (value != NULL) {

2987

strlength = 256;

2988

valuestr = g_variant_get_string(value, &strlength);

2989

contact->group = g_strdup(valuestr);

2990

g_variant_unref(value);

2991

} else {

2992

contact->group = g_strdup(_("Unknown"));

2993

}

2994

//Additional contact name

2995

value = g_variant_lookup_value(contactv, "name2", G_VARIANT_TYPE_STRING);

2996

if (value != NULL) {

2997

strlength = 256;

2998

valuestr = g_variant_get_string(value, &strlength);

2999

contact->name2 = g_strdup(valuestr);

3000

g_variant_unref(value);

3001

} else {

3002

contact->name2 = g_strdup(_("Unknown"));

3003

}

3004

//Additional contact telephone number

3005

value = g_variant_lookup_value(contactv, "number2", G_VARIANT_TYPE_STRING);

3006

if (value != NULL) {

3007

strlength = 256;

3008

valuestr = g_variant_get_string(value, &strlength);

3009

contact->number2 = g_strdup(valuestr);

3010

g_variant_unref(value);

3011

} else {

3012

contact->number2 = g_strdup(_("Unknown"));

3013

}

3014

//Boolean flag to specify whether this entry is hidden or not

3015

value = g_variant_lookup_value(contactv, "hidden", G_VARIANT_TYPE_BOOLEAN);

3016

if (value != NULL) {

3017

contact->hidden = g_variant_get_boolean(value);

3018

g_variant_unref(value);

3019

} else {

3020

contact->hidden = FALSE;

3021

}

3022

//Phonebook in which the contact is stored

3023

value = g_variant_lookup_value(contactv, "storage", G_VARIANT_TYPE_UINT32);

3024

if (value != NULL) {

3025

contact->storage = g_variant_get_uint32(value);

3026

g_variant_unref(value);

3027

} else {

3028

contact->storage = FALSE;

3029

}

3030

//Internal private number (this is a critical parameter, so entry will be skipped if value is unknown)

3031

value = g_variant_lookup_value(contactv, "index", G_VARIANT_TYPE_UINT32);

3032

if (value != NULL) {

3033

contact->id = g_variant_get_uint32(value);

3034

g_variant_unref(value);

3035

return contact;

3036

} else {

3037

if (contact->name != NULL) g_free(contact->name);

3038

if (contact->number != NULL) g_free(contact->number);

3039

if (contact->email != NULL) g_free(contact->email);

3040

if (contact->group != NULL) g_free(contact->group);

3041

if (contact->name2 != NULL) g_free(contact->name2);

3042

if (contact->number2 != NULL) g_free(contact->number2);

3043

g_free(contact);

3044

return NULL;

3045

}

3046

}

3047

3048

G_MODULE_EXPORT guint mmgui_module_contacts_enum(gpointer mmguicore, GSList **contactslist)

3049

{

3050

mmguicore_t mmguicorelc;

3051

moduledata_t moduledata;

3052

GError *error;

3053

GVariant *contacts;

3054

guint contactsnum;

3055

GVariantIter citerl1, citerl2;

3056

GVariant *cnodel1, *cnodel2;

3057

mmgui_contact_t contact;

3058

3059

if ((mmguicore == NULL) || (contactslist == NULL)) return 0;

3060

mmguicorelc = (mmguicore_t)mmguicore;

3061

3062

if (mmguicorelc->moduledata == NULL) return 0;

3063

moduledata = (moduledata_t)mmguicorelc->moduledata;

3064

3065

if (moduledata->contactsproxy == NULL) return 0;

3066

if (mmguicorelc->device == NULL) return 0;

3067

if (!mmguicorelc->device->enabled) return 0;

3068

if (!(mmguicorelc->device->contactscaps & MMGUI_CONTACTS_CAPS_EXPORT)) return 0;

3069

3070

error = NULL;

3071

3072

contacts = g_dbus_proxy_call_sync(moduledata->contactsproxy,

3073

"List",

3074

NULL,

3075

0,

3076

-1,

3077

NULL,

3078

&error);

3079

3080

if ((contacts == NULL) && (error != NULL)) {

3081

mmgui_module_handle_error_message(mmguicorelc, error);

3082

g_error_free(error);

3083

return 0;

3084

}

3085

3086

contactsnum = 0;

3087

3088

g_variant_iter_init(&citerl1, contacts);

3089

while ((cnodel1 = g_variant_iter_next_value(&citerl1)) != NULL) {

3090

g_variant_iter_init(&citerl2, cnodel1);

3091

while ((cnodel2 = g_variant_iter_next_value(&citerl2)) != NULL) {

3092

contact = mmgui_module_contact_retrieve(cnodel2);

3093

if (contact != NULL) {

3094

*contactslist = g_slist_prepend(*contactslist, contact);

3095

contactsnum++;

3096

}

3097

g_variant_unref(cnodel2);

3098

}

3099

g_variant_unref(cnodel1);

3100

}

3101

3102

g_variant_unref(contacts);

3103

3104

return contactsnum;

3105

}

3106

3107

G_MODULE_EXPORT gboolean mmgui_module_contacts_delete(gpointer mmguicore, guint index)

3108

{

3109

mmguicore_t mmguicorelc;

3110

moduledata_t moduledata;

3111

GError *error;

3112

3113

if (mmguicore == NULL) return FALSE;

3114

mmguicorelc = (mmguicore_t)mmguicore;

3115

3116

if (mmguicorelc->moduledata == NULL) return FALSE;

3117

moduledata = (moduledata_t)mmguicorelc->moduledata;

3118

3119

if (moduledata->contactsproxy == NULL) return FALSE;

3120

if (mmguicorelc->device == NULL) return FALSE;

3121

if (!mmguicorelc->device->enabled) return FALSE;

3122

if (!(mmguicorelc->device->contactscaps & MMGUI_CONTACTS_CAPS_EDIT)) return FALSE;

3123

3124

error = NULL;

3125

3126

g_dbus_proxy_call_sync(moduledata->contactsproxy,

3127

"Delete",

3128

g_variant_new("(i)", index),

3129

0,

3130

-1,

3131

NULL,

3132

&error);

3133

3134

if (error != NULL) {

3135

mmgui_module_handle_error_message(mmguicorelc, error);

3136

g_error_free(error);

3137

return FALSE;

3138

}

3139

3140

return TRUE;

3141

}

3142

3143

G_MODULE_EXPORT gint mmgui_module_contacts_add(gpointer mmguicore, gchar* name, gchar *number)

3144

{

3145

mmguicore_t mmguicorelc;

3146

moduledata_t moduledata;

3147

GVariantBuilder *builder;

3148

GVariant *array, *contact;

3149

GError *error;

3150

GVariant *idv;

3151

guint id;

3152

3153

if ((mmguicore == NULL) || (name == NULL) || (number == NULL)) return -1;

3154

mmguicorelc = (mmguicore_t)mmguicore;

3155

3156

if (mmguicorelc->moduledata == NULL) return -1;

3157

moduledata = (moduledata_t)mmguicorelc->moduledata;

3158

3159

if (moduledata->contactsproxy == NULL) return -1;

3160

if (mmguicorelc->device == NULL) return -1;

3161

if (!mmguicorelc->device->enabled) return -1;

3162

if (!(mmguicorelc->device->contactscaps & MMGUI_CONTACTS_CAPS_EDIT)) return -1;

3163

3164

builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);

3165

g_variant_builder_add_parsed(builder, "{'name', <%s>}", name);

3166

g_variant_builder_add_parsed(builder, "{'number', <%s>}", number);

3167

g_variant_builder_add_parsed(builder, "{'hidden', <%b>}", FALSE);

3168

array = g_variant_builder_end(builder);

3169

3170

builder = g_variant_builder_new(G_VARIANT_TYPE_TUPLE);

3171

g_variant_builder_add_value(builder, array);

3172

contact = g_variant_builder_end(builder);

3173

3174

error = NULL;

3175

3176

idv = g_dbus_proxy_call_sync(moduledata->contactsproxy,

3177

"Add",

3178

contact,

3179

0,

3180

-1,

3181

NULL,

3182

&error);

3183

3184

if ((idv == NULL) && (error != NULL)) {

3185

mmgui_module_handle_error_message(mmguicorelc, error);

3186

g_error_free(error);

3187

return -1;

3188

}

3189

3190

g_variant_get(idv, "(u)", &id);

3191

g_variant_unref(idv);

3192

3193

return id;

3194

}