使用 Kivy 的嵌套/交替应用程序

Question

我希望有一个 kivy 应用程序功能作为其他 kivy 应用程序的启动器，具体取决于输入。我在下面实现它的方式显然不起作用（因为kv 文件被重新加载并且它的样式被重新应用，因此添加了越来越多的按钮），而且当我点击Esc 时，跟踪暗示似乎也有一些递归。退出。

我确实收到app1.kv 被多次加载的警告，但是，在App.load_kv() 的文档中它说

如果没有，则在应用程序第一次运行时调用此方法 之前已经为此应用构建了小部件树。

这对我来说意味着应该可以多次run() 一个应用程序？

这是我的代码：

ma​​in.py

from kivy.uix.widget import Widget
from kivy.uix.gridlayout import GridLayout
from kivy.app import App
from kivy.properties import ObjectProperty
from kivy.uix.button import Button
from kivy.clock import Clock
from kivy.logger import Logger
from kivy.lang import Builder

class OutsideApp(App):
    current_app = ObjectProperty(None)

    def build(self):
        Clock.schedule_interval(self.update, 3)
        return Widget()

    def update(self, dt):
        if isinstance(self.current_app, App):
            self.current_app.stop()
        if isinstance(self.current_app, App1):
            self.current_app = App2()
        else:
            self.current_app = App1()
        self.current_app.run()

class App1(App):
    pass
class App2(App):
    def build(self):
        gl = Builder.load_string("<SequencesGame@GridLayout>:\n cols: 2\n   Button:\n       text: \"hello 2\"\nSequencesGame:")
        return gl

if __name__ == '__main__':
    oa = OutsideApp()
    oa.run()

app1.kv

#:kivy 1.0.9
<SequencesGame@GridLayout>:
    cols: 2
    Button:
        text: "hello 111"
SequencesGame:

即使应用没有嵌套，这似乎也是个问题：

ma​​in2.py

from kivy.app import App

from kivy.clock import Clock
from kivy.logger import Logger
from kivy.lang import Builder

class App1(App):
    pass
class App2(App):
    def build(self):
        return Builder.load_string("<SequencesGame@GridLayout>:\n   cols: 2\n   Button:\n       text: \"hello 2\"\nSequencesGame:")

current_app = None

def switch(*args):
    global current_app
    if isinstance(current_app, App):
        current_app.stop()
    if isinstance(current_app, App1):
        current_app = App2()
    else:
        current_app = App1()
    current_app.run()

if __name__ == '__main__':
    Clock.schedule_interval(switch, 2)
    switch()

Answer 1

最后我按照@inclement 的建议使用multiprocessing。这是一个基本实现（不通过管道或队列进行通信）：

import sys
import multiprocessing
from kivy.app import App
from kivy.lang import  Builder
from time import sleep#, localtime, time

def str_to_class(str):
    return reduce(getattr, str.split("."), sys.modules[__name__])

class App1(App):
    def build(self):
        return Builder.load_string("BoxLayout:\n    Button:\n       text: \"hello 1\"")

class App2(App):
    def build(self):
        return Builder.load_string("BoxLayout:\n    Button:\n       text: \"hello 2\"")


class Wrapper(object):
    def __init__(self, *kargs, **kwargs):
        super(Wrapper, self).__init__()
        self.running_app = None
        self.next_app = 'App1'

    def change_running_app(self, name='App1'):
        if self.running_app is not None:
            self.running_app.terminate()
        self.running_app = multiprocessing.Process(target=self.run_app, kwargs={'name':name})
        self.running_app.start()

    def run_app(self, name='App1'):
        app = str_to_class(name)()
        app.run()

    def swap(self):
        self.change_running_app(name=self.next_app)
        self.next_app = ['App1', 'App2']['App1' is self.next_app]

if __name__ == '__main__':
    counter = 0
    w = Wrapper()
    while True:
        counter += 1
        print "Started App instance {}".format(counter)
        w.swap()
        sleep(5)