func Start() *LangSelector {
var logger = log.NewLogger(dbusSender)
if !lib.UniqueOnSession(dbusSender) {
logger.Warning("There is a LangSelector running...")
return nil
}
logger.BeginTracing()
_lang = newLangSelector(logger)
if _lang == nil {
logger.Error("Create LangSelector Failed")
return nil
}
err := dbus.InstallOnSession(_lang)
if err != nil {
logger.Error("Install Session DBus Failed:", err)
Stop()
return nil
}
_lang.onLocaleSuccess()
return _lang
}
func init() {
if logger == nil {
logger = log.NewLogger("com.deepin.daemon.Power")
}
C.Suite(&DBusInterfaceTest{})
}
func main() {
logger := log.NewLogger("dde-daemon/desktop-toggle")
logger.BeginTracing()
defer logger.EndTracing()
X, err := xgbutil.NewConn()
if err != nil {
logger.Error("New xgbutil connection failed: ", err)
panic(err)
}
if ret, err := ewmh.ShowingDesktopGet(X); err == nil {
// !!! NOT using ewmh.ShowingDesktopReq
// because ewmh.ShowingDesktopReq passes a uint argument,
// and int is used on xevent.NewClientMessage.
logger.Info("Show Desktop Status: ", ret)
var showInt int
if ret {
showInt = 0
} else {
showInt = 1
}
ewmh.ClientEvent(X, X.RootWin(), "_NET_SHOWING_DESKTOP", showInt)
}
X.Sync()
}
func NewManager() *Manager {
var m = Manager{}
m.logger = log.NewLogger(dbusSender)
m.monitor = gio.VolumeMonitorGet()
m.setting, _ = dutils.CheckAndNewGSettings(mediaHandlerSchema)
m.diskCache = make(map[string]*diskObjectInfo)
m.endFlag = make(chan struct{})
m.DiskList = m.getDiskInfos()
return &m
}
func Start() {
if _m != nil {
return
}
var logger = log.NewLogger("com.deepin.daemon.InputDevices")
logger.BeginTracing()
if !initDeviceChangedWatcher() {
logger.Error("Init device changed wacher failed")
logger.EndTracing()
return
}
_m := NewManager(logger)
err := dbus.InstallOnSession(_m)
if err != nil {
logger.Error("Install Manager DBus Failed:", err)
finalize()
return
}
err = dbus.InstallOnSession(_m.mouse)
if err != nil {
logger.Error("Install Mouse DBus Failed:", err)
finalize()
return
}
err = dbus.InstallOnSession(_m.touchpad)
if err != nil {
logger.Error("Install Touchpad DBus Failed:", err)
finalize()
return
}
err = dbus.InstallOnSession(_m.kbd)
if err != nil {
logger.Error("Install Keyboard DBus Failed:", err)
finalize()
return
}
err = dbus.InstallOnSession(_m.wacom)
if err != nil {
logger.Error("Install Wacom DBus Failed:", err)
finalize()
return
}
}
func Start() {
if _sysInfo != nil {
return
}
logger := log.NewLogger("com.deepin.daemon.SystemInfo")
logger.BeginTracing()
_sysInfo = NewSystemInfo(logger)
err := dbus.InstallOnSession(_sysInfo)
if err != nil {
logger.Error(err)
_sysInfo = nil
logger.EndTracing()
return
}
}
func NewSystemInfo(l *log.Logger) *SystemInfo {
sys := &SystemInfo{}
if l == nil {
l = log.NewLogger("com.deepin.daemon.SystemInfo")
}
sys.logger = l
var err error
sys.Version, err = getVersionFromDeepin("/etc/deepin-version")
if err != nil {
sys.logger.Warning(err)
sys.Version, err = getVersionFromLsb("/etc/lsb-release")
if err != nil {
sys.logger.Error(err)
return nil
}
}
sys.Processor, err = getCPUInfoFromFile("/proc/cpuinfo")
if err != nil {
sys.logger.Error(err)
return nil
}
sys.MemoryCap, err = getMemoryCapFromFile("/proc/meminfo")
if err != nil {
sys.logger.Error(err)
return nil
}
sys.SystemType, err = getSystemType()
if err != nil {
sys.logger.Error(err)
return nil
}
sys.DiskCap, err = getDiskCap()
if err != nil {
sys.logger.Error(err)
return nil
}
return sys
}
func runAsDaemon() {
logger := log.NewLogger(grub2.DbusGrubDest + ".Runner")
logger.BeginTracing()
defer logger.EndTracing()
if !lib.UniqueOnSession(grub2.DbusGrubDest) {
logger.Error("dbus unique:", grub2.DbusGrubDest)
return
}
grub2.Start()
dbus.SetAutoDestroyHandler(60*time.Second, func() bool {
return !grub2.IsUpdating()
})
dbus.DealWithUnhandledMessage()
if err := dbus.Wait(); err != nil {
logger.Error("lost dbus session:", err)
os.Exit(1)
}
}
func newLangSelector(l *log.Logger) *LangSelector {
lang := LangSelector{LocaleState: LocaleStateChanged}
if l != nil {
lang.logger = l
} else {
lang.logger = log.NewLogger(dbusSender)
}
var err error
lang.lhelper, err = localehelper.NewLocaleHelper(
"com.deepin.api.LocaleHelper",
"/com/deepin/api/LocaleHelper")
if err != nil {
lang.logger.Warning("New LocaleHelper Failed:", err)
return nil
}
lang.setPropCurrentLocale(getLocale())
return &lang
}
"time"
)
type Manager struct {
writeStart bool
writeEnd chan bool
}
const (
DBUS_DEST = "com.deepin.daemon.Search"
DBUS_PATH = "/com/deepin/daemon/Search"
DBUS_IFC = "com.deepin.daemon.Search"
)
var (
logger = log.NewLogger(DBUS_DEST)
)
func newManager() *Manager {
m := Manager{}
m.writeStart = false
return &m
}
var _manager *Manager
func GetManager() *Manager {
if _manager == nil {
_manager = newManager()
C.set_backlight(C.double(v))
}
func (h *BacklightHelper) GetBrightness() float64 {
h.lock.Lock()
defer h.lock.Unlock()
return (float64)(C.get_backlight())
}
func (*BacklightHelper) GetDBusInfo() dbus.DBusInfo {
return dbus.DBusInfo{
"com.deepin.daemon.helper.Backlight",
"/com/deepin/daemon/helper/Backlight",
"com.deepin.daemon.helper.Backlight",
}
}
var logger = log.NewLogger("com.deepin.daemon.helper.Backlight")
func main() {
helper := NewBacklightHelper()
err := dbus.InstallOnSystem(helper)
if err != nil {
logger.Errorf("register dbus interface failed: %v", err)
os.Exit(1)
}
dbus.SetAutoDestroyHandler(time.Second*1, nil)
dbus.DealWithUnhandledMessage()
if err := dbus.Wait(); err != nil {
logger.Errorf("lost dbus session: %v", err)
os.Exit(1)
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package main
import (
"flag"
"os"
"pkg.linuxdeepin.com/dde-daemon/grub2"
"pkg.linuxdeepin.com/lib"
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
"time"
)
var logger = log.NewLogger(grub2.DbusGrub2ExtDest + ".Runner")
var argDebug bool
func main() {
logger.BeginTracing()
defer logger.EndTracing()
if !lib.UniqueOnSystem(grub2.DbusGrub2ExtDest) {
logger.Warning("There already has an Grub2 daemon running.")
return
}
flag.BoolVar(&argDebug, "d", false, "debug mode")
flag.BoolVar(&argDebug, "debug", false, "debug mode")
flag.Parse()
if argDebug {
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package network
import (
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
)
var (
logger = log.NewLogger(dbusNetworkDest)
manager *Manager
)
func Start() {
if manager != nil {
return
}
logger.BeginTracing()
initSlices() // initialize slice code
manager = NewManager()
err := dbus.InstallOnSession(manager)
if err != nil {
import (
libarea "dbus/com/deepin/api/xmousearea"
libdsp "dbus/com/deepin/daemon/display"
"dbus/com/deepin/dde/launcher"
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/gio-2.0"
"pkg.linuxdeepin.com/lib/log"
"sync"
)
var (
dspObj *libdsp.Display
areaObj *libarea.XMouseArea
launchObj *launcher.Launcher
logger = log.NewLogger(ZONE_DEST)
mutex = new(sync.Mutex)
edgeActionMap = make(map[string]string)
)
var zoneSettings = func() func() *gio.Settings {
var initZoneSettings sync.Once
var _zoneSettings *gio.Settings
return func() *gio.Settings {
initZoneSettings.Do(func() {
_zoneSettings = gio.NewSettings("com.deepin.dde.zone")
})
return _zoneSettings
}
}()
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package bluetooth
import (
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
)
var (
logger = log.NewLogger(dbusBluetoothDest)
bluetooth *Bluetooth
)
func Start() {
if bluetooth != nil {
return
}
logger.BeginTracing()
bluetooth = NewBluetooth()
err := dbus.InstallOnSession(bluetooth)
if err != nil {
// don't panic or fatal here
logger.Error("register dbus interface failed: ", err)
package main
import (
"os"
"pkg.linuxdeepin.com/lib"
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
"time"
)
const (
DEST = "com.deepin.daemon.Personalization"
)
var (
Logger = log.NewLogger(DEST)
)
func main() {
if !lib.UniqueOnSession(DEST) {
Logger.Warning("There has an set-fonts running...")
return
}
Logger.BeginTracing()
defer Logger.EndTracing()
Logger.SetRestartCommand("/usr/lib/deepin-daemon/personalization")
StartFont()
dbus.DealWithUnhandledMessage()
package screensaver
import (
"github.com/BurntSushi/xgb/dpms"
"github.com/BurntSushi/xgb/screensaver"
"github.com/BurntSushi/xgb/xproto"
"github.com/BurntSushi/xgbutil"
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
"sync"
)
var logger = log.NewLogger("org.freedesktop.ScreenSaver")
type inhibitor struct {
cookie uint32
name string
reason string
}
type ScreenSaver struct {
xu *xgbutil.XUtil
IdleOn func()
CycleActive func()
IdleOff func()
blank byte
idleTime uint32
idleInterval uint32
inhibitors map[uint32]inhibitor
package audio
import "pkg.linuxdeepin.com/lib/dbus"
import "pkg.linuxdeepin.com/lib/log"
import "pkg.linuxdeepin.com/lib/pulse"
import libsound "dbus/com/deepin/api/sound"
var logger = log.NewLogger("com.deepin.daemon.Audio")
type Audio struct {
init bool
core *pulse.Context
Sinks []*Sink
Sources []*Source
SinkInputs []*SinkInput
DefaultSink string
DefaultSource string
MaxUIVolume float64
siEventChan chan func()
siPollerExit chan struct{}
}
func (a *Audio) Reset() {
for _, s := range a.Sinks {
s.SetVolume(s.BaseVolume, false)
s.SetBalance(0, false)
s.SetFade(0)
}
package main
import "pkg.linuxdeepin.com/lib/log"
import "pkg.linuxdeepin.com/lib"
import "pkg.linuxdeepin.com/lib/dbus"
import "os"
import _ "pkg.linuxdeepin.com/dde-daemon/accounts"
import "pkg.linuxdeepin.com/dde-daemon"
import . "pkg.linuxdeepin.com/lib/gettext"
var logger = log.NewLogger("com.deepin.daemon")
func main() {
logger.BeginTracing()
defer logger.EndTracing()
if !lib.UniqueOnSystem("com.deepin.daemon") {
logger.Warning("There already has an dde-daemon running.")
return
}
InitI18n()
Textdomain("dde-daemon")
logger.SetRestartCommand("/usr/lib/deepin-daemon/dde-system-daemon")
loader.StartAll()
defer loader.StopAll()
dbus.DealWithUnhandledMessage()
"pkg.linuxdeepin.com/lib/log"
"strings"
)
const (
MPRIS_FILTER_KEY = "org.mpris.MediaPlayer2"
MPRIS_PATH = "/org/mpris/MediaPlayer2"
SEEK_DISTANCE = int64(5000000) // 5s
MIME_TYPE_BROWSER = "x-scheme-handler/http"
MIME_TYPE_EMAIL = "x-scheme-handler/mailto"
CALCULATOR_CMD = "/usr/bin/gnome-calculator"
)
var (
logger = log.NewLogger("dde-daemon/mpris")
dbusObj *libdbus.DBusDaemon
mediaKeyObj *libkeybind.MediaKey
loginObj *liblogin1.Manager
prevSender = ""
)
func getCommandByMimeType(mimeType string) (string, bool) {
if appInfo := gio.AppInfoGetDefaultForType(mimeType, false); appInfo != nil {
return appInfo.GetExecutable(), true
}
return "", false
}
func getMprisClients() ([]string, bool) {
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package sessionwatcher
import (
"pkg.linuxdeepin.com/lib/log"
"time"
)
var (
logger = log.NewLogger("dde-daemon/sessionwatcher")
)
type Manager struct {
dock *Dock
appelt *DockApplet
exitTimer chan struct{}
}
func NewManager() *Manager {
m := &Manager{}
m.dock = NewDock()
m.appelt = NewDockApplet()
m.exitTimer = make(chan struct{})
package dock
import (
"dbus/com/deepin/api/xmousearea"
"dbus/com/deepin/daemon/display"
"github.com/BurntSushi/xgbutil"
"github.com/BurntSushi/xgbutil/xprop"
"os"
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
"time"
)
var (
logger = log.NewLogger("com.deepin.daemon.Dock")
region *Region = nil
setting *Setting = nil
hideModemanager *HideStateManager = nil
dpy *display.Display = nil
dockProperty *DockProperty = nil
entryProxyerManager *EntryProxyerManager = nil
dockedAppManager *DockedAppManager = nil
areaImp *xmousearea.XMouseArea = nil
mouseArea *XMouseAreaProxyer = nil
)
func Stop() {
if dockProperty != nil {
dockProperty.destroy()
dockProperty = nil
}
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package appearance
import (
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
)
var (
logger = log.NewLogger("com.deepin.daemon.Themes")
)
var _manager *Manager
func finalize() {
logger.EndTracing()
_manager.destroy()
_manager = nil
}
func Start() {
if _manager != nil {
return
}
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package grub2
import (
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
)
var (
logger = log.NewLogger(DbusGrubDest)
grub *Grub2
)
func Start() {
logger.BeginTracing()
grub = NewGrub2()
err := dbus.InstallOnSession(grub)
if err != nil {
logger.Errorf("register dbus interface failed: %v", err)
return
}
err = dbus.InstallOnSession(grub.theme)
if err != nil {
logger.Errorf("register dbus interface failed: %v", err)
package main
import "io/ioutil"
import "pkg.linuxdeepin.com/lib/dbus"
import log "pkg.linuxdeepin.com/lib/log"
import "os"
import "os/exec"
var logger = log.NewLogger("com.deepin.helper.LanguageSelector")
type LanguageSelector struct {
}
func run_shell_content(code string, argv ...string) {
f, err := ioutil.TempFile(os.TempDir(), "shell_code")
if err != nil {
logger.Warning("can't create temp file: ", err)
return
}
f.Close()
os.Remove(f.Name())
ioutil.WriteFile(f.Name(), ([]byte)(code), 0755)
argv = append([]string{f.Name()}, argv...)
cmd := exec.Command("/bin/sh", argv...)
d, err := cmd.Output()
logger.Info(string(d))
if err != nil {
logger.Error("Can't run shell code:", err)
}
defer os.Remove(f.Name())
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package keybinding
import (
"github.com/BurntSushi/xgbutil"
"github.com/BurntSushi/xgbutil/keybind"
"github.com/BurntSushi/xgbutil/xevent"
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/gio-2.0"
"pkg.linuxdeepin.com/lib/log"
)
var (
logger = log.NewLogger("daemon/keybinding")
X *xgbutil.XUtil
grabKeyBindsMap = make(map[KeycodeInfo]string)
PrevSystemPairs = make(map[string]string)
PrevCustomPairs = make(map[string]string)
bindGSettings *gio.Settings
sysGSettings *gio.Settings
mediaGSettings *gio.Settings
)
func initGSettings() {
bindGSettings = gio.NewSettings("com.deepin.dde.keybinding")
sysGSettings = gio.NewSettings("com.deepin.dde.keybinding.system")
mediaGSettings = gio.NewSettings("com.deepin.dde.keybinding.mediakey")
"database/sql"
storeApi "dbus/com/deepin/store/api"
"errors"
"sync"
// . "pkg.linuxdeepin.com/dde-daemon/launcher/interfaces"
. "pkg.linuxdeepin.com/dde-daemon/launcher/category"
. "pkg.linuxdeepin.com/dde-daemon/launcher/item"
. "pkg.linuxdeepin.com/dde-daemon/launcher/item/search"
. "pkg.linuxdeepin.com/dde-daemon/launcher/item/softwarecenter"
"pkg.linuxdeepin.com/lib/dbus"
. "pkg.linuxdeepin.com/lib/gettext"
"pkg.linuxdeepin.com/lib/gio-2.0"
"pkg.linuxdeepin.com/lib/log"
)
var logger = log.NewLogger("dde-daemon/launcher-daemon")
var launcher *Launcher = nil
func Stop() {
if launcher == nil {
return
}
launcher.destroy()
launcher = nil
logger.EndTracing()
}
func startFailed(err error) {
logger.Error(err)
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
**/
package accounts
import (
"pkg.linuxdeepin.com/lib/dbus"
"pkg.linuxdeepin.com/lib/log"
)
var (
_m *Manager
logger = log.NewLogger(dbusSender)
)
func Start() {
if _m != nil {
return
}
logger.BeginTracing()
_m = NewManager()
err := dbus.InstallOnSystem(_m)
if err != nil {
logger.Error("Install manager dbus failed:", err)
if _m.watcher != nil {
_m.watcher.EndWatch()
_m.watcher = nil
package loader
import (
"pkg.linuxdeepin.com/lib/log"
)
var logger = log.NewLogger("dde.daemon.loader")
type Module struct {
Name string
Start func()
Stop func()
Enable bool
}
var modules = make([]*Module, 0)
func getModule(name string) (module *Module) {
for _, m := range modules {
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 {
import (
"math/rand"
"os"
"os/exec"
"path"
"pkg.linuxdeepin.com/lib/graphic"
"pkg.linuxdeepin.com/lib/log"
dutils "pkg.linuxdeepin.com/lib/utils"
"strings"
"time"
"unsafe"
)
var (
forceFlag = false
logger = log.NewLogger("theme-thumb-tool")
)
const (
_CMD_ = "theme-thumb-tool"
_GTK_THUMB_CMD_ = "/usr/lib/deepin-daemon/gtk-thumb-tool"
THUMB_CACHE_DIR = "autogen"
)
func getUserPictureDir() string {
str := C.get_user_pictures_dir()
//defer C.free(unsafe.Pointer(str))
ret := C.GoString(str)