loader: adjust code

Standardized variable names, split methods and
reduce repeat code.

Change-Id: I0f542d8bf106ad868365628079a16b1f80888c6f

bin/dde-session-daemon/daemon.go

@@ -46,8 +46,11 @@ import "pkg.linuxdeepin.com/dde-daemon"
 var logger = log.NewLogger("com.deepin.daemon")
 
 func main() {
+	InitI18n()
+	Textdomain("dde-daemon")
+
 	if !lib.UniqueOnSession("com.deepin.daemon") {
-		logger.Warning("There already has an dde-daemon running.")
+		logger.Warning("There already has a dde-daemon running.")
 		return
 	}
 	if len(os.Args) >= 2 {
@@ -55,18 +58,16 @@ func main() {
 			loader.Enable(disabledModuleName, false)
 		}
 	}
-	logger.BeginTracing()
-	defer logger.EndTracing()
-
-	InitI18n()
-	Textdomain("dde-daemon")
 
 	C.init()
 	proxy.SetupProxy()
 
-	initPlugins()
+	initModules()
 	listenDaemonSettings()
 
+	loader.StartAll()
+	defer loader.StopAll()
+
 	go func() {
 		if err := dbus.Wait(); err != nil {
 			logger.Errorf("Lost dbus: %v", err)
@@ -77,9 +78,6 @@ func main() {
 		}
 	}()
 
-	loader.Start()
-	defer loader.Stop()
-
 	ddeSessionRegister()
 	dbus.DealWithUnhandledMessage()
 	glib.StartLoop()

bin/dde-session-daemon/module.go

@@ -27,7 +27,8 @@ import (
 )
 
 var (
-	_pluginList = []string{
+	// modules should be loaded in following order
+	orderedModules = []string{
 		"inputdevices",
 		"screensaver",
 		"power",
@@ -48,28 +49,24 @@ var (
 		"systeminfo",
 		"sessionwatcher",
 	}
-
-	_daemonSettings = gio.NewSettings("com.deepin.dde.daemon")
+	daemonSettings = gio.NewSettings("com.deepin.dde.daemon")
 )
 
-func initPlugins() {
-	for _, plugin := range _pluginList {
-		enable := _daemonSettings.GetBoolean(plugin)
-		if !enable {
-			loader.Enable(plugin, false)
-		}
+func initModules() {
+	for _, name := range orderedModules {
+		loader.Enable(name, daemonSettings.GetBoolean(name))
 	}
 }
 
 func listenDaemonSettings() {
-	_daemonSettings.Connect("changed", func(s *gio.Settings, key string) {
-		enable := _daemonSettings.GetBoolean(key)
+	daemonSettings.Connect("changed", func(s *gio.Settings, name string) {
+		// gsettings key names must keep consistent with module names
+		enable := daemonSettings.GetBoolean(name)
+		loader.Enable(name, enable)
 		if enable {
-			logger.Info("-------------Enable plugin:", key)
-			loader.StartPlugin(key)
+			loader.Start(name)
 		} else {
-			logger.Info("+++++++++++++Disable plugin:", key)
-			loader.StopPlugin(key)
+			loader.Stop(name)
 		}
 	})
 }

bin/dde-system-daemon/main.go

@@ -25,12 +25,8 @@ func main() {
 
 	logger.SetRestartCommand("/usr/lib/deepin-daemon/dde-system-daemon")
 
-	// for some laptops such as ideapad, the wireless devices may be
-	// blocked at startup, so we try to unblock them here.
-	requestUnblockAllDevice()
-
-	loader.Start()
-	defer loader.Stop()
+	loader.StartAll()
+	defer loader.StopAll()
 
 	dbus.DealWithUnhandledMessage()
 

loader.go

@@ -15,70 +15,94 @@ type Module struct {
 
 var modules = make([]*Module, 0)
 
-func StartPlugin(plugin string) {
+func getModule(name string) (module *Module) {
 	for _, m := range modules {
-		if m.Name == plugin {
-			m.Start()
-			return
+		if m.Name == name {
+			module = m
+			break
 		}
 	}
+	if module == nil {
+		logger.Warning("target module not found:", name)
+	}
+	return
+}
+func isModuleExist(name string) (ok bool) {
+	for _, m := range modules {
+		if m.Name == name {
+			ok = true
+			break
+		}
+	}
+	return
 }
 
-func StopPlugin(plugin string) {
-	for _, m := range modules {
-		if m.Name == plugin {
-			m.Stop()
-			return
-		}
+func Start(name string) {
+	m := getModule(name)
+	if m != nil {
+		doStart(m)
 	}
 }
+func doStart(m *Module) {
+	logger.Info("Start module:", m.Name)
+	defer func() {
+		if err := recover(); err != nil {
+			logger.Error("Start module", m.Name, "failed:", err)
+		}
+	}()
+	m.Start()
+}
+
+func Stop(name string) {
+	m := getModule(name)
+	if m != nil {
+		doStop(m)
+	}
+}
+func doStop(m *Module) {
+	logger.Info("Stop module:", m.Name)
+	defer func() {
+		if err := recover(); err != nil {
+			logger.Error("Stop module", m.Name, "failed:", err)
+		}
+	}()
+	m.Stop()
+}
 
 func Enable(name string, enable bool) {
-	for _, m := range modules {
-		if m.Name == name {
-			m.Enable = enable
-		}
+	m := getModule(name)
+	if m != nil {
+		m.Enable = enable
 	}
 }
 
 func Register(newModule *Module) {
-	for _, m := range modules {
-		if m.Name == newModule.Name {
-			return
-		}
+	logger.Info("Register module:", newModule.Name)
+	if isModuleExist(newModule.Name) {
+		logger.Warning("module already registered:", newModule.Name)
+		return
 	}
 	if newModule.Start == nil || newModule.Stop == nil {
-		logger.Error("can't register an incomplete module " + newModule.Name)
+		logger.Error("can't register an incomplete module:", newModule.Name)
 		return
 	}
 	modules = append([]*Module{newModule}, modules...)
 }
 
-func Start() {
+func StartAll() {
+	logger.Info("Start all modules")
 	for _, m := range modules {
 		if !m.Enable {
+			logger.Info("skip disabled module:", m.Name)
 			continue
 		}
+		doStart(m)
+	}
+}
 
-		func() {
-			defer func() {
-				if err := recover(); err != nil {
-					logger.Error("Start module", m.Name, "failed:", err)
-				}
-			}()
-			m.Start()
-		}()
-	}
-}
-func Stop() {
+func StopAll() {
+	logger.Info("Stop all modules")
 	for _, m := range modules {
-		func() {
-			defer func() {
-				if err := recover(); err != nil {
-					logger.Error("Stop module", m.Name, "failed:", err)
-				}
-			}()
-			m.Stop()
-		}()
+		doStop(m)
 	}
 }