def on_pause(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('Datos Sensores', 'running')
service.start('service started')
self.service = service
return True
def build(self):
if platform == "android":
from android import AndroidService
service = AndroidService('desire sensors service', 'running')
service.start('service started')
self.service = service
status_page = StatusPage()
accelerometer.enable()
compass.enable()
self.gps = gps
self.gps.configure(on_location=self.on_gps_location,
on_status=self.on_gps_status)
self.gps.start()
notification.notify(title="Hello", message="Just Checking")
#vibrator.vibrate(0.2) # vibrate for 0.2 seconds
print("Hello World")
status_page.gps_data = self.gps_data
# Clock.schedule_interval(status_page.update, 1.0 / 10.0) # 10H
Clock.schedule_interval(status_page.update, 1.0) # 1Hz
button = Button(text='Service', size_hint=(0.12, 0.12))
button.bind(on_press=self.callback)
status_page.add_widget(button)
switch = Switch()
switch.bind(active=self.callback)
status_page.add_widget(switch)
return status_page
def build(self):
global app
app = self
self.service = AndroidService('Kivy Remote Shell',
'remote shell is running')
self.service.start('8000')
return MainScreen()
def build(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('launch service')
service.start('service started')
self.service = service
return Builder.load_string(kv)
def start_service(self, app_name):
if platform == "android" and app_name in self.plugins_list:
# Clean up old logs
self.log_name = os.path.join(
main_utils.get_mobileinsight_analysis_path(),
app_name + "_log.txt")
if os.path.exists(self.log_name):
os.remove(self.log_name)
self.terminal_stop = threading.Event()
self.terminal_thread = threading.Thread(target=self.show_log)
self.terminal_thread.start()
self.error_log = "Running " + app_name + "..."
self.service = AndroidService(
"MobileInsight is running...", app_name)
# stop the running service
self.service.stop()
self.service.start(
app_name + ":" + self.plugins_list[app_name][0]) # app name
self.default_app_name = app_name
# TODO: support collecting TCPDUMP trace
# currentTime = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
# tcpdumpcmd = "su -c tcpdump -i rmnet_data0 -w " \
# + main_utils.get_mobileinsight_log_path() \
# + "/tcpdump_" + str(currentTime) + ".pcap\n"
# main_utils.run_shell_cmd(tcpdumpcmd)
else:
self.error_log = "Error: " + app_name + "cannot be launched!"
def start_service(self, app_name):
if platform == "android" and app_name in self.plugins_list:
if self.service:
# stop the running service
self.stop_service()
# Show logs on screen
# Clean up old logs
self.log_name = os.path.join(
main_utils.get_mobileinsight_analysis_path(),
app_name + "_log.txt")
if os.path.exists(self.log_name):
os.remove(self.log_name)
self.terminal_stop = threading.Event()
self.terminal_thread = threading.Thread(target=self.show_log)
self.terminal_thread.start()
self.error_log = "Running " + app_name + "..."
self.service = AndroidService("MobileInsight is running...",
app_name)
self.service.start(app_name + ":" +
self.plugins_list[app_name][0]) # app name
self.default_app_name = app_name
else:
self.error_log = "Error: " + app_name + "cannot be launched!"
def build(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('irc1\'s service', 'running')
service.start('service started')
self.service = service
osc.init()
oscid = osc.listen(ipAddr='127.0.0.1', port=activityport)
osc.bind(oscid, self.main_api_callback, '/api/main')
Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0.1)
self.icon = 'data/icon.png'
self.servers = DictStore('servers.db')
self.msg_animation = Animation(opacity=1, transition='out_cubic')
self.screenmain = ScreenMain()
self.running = {}
self.boxes = {}
for name in sorted(dict(self.servers.find()).keys()):
data = self.servers.get(name)
box = ServerBox(name=name)
self.boxes[name] = box
self.screenmain.ids.servers.add_widget(box)
manager = ScreenManager(transition=SlideTransition(duration=0.2))
manager.add_widget(self.screenmain)
return manager
def on_pause(self):
"""Al pausar la app si se encuentra en android ejecuta el servicio de chequeo de alertas."""
if platform == 'android':
from android import AndroidService
service = AndroidService('Datos Sensores', 'running')
service.start('service started')
self.service = service
return True
def pong(self, message, *args):
self.logging_function(
u'[b]Бот уже запущен! Переподключение завершено[/b]',
2, time.time()
)
self.subprocess = AndroidService('VKBot', 'Бот работает')
self.start_requesting_answers_count()
self.mainscreen.ids.main_btn.text = self.mainscreen.stop_bot_text
def start_new_service(self, title=None, description=None):
if self.service is not None:
self.service.stop()
self.service = None
service = AndroidService(title or self.service_title, description
or self.service_description)
service.start('service started')
self.service = service
def start_server(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('Mazerace server', 'Server is running')
service.start('service started')
self.service = service
else:
Logger.warn('Not android: Please start service manually!')
def build(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('pupy', 'running')
service.start('service started')
self.service = service
App.get_running_app().stop()
return Builder.load_string(kv)
def onSharedPreferenceChanged(self, sharedPref, key):
if sharedPref.getInt("live", 1) == 0:
try:
from android import AndroidService
AndroidService().stop()
time.sleep(0.3)
JavaHandler.killApp()
except IOError:
print "cannot stop AndroidService normally"
def build(self):
# calling the service
if platform == "android":
from android import AndroidService
service = AndroidService("my pong service", "running")
service.start("service started")
self.service = service
return MainScreen()
def start_anontunnel_android(self):
"""
Starts the anontunnel as an android service
"""
from android import AndroidService
service = AndroidService('Anonymous downloading Service',
'Anonymous tunnels are running...')
service.start('Anonymous tunnels service started')
self.service = service
def start_gps_daemon(self):
"""For instance, only Android is supported. An android.app.Service is created.
On iOs, a similar approach may be needed.
"""
if platform == 'android':
from android import AndroidService
service = AndroidService('KivyTrek gps service', 'running')
service.start('service started')
self.service = service
def start_service(self):
# Make a thing to test passing vars to the service
appdict = {"string": "Hello!", "int": 1, "list": [1, 2, 3, 4, 5]}
# JSON. every. day.
dumpd = dumps(appdict)
# Makin' that service
self.service = AndroidService('Sevice example', 'service is running')
# This just starts the service. I shouldn't need a comment here.
self.service.start(dumpd)
def schedule_load_content(self):
self.web_view.save_version_code()
if JavaHandler.movingFile():
return 'Loading finished'
else:
if self.server_is_running:
from android import AndroidService
AndroidService().stop()
time.sleep(0.5)
self.web_view.content_not_found_dialog()
def startService(self, level):
self.isRunning = True
if platform == 'android':
if not self.service:
self.service = AndroidService('my gps service', 'running')
if self.device:
self.service.start(level + '|' + self.device + '|' +
data.credentials.deviceAuth + '|' +
IOT._brokerPwd)
else:
self.service.start(level)
def __init__(self, **kwargs):
if platform == 'android':
self.isRunning = isServiceRunning()
if self.isRunning:
self.service = AndroidService('my gps service', 'running')
self.currentstatus = "service was running"
else:
self.service = None
else:
self.service = None
self.isRunning = False
super(MainWindow, self).__init__(**kwargs)
def start_service(self, foo=None):
try:
self.service.stop()
self.service = None
except:
logging.exception("Likely no need to stop nonexistent service")
try:
self.getPermission('location')
from plyer import gps
gps.configure(on_location=self.on_location)
gps.start()
except:
logging.exception("Could not start location service")
if platform == 'android':
from android import AndroidService
logging.info("About to start Android service")
service = AndroidService('HardlineP2P Service', 'running')
service.start('service started')
self.service = service
# On android the service that will actually be handling these databases is in the background in a totally separate
# process. So we open an SECOND drayer database object for each, with the same physical storage, using the first as the server.
# just for use in the foreground app.
# Because of this, two connections to the same DB file is a completetely supported use case that drayerDB has optimizations for.
daemonconfig.loadUserDatabases(
None,
forceProxy='localhost:7004',
callbackFunction=self.onDrayerRecordChange)
else:
def f():
# Ensure stopped
hardline.stop()
loadedServices = daemonconfig.loadUserServices(None)
daemonconfig.loadDrayerServerConfig()
self.currentPageNewRecordHandler = None
db = daemonconfig.loadUserDatabases(
None, callbackFunction=self.onDrayerRecordChange)
hardline.start(7009)
# Unload them at exit because we will be loading them again on restart
for i in loadedServices:
loadedServices[i].close()
t = threading.Thread(target=f, daemon=True)
t.start()
def schedule_reload_content(self):
if self.server_is_running:
time.sleep(2)
self.stop_server()
if JavaHandler.movingFile():
self.setup_environment()
self.start_server('threads=18')
return 'Loading finished'
else:
if self.server_is_running:
from android import AndroidService
AndroidService().stop()
time.sleep(0.5)
self.web_view.content_not_found_dialog()
def __init__(self, **kwargs):
self.port = kwargs.get('port')
_reader_should_run = None
_reader_thread = None
self._rx_queue = Queue.Queue()
osc.init()
oscid = osc.listen(ipAddr='0.0.0.0', port=CLIENT_API_PORT)
osc.bind(oscid, self.on_rx, RX_API)
osc.bind(oscid, self.on_command, CMD_API)
self._oscid = oscid
service = AndroidService('RC comms service', 'running')
service.start('service started')
self._service = service
def start_service(self,foo=None):
if self.service:
self.service.stop()
self.service = None
if platform == 'android':
from android import AndroidService
service = AndroidService('KaithemAutomation', 'running')
service.start('service started')
self.service = service
else:
def f():
from src import main
t = threading.Thread(target=f,daemon=True)
t.start()
def build(self):
if platform == 'android':
from android import AndroidService
service = AndroidService('My Activity', 'running')
service.start('service started')
self.service = service
osc.init()
osc_id = osc.listen(ipAddr='127.0.0.1', port=activity_port)
osc.bind(osc_id, self.my_callback, '/message')
# Listen for messages regularly
Clock.schedule_interval(lambda *x: osc.readQueue(osc_id), 0)
btn = Button(text='Push me to see OSC working')
btn.bind(on_release=self.send_msg_to_service)
return btn
def build(self):
#EventLoop.window.bind(on_keyboard=self.hook_keyboard)
if platform == 'android':
service = AndroidService('Sister Radio', 'running')
service.start('service started!')
self.service = service
self.wakelock.start()
osc.init()
oscid = osc.listen(ipAddr='127.0.0.1', port=activityport)
osc.bind(oscid, self.is_playing, '/is_playing')
osc.bind(oscid, self.is_stopped, '/is_stopped')
Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0)
menu = Menu()
return menu
def start(self):
self.logging_function(u'Начинаю запуск бота', 1, time.time())
self.start_reading_osc_queue()
if platform == 'android':
# self.subprocess = autoclass(
# 'org.fogaprod.vkbot.dev.ServiceBotservice')
# mActivity = autoclass(
# 'org.kivy.android.PythonActivity').mActivity
# argument = ''
# self.subprocess.start(mActivity, argument)
self.subprocess = AndroidService('VKBot', 'Бот работает')
self.subprocess.start('Сервис запущен')
else:
self.subprocess = subprocess.Popen(
['python2.7', 'service/main.py'])
self.start_requesting_answers_count()
def __init__(self, **kargs):
super(PedidosWidget, self).__init__(**kargs)
Logger.debug('Cagada')
self.listapedidos = []
self.modify_pedidos = []
if platform == 'android':
from android import AndroidService
service = AndroidService('TpvB3 receptor', 'running')
service.start('service started')
self.service = service
else:
import os, threading
#threading.Thread(target=os.system, args=("python ./service/main.py",)).start()
osc.init()
oscid = osc.listen(ipAddr='127.0.0.1', port=activityport)
osc.bind(oscid, self.mostrar_pedidos, '/sync_pedidos')
Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0)
self.mostrar_pedidos('ok')
def build(self):
self.root = NotificationDemo(self)
if platform == 'android':
try:
self.service = autoclass('org.test.npexample.ServiceMyservice')
mActivity = autoclass(
'org.kivy.android.PythonActivity').mActivity
argument = ''
self.service.start(mActivity, argument)
except:
self.service = AndroidService('Sevice example',
'service is running')
self.service.start('Hello From Service')
else:
Window.system_size = cm(7), cm(12)
self.client.on_connect = self.on_connect
self.client.on_disconnect = self.on_disconnect
Clock.schedule_once(self.try_connecting, 0)
Clock.schedule_interval(self.handle_msg, 0.1)
# def skipp(*a):
# self.root.ids.sm.current = 'main'
# Clock.schedule_once(skipp, 0.5)
return self.root
def on_start(self):
"""Build main application, initialize background service and events."""
self.profile = cProfile.Profile()
self.profile.enable()
logging.info(f'Detected platform "{platform}"')
if platform == 'android':
from android import AndroidService
self.service = AndroidService(title='IRCService')
elif platform in ['linux', 'win']:
from .service import create_service
self.service = threading.Thread(target=create_service,
args=(blinker_namespace, ))
self.service.daemon = True
else:
logging.critical(f'Currently not supported platform!')
sys.exit(1)
self.service.start()
Signal('pubmsg').connect(self.handle_pubmsg)
Signal('whisper').connect(self.handle_whisper)
Signal('joined').connect(self.handle_joined)
