← Back to branch summary

~mandel/ubuntu-download-manager/typos-logs-unlock-not-locked

« back to all changes in this revision

Viewing changes to bindings/golang/udm.go

  • Committer: Tarmac
  • Author(s): Manuel de la Pena
  • Date: 2014-02-12 20:28:37 UTC
  • mfrom: (235.1.2 use-int32-go)
  • Revision ID: tarmac-20140212202837-gs93m5tgwv50ph50
Fix the go bindings. Fixes: https://bugs.launchpad.net/bugs/1279409, https://bugs.launchpad.net/bugs/1279430.

Approved by Sergio Schvezov, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bindings/golang/udm.go
24
24
 
25
25
import (
26
26
        "launchpad.net/go-dbus/v1"
27
 
        "log"
28
27
        "runtime"
29
28
)
30
29
 
198
197
func (down *FileDownload) TotalSize() (size uint64, err error) {
199
198
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "totalSize")
200
199
        if err != nil || reply.Type == dbus.TypeError {
201
 
                log.Fatal("FAILED: TotalSize")
202
200
                return 0, err
203
201
        }
204
202
        if err = reply.Args(&size); err != nil {
205
 
                log.Fatal("FAILED: Casting size")
206
203
                return 0, err
207
204
        }
208
205
        return size, nil
212
209
func (down *FileDownload) Progress() (progress uint64, err error) {
213
210
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "progress")
214
211
        if err != nil || reply.Type == dbus.TypeError {
215
 
                log.Fatal("FAILED: Progress")
216
212
                return 0, err
217
213
        }
218
214
        if err = reply.Args(&progress); err != nil {
219
 
                log.Fatal("FAILED: Casting progress")
220
215
                return 0, err
221
216
        }
222
217
        return progress, nil
226
221
func (down *FileDownload) Metadata() (metadata map[string]string, err error) {
227
222
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "metadata")
228
223
        if err != nil || reply.Type == dbus.TypeError {
229
 
                log.Fatal("FAILED: Metadata")
230
224
                return nil, err
231
225
        }
232
226
        if err = reply.Args(&metadata); err != nil {
233
 
                log.Fatal("FAILED: Casting metadata")
234
227
                return nil, err
235
228
        }
236
229
        return metadata, nil
240
233
func (down *FileDownload) SetThrottle(throttle uint64) (err error) {
241
234
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "setThrottle", throttle)
242
235
        if err != nil || reply.Type == dbus.TypeError {
243
 
                log.Fatal("FAILED: SetThrottle")
244
236
                return err
245
237
        }
246
238
        return nil
250
242
func (down *FileDownload) Throttle() (throttle uint64, err error) {
251
243
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "throttle")
252
244
        if err != nil || reply.Type == dbus.TypeError {
253
 
                log.Fatal("FAILED: Throttle")
254
245
                return 0, err
255
246
        }
256
247
        if err = reply.Args(&throttle); err != nil {
257
 
                log.Fatal("FAILED: Casting metadata")
258
248
                return 0, err
259
249
        }
260
250
        return throttle, nil
265
255
func (down *FileDownload) AllowMobileDownload(allowed bool) (err error) {
266
256
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "allowGSMDownload", allowed)
267
257
        if err != nil || reply.Type == dbus.TypeError {
268
 
                log.Fatal("FAILED: AllowMobileDownload ")
269
258
                return err
270
259
        }
271
260
        return nil
275
264
func (down *FileDownload) IsMobileDownload() (allowed bool, err error) {
276
265
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "isGSMDownloadAllowed", allowed)
277
266
        if err != nil || reply.Type == dbus.TypeError {
278
 
                log.Fatal("FAILED: IsMobileDownload")
279
267
                return false, err
280
268
        }
281
269
        if err = reply.Args(&allowed); err != nil {
282
 
                log.Fatal("FAILED: Casting metadata")
283
270
                return false, err
284
271
        }
285
272
        return allowed, nil
330
317
func (down *FileDownload) Start() (err error) {
331
318
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "start")
332
319
        if err != nil || reply.Type == dbus.TypeError {
333
 
                log.Fatal("FAILED: start")
334
320
                return err
335
321
        }
336
322
        return nil
340
326
func (down *FileDownload) Pause() (err error) {
341
327
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "pause")
342
328
        if err != nil || reply.Type == dbus.TypeError {
343
 
                log.Fatal("FAILED: start")
344
329
                return err
345
330
        }
346
331
        return nil
350
335
func (down *FileDownload) Resume() (err error) {
351
336
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "resume")
352
337
        if err != nil || reply.Type == dbus.TypeError {
353
 
                log.Fatal("FAILED: start")
354
338
                return err
355
339
        }
356
340
        return nil
361
345
func (down *FileDownload) Cancel() (err error) {
362
346
        reply, err := down.proxy.Call(DOWNLOAD_INTERFACE, "cancel")
363
347
        if err != nil || reply.Type == dbus.TypeError {
364
 
                log.Fatal("FAILED: start")
365
348
                return err
366
349
        }
367
350
        return nil
491
474
func NewDownloadManager() (*DownloadManager, error) {
492
475
        conn, err := dbus.Connect(dbus.SessionBus)
493
476
        if err != nil {
494
 
                log.Printf("Connection error:")
 
477
                return nil, err
495
478
        }
496
479
 
497
480
        if err != nil {
498
 
                log.Printf("Error: %s\n")
 
481
                return nil, err
499
482
        }
500
483
 
501
484
        proxy := conn.Object(DOWNLOAD_SERVICE, "/")
529
512
func (man *DownloadManager) CreateDownload(url string, hash string, algo hashType, metadata map[string]interface{}, headers map[string]string) (down Download, err error) {
530
513
        var t map[string]*dbus.Variant
531
514
        for key, value := range metadata {
532
 
                log.Print("Key:", key, "Value:", value)
533
515
                t[key] = &dbus.Variant{Value: value}
534
516
        }
535
517
        s := struct {
542
524
        var path dbus.ObjectPath
543
525
        reply, err := man.proxy.Call(DOWNLOAD_MANAGER_INTERFACE, "createDownload", s)
544
526
        if err != nil || reply.Type == dbus.TypeError {
545
 
                log.Fatal("FAILED: createDownload")
546
527
                return nil, err
547
528
        }
548
529
        if err = reply.Args(&path); err != nil {
549
 
                log.Fatal("FAILED: Casting path")
550
530
                return nil, err
551
531
        }
552
532
        down, err = newFileDownload(man.conn, path)
556
536
// CreateMmsDownload creates an mms download that will be performed right away. An
557
537
// mms download only uses mobile that and an apn proxy to download a multime media
558
538
// message.
559
 
func (man *DownloadManager) CreateMmsDownload(url string, hostname string, port int, username string, password string) (down Download, err error) {
 
539
func (man *DownloadManager) CreateMmsDownload(url string, hostname string, port int32, username string, password string) (down Download, err error) {
560
540
        var path dbus.ObjectPath
561
541
        reply, err := man.proxy.Call(DOWNLOAD_MANAGER_INTERFACE, "createMmsDownload", url, hostname, port, username, password)
562
542
        if err != nil || reply.Type == dbus.TypeError {
563
 
                log.Fatal("FAILED: createMmsDownload")
564
543
                return nil, err
565
544
        }
566
545
        if err = reply.Args(&path); err != nil {
567
 
                log.Fatal("FAILED: Casting path")
568
546
                return nil, err
569
547
        }
570
548
        down, err = newFileDownload(man.conn, path)