kivyblocks/kivyblocks/blocksapp.py

157 lines
3.7 KiB
Python
Raw Normal View History

2019-12-19 11:13:47 +08:00
import os
import sys
import signal
2021-01-21 12:30:56 +08:00
import codecs
import json
2019-12-19 11:13:47 +08:00
from appPublic.jsonConfig import getConfig
from appPublic.folderUtils import ProgramPath
2021-01-21 12:30:56 +08:00
from appPublic.uniqueID import getID
2019-12-19 11:13:47 +08:00
2020-06-03 11:23:34 +08:00
from kivy.factory import Factory
2019-12-19 11:13:47 +08:00
from kivy.config import Config
from kivy.metrics import sp,dp,mm
from kivy.core.window import WindowBase, Window
from kivy.clock import Clock
2020-03-17 18:05:56 +08:00
from kivy.logger import Logger
2019-12-19 11:13:47 +08:00
import kivy
2021-01-21 12:30:56 +08:00
import plyer
2019-12-19 11:13:47 +08:00
from kivy.resources import resource_add_path
resource_add_path(os.path.join(os.path.dirname(__file__),'./ttf'))
Config.set('kivy', 'default_font', [
'msgothic',
'DroidSansFallback.ttf'])
from kivy.app import App
2021-01-20 14:10:00 +08:00
from kivy.utils import platform
2019-12-19 11:13:47 +08:00
from .threadcall import HttpClient,Workers
from .utils import *
from .pagescontainer import PageContainer
from .blocks import Blocks
2020-03-07 22:11:07 +08:00
from .theming import ThemeManager
2020-02-26 17:24:58 +08:00
from appPublic.rsa import RSA
2021-01-21 12:30:56 +08:00
if platform == 'android':
from jnius import autoclass
2020-02-26 17:24:58 +08:00
class ServerInfo:
def __init__(self):
self.rsaEngine = RSA()
self.publickey = None
self.authCode = None
def getServerPK(self):
config = getConfig()
url = '%s%s' % (config.uihome, config.publickey_url)
hc = App.get_running_app().hc
d = hc.get(url)
self.publickey = self.rsaEngine. publickeyFromText(d)
def encode(self,uinfo):
if self.publickey is None:
self.getServerPK()
if uinfo['authmethod'] == 'password':
authinfo = '%s::%s::%s' % (uinfo['authmethod'], uinfo['userid'], uinfo['passwd'])
x = self.rsaEngine.encode(self.publickey, authinfo)
self.authCode = x
return x
return None
2019-12-19 11:13:47 +08:00
def signal_handler(signal, frame):
app = App.get_running_app()
app.workers.running = False
app.stop()
print('Singal handled .........')
signal.signal(signal.SIGINT, signal_handler)
2020-03-15 00:51:44 +08:00
def getAuthHeader():
app = App.get_running_app()
if not hasattr(app,'serverinfo'):
print('app serverinfo not found')
2020-02-26 17:24:58 +08:00
return {}
2020-03-15 00:51:44 +08:00
serverinfo = app.serverinfo
if hasattr(serverinfo,'authCode'):
return {
'authorization':serverinfo.authCode
}
print('serverinfo authCode not found')
return {}
class BlocksApp(App):
def build(self):
config = getConfig()
2021-01-20 14:10:00 +08:00
self.public_headers = {}
Window.bind(on_request_close=self.on_close)
Window.bind(size=self.device_info)
self.workers = Workers(maxworkers=config.maxworkers or 80)
self.workers.start()
self.running = True
blocks = Blocks()
print(config.root)
x = blocks.widgetBuild(config.root)
if x is None:
alert('buildError,Exit', title='Error')
self.on_close()
return x
2021-01-21 12:30:56 +08:00
def get_user_data_path(self):
if platform == 'android':
Environment = autoclass('android.os.Environment')
2021-01-21 13:56:33 +08:00
sdpath = Environment.getExternalStorageDirectory()
2021-01-21 12:30:56 +08:00
return str(sdpath)
sdpath = App.get_running_app().user_data_dir
return str(sdpath)
def get_profile_name(self):
2021-01-21 13:56:33 +08:00
fname = os.path.join(self.user_data_dir,'.profile.json')
2021-01-21 12:30:56 +08:00
print('profile_path=', fname)
return fname
def write_profile(self, dic):
fname = self.get_profile_name()
with codecs.open(fname,'w','utf-8') as f:
json.dump(dic,f)
def write_default_profile(self):
device_id = getID()
try:
device_id = plyer.uniqueid.id
except:
pass
2021-02-14 12:50:02 +08:00
if isinstance(device,bytes):
device_id = device.decode('utf-8')
2021-01-21 12:30:56 +08:00
d = {
'device_id': device_id
}
self.write_profile(d)
def read_profile(self):
fname = self.get_profile_name()
if not os.path.isfile(fname):
self.write_default_profile()
with codecs.open(fname, 'r', 'utf-8') as f:
d = json.load(f)
return d
2021-01-20 14:10:00 +08:00
def device_info(self, *args):
d = {
"platform":platform,
"width":Window.width,
"height":Window.height
}
device = {
"device_info":";".join([f'{k}={v}' for k,v in d.items()])
}
self.public_headers.update(device)
def on_close(self, *args):
self.workers.running = False
return False
2020-06-03 11:23:34 +08:00