~victored/noise/lp-1099591

« back to all changes in this revision

Viewing changes to core/Devices/DeviceManager.vala

  • Committer: Corentin Noël
  • Date: 2014-03-07 15:06:55 UTC
  • Revision ID: tintou@mailoo.org-20140307150655-bqqrksl14ke55mjy
Improved the DeviceManager

Show diffs side-by-side

added added

removed removed

Lines of Context:
29
29
 *              Corentin Noël <tintou@mailoo.org>
30
30
 */
31
31
 
32
 
using Gee;
33
 
 
34
32
public class Noise.DeviceManager : GLib.Object {
35
33
    VolumeMonitor vm;
36
 
    
37
 
    public Gee.ArrayList<DevicePreferences> device_preferences;
38
 
    public Gee.ArrayList<unowned Device> devices;
39
 
    private Gee.ArrayList<Playlist> local_playlists;
40
 
    
 
34
 
41
35
    public signal void device_added (Device d);
42
36
    public signal void device_removed (Device d);
43
37
    public signal void device_name_changed (Device d);
44
 
    
 
38
 
45
39
    public signal void mount_added (Mount mount);
46
40
    public signal void mount_removed (Mount mount);
47
41
 
 
42
    private Gee.ArrayList<DevicePreferences> device_preferences;
 
43
    private Gee.ArrayList<unowned Device> initialized_devices;
 
44
    private Gee.ArrayList<unowned Mount> mounts_availables;
 
45
    private Gee.ArrayList<Playlist> local_playlists;
 
46
 
48
47
    private static DeviceManager? device_manager = null;
49
48
 
50
49
    public static DeviceManager get_default () {
52
51
            device_manager = new DeviceManager ();
53
52
        return device_manager;
54
53
    }
55
 
    
 
54
 
56
55
    private DeviceManager () {
57
 
        
58
56
        device_preferences = new Gee.ArrayList<DevicePreferences> ();
59
 
        devices = new Gee.ArrayList<unowned Device> ();
 
57
        initialized_devices = new Gee.ArrayList<unowned Device> ();
 
58
        mounts_availables = new Gee.ArrayList<unowned Mount> ();
60
59
        local_playlists = new Gee.ArrayList<Playlist> ();
61
 
        
62
 
        vm = VolumeMonitor.get();
63
 
        
64
 
        vm.mount_added.connect((mount) => {mount_added (mount);});
65
 
        vm.mount_changed.connect(mount_changed);
66
 
        vm.mount_pre_unmount.connect(mount_pre_unmount);
67
 
        vm.mount_removed.connect((mount) => {mount_removed (mount);});
68
 
        vm.volume_added.connect(volume_added);
 
60
 
 
61
        vm = VolumeMonitor.get ();
 
62
        vm.mount_added.connect ((mount) => {mounts_availables.add (mount); mount_added (mount);});
 
63
        vm.mount_changed.connect (mount_changed);
 
64
        vm.mount_pre_unmount.connect (mount_pre_unmount);
 
65
        vm.mount_removed.connect ((mount) => {mounts_availables.remove (mount); mount_removed (mount);});
 
66
        vm.volume_added.connect (volume_added);
 
67
        Threads.add (get_pre_existing_mounts);
69
68
    }
70
 
    
 
69
 
71
70
    public void set_device_preferences (Gee.Collection<DevicePreferences> device_preferences) {
72
71
        this.device_preferences.add_all (device_preferences);
73
72
    }
74
 
    
75
 
    public void loadPreExistingMounts() {
76
 
        // this can take time if we have to rev up the cd drive
77
 
        Threads.add (get_pre_existing_mounts);
78
 
    }
79
 
    
 
73
 
80
74
    public void get_pre_existing_mounts () {
81
 
        var mounts = new LinkedList<Mount>();
82
 
        var volumes = new LinkedList<Volume>();
83
 
        
84
 
        foreach(var m in vm.get_mounts()) {
85
 
            mounts.add(m);
86
 
        }
87
 
        
88
 
        foreach(var v in vm.get_volumes()) {
89
 
            volumes.add(v);
90
 
        }
91
 
        
92
 
        Idle.add( () => {
93
 
            
94
 
            foreach(var m in mounts) {
95
 
                mount_added(m);
96
 
            }
97
 
            
98
 
            foreach(var v in volumes) {
99
 
                volume_added(v);
100
 
            }
101
 
            
 
75
        var mounts = new Gee.LinkedList<Mount> ();
 
76
        var volumes = new Gee.LinkedList<Volume> ();
 
77
 
 
78
        foreach (var m in vm.get_mounts ()) {
 
79
            mounts.add (m);
 
80
        }
 
81
 
 
82
        foreach (var v in vm.get_volumes ()) {
 
83
            volumes.add (v);
 
84
        }
 
85
 
 
86
        Idle.add(() => {
 
87
            foreach (var m in mounts) {
 
88
                mounts_availables.add (m); 
 
89
                mount_added (m);
 
90
            }
 
91
 
 
92
            foreach (var v in volumes) {
 
93
                volume_added (v);
 
94
            }
 
95
 
102
96
            return false;
103
97
        });
104
98
    }
105
 
    
 
99
 
106
100
    void volume_added(Volume volume) {
107
 
        if(Settings.Main.get_default ().music_mount_name == volume.get_name() && volume.get_mount() == null) {
108
 
            debug ("mounting %s because it is believed to be the music folder\n", volume.get_name());
 
101
        if(Settings.Main.get_default ().music_mount_name == volume.get_name () && volume.get_mount () == null) {
 
102
            debug ("mounting %s because it is believed to be the music folder\n", volume.get_name ());
109
103
            volume.mount.begin (MountMountFlags.NONE, null, null);
110
104
        }
111
105
    }
112
 
    
 
106
 
113
107
    public void device_initialized (Device d) {
114
108
        debug ("adding device\n");
115
109
        device_added (d);
116
 
        devices.add (d);
 
110
        initialized_devices.add (d);
117
111
    }
118
 
    
 
112
 
119
113
    public virtual void mount_changed (Mount mount) {
120
114
        //message ("mount_changed:%s\n", mount.get_uuid());
121
115
    }
122
 
    
 
116
 
123
117
    public virtual void mount_pre_unmount (Mount mount) {
124
118
        //message ("mount_preunmount:%s\n", mount.get_uuid());
125
119
    }
126
 
    
127
 
    public DevicePreferences? get_device_preferences(string id) {
 
120
 
 
121
    public DevicePreferences? get_device_preferences (string id) {
128
122
        foreach (var device in device_preferences) {
129
123
            if (device.id == id)
130
124
                return device;
131
125
        }
 
126
 
132
127
        return null;
133
128
    }
134
 
    
135
 
    public void add_device_preferences(DevicePreferences dp) {
136
 
        
137
 
        lock(device_preferences) {
138
 
            device_preferences.add(dp);
 
129
 
 
130
    public Gee.ArrayList<unowned Device> get_initialized_devices () {
 
131
        return initialized_devices;
 
132
    }
 
133
 
 
134
    public Gee.ArrayList<unowned Mount> get_available_mounts () {
 
135
        return mounts_availables;
 
136
    }
 
137
 
 
138
    public void add_device_preferences (DevicePreferences dp) {
 
139
        lock (device_preferences) {
 
140
            device_preferences.add (dp);
139
141
        }
140
142
    }
141
143
}
 
 
b'\\ No newline at end of file'