ui/main.go

package main

import (
	libapp "cwtch.im/cwtch/app"
	"cwtch.im/ui/go/characters"
	"cwtch.im/ui/go/gobjects"
	"cwtch.im/ui/go/gothings"
	"cwtch.im/ui/go/gothings/android"
	"cwtch.im/ui/go/the"
	"flag"
	"git.openprivacy.ca/openprivacy/libricochet-go/connectivity"
	"git.openprivacy.ca/openprivacy/libricochet-go/log"
	"github.com/therecipe/qt/core"
	"github.com/therecipe/qt/gui"
	"github.com/therecipe/qt/network"
	"github.com/therecipe/qt/qml"
	"github.com/therecipe/qt/quickcontrols2"
	"os"
	"os/user"
	"path"
	"path/filepath"
	"runtime"
	"time"
)

const androidBaseDir = "/data/data/ca.openprivacy.cwtch.ui/"

var (
	buildVer  string
	buildDate string
)

func init() {
	// make go-defined types available in qml
	gothings.GrandCentralDispatcher_QmlRegisterType2("CustomQmlTypes", 1, 0, "GrandCentralDispatcher")
}

func main() {
	log.Infoln("ui main()\n")
	flagDebug := flag.Bool("debug", false, "turn on extra logging. WARNING: THIS MAY EXPOSE PRIVATE INFORMATION IN CONSOLE OUTPUT!")
	flagLocal := flag.Bool("local", false, "load user interface from the local folder \"qml\" instead of the built-in UI")
	flagService := flag.Bool("service", false, "indicate this process should run as an android service")
	flag.Parse()

	if *flagDebug {
		log.SetLevel(log.LevelDebug)
	} else {
		log.SetLevel(log.LevelInfo)
	}

	if os.Getenv("CWTCH_FOLDER") != "" {
		the.CwtchDir = os.Getenv("CWTCH_FOLDER")
	} else if runtime.GOOS == "android" {
		the.CwtchDir = path.Join(androidBaseDir, "files")
	} else {
		usr, err := user.Current()
		if err != nil {
			log.Errorf("\nerror: could not load current user: %v\n", err)
			os.Exit(1)
		}
		the.CwtchDir = path.Join(usr.HomeDir, ".cwtch")
	}
	the.ACN = nil

	if *flagService {
		mainService()

	} else {
		mainUi(*flagLocal)
	}

	if the.ACN != nil {
		the.ACN.Close()
	}
}

func mainService() {
	log.Infoln("I am the service")
	loadACN()
	log.Infoln("Starting a cwtch app...")
	the.CwtchApp = libapp.NewApp(the.ACN, the.CwtchDir)

	log.Infoln("Sleepinging???")
	for true {
		time.Sleep(5 * time.Second)
		log.Infoln("Wake up, repeat")
	}
}

func mainUi(flagLocal bool) {
	log.Infoln("I am the application")

	app := gui.NewQGuiApplication(len(os.Args), os.Args)

	// our globals
	gcd := gothings.NewGrandCentralDispatcher(nil)
	gcd.SetOs(runtime.GOOS)
	if buildVer != "" {
		gcd.SetVersion(buildVer)
		gcd.SetBuildDate(buildDate)
	} else {
		gcd.SetVersion("development")
		gcd.SetBuildDate("now")
	}
	gcd.UIState = gothings.NewUIState(gcd)
	the.AcknowledgementIDs = make(map[string][]*the.AckId)
	gcd.OutgoingMessages = make(chan gobjects.Letter, 1000)

	//TODO: put theme stuff somewhere better
	gcd.SetThemeScale(1.0)

	// this is to load local qml files quickly when developing
	var qmlSource *core.QUrl
	if flagLocal {
		qmlSource = core.QUrl_FromLocalFile("./qml/main.qml")
	} else {
		qmlSource = core.NewQUrl3("qrc:/qml/main.qml", 0)
	}

	app.SetWindowIcon(gui.NewQIcon5(":/qml/images/cwtch-icon.png"))

	// load english first so it becomes the default in case we don't have a .ts for the user's locale, or if it contains unfinished strings
	translator := core.NewQTranslator(nil)
	translator.Load("translation_en", ":/i18n/", "", "")
	core.QCoreApplication_InstallTranslator(translator)

	gcd.Translator = core.NewQTranslator(nil)
	gcd.Translator.Load("translation_"+core.QLocale_System().Name(), ":/i18n/", "", "")
	core.QCoreApplication_InstallTranslator(gcd.Translator)

	core.QCoreApplication_SetAttribute(core.Qt__AA_EnableHighDpiScaling, true)
	quickcontrols2.QQuickStyle_SetStyle("Universe")
	engine := qml.NewQQmlApplicationEngine(nil)
	gcd.QMLEngine = engine

	// prevent qt from initiating network connections (possible deanon attempts!)
	factory := qml.NewQQmlNetworkAccessManagerFactory()
	factory.ConnectCreate(func(parent *core.QObject) *network.QNetworkAccessManager {
		nam := network.NewQNetworkAccessManager(parent)
		nam.SetNetworkAccessible(network.QNetworkAccessManager__NotAccessible)
		proxy := network.NewQNetworkProxy()
		proxy.SetHostName("0.0.0.0")
		nam.SetProxy(proxy)
		//nam.ConnectCreateRequest(func(op network.QNetworkAccessManager__Operation, originalReq *network.QNetworkRequest, outgoingData *core.QIODevice) *network.QNetworkReply {
		//	log.Errorf("network access request detected - possible remote content insertion bug!!!")
		//	return nil
		//})
		return nam
	})
	engine.SetNetworkAccessManagerFactory(factory)

	// variables we want to access from inside qml
	if runtime.GOOS == "android" {
		gcd.SetThemeScale(2.9)
	} else {
		gcd.SetThemeScale(1.0)
	}
	engine.RootContext().SetContextProperty("gcd", gcd)

	var androidCwtchActivity = android.NewCwtchActivity(nil)
	engine.RootContext().SetContextProperty("androidCwtchActivity", androidCwtchActivity)

	//engine.addImportPath(QStringLiteral("qrc:/"));
	//engine.load(QUrl(QStringLiteral("qrc:/source/qml/main.qml")));

	engine.Load(qmlSource)

	go loadNetworkingAndFiles(gcd)

	app.Exec()

}

func loadACN() {
	torpath := "tor"
	if runtime.GOOS == "android" {
		torpath = path.Join(androidBaseDir, "lib/libtor.so")
	} else {
		dir, _ := filepath.Abs(filepath.Dir(os.Args[0]))
		if _, err := os.Stat(path.Join(dir, "tor")); os.IsNotExist(err) {
			if _, err := os.Stat(path.Join(dir, "deploy", "linux", "tor")); os.IsNotExist(err) {
				if _, err := os.Stat(path.Join(dir, "deploy", "windows", "tor")); os.IsNotExist(err) {
					log.Warnln("Cannot find bundled Tor")
				} else {
					torpath = path.Join(dir, "deploy", "windows", "tor")
				}
			} else {
				torpath = path.Join(dir, "deploy", "linux", "tor")
			}
		} else {
			torpath = path.Join(dir, "tor")
		}
	}
	var err error
	the.ACN, err = connectivity.StartTor(the.CwtchDir, torpath)
	if err != nil {
		log.Errorf("Could not start Tor: %v", err)
		os.Exit(1)
	}
}

func loadNetworkingAndFiles(gcd *gothings.GrandCentralDispatcher) {
	if runtime.GOOS != "android" {
		loadACN()
	}

	the.Peer = nil

	os.MkdirAll(the.CwtchDir, 0700)

	the.CwtchApp = libapp.NewApp(the.ACN, the.CwtchDir)
	the.AppBus = the.CwtchApp.GetPrimaryBus()
	go characters.AppEventListener(gcd)
	the.CwtchApp.LoadProfiles("be gay do crime")
}