def __init__(self, panel):
from pyphone.controllers import GammuController, IncomingCallEvent, EndCallEvent
super().__init__(panel)
panel.bind_on_raise(self._on_raise)
controllers.get(GammuController).bind(IncomingCallEvent, self._on_incoming_call)
controllers.get(GammuController).bind(EndCallEvent, self._on_end_call)
def _fetch_contacts_worker(self):
from pyphone.controllers import CallController
try:
self._fetch_contacts()
except Exception as e:
error_message = "{}: {}".format(type(e).__name__, e)
self._log.exception(error_message)
controllers.get(CallController).show_error("Authorization failed", error_message)
def show_error(self, error_title, error_detail):
from pyphone.controllers import TopController
panel = self.panel.main_panel.ErrorPanel
panel.error_title.configure(text=error_title)
panel.error_detail.configure(text=error_detail)
controllers.get(TopController).show_call_panel()
self.panel.main_panel.show_panel(ErrorPanel)
def _decline_call(self):
from pyphone.controllers import CallController, GammuController
def command_finished(name, result, error, percents):
if error is not None:
controllers.get(CallController).show_error(
"Could not decline call", error)
controllers.get(GammuController).enqueue_command(
"CancelCall", (0, True), command_finished)
def show_ongoing_call_panel(self):
from pyphone.controllers import ContactsController, DialController, TopController
phone_number = controllers.get(DialController).get_phone_number()
contact = controllers.get(ContactsController).find_contact_by_number(phone_number)
caller_id = phone_number if contact is None else contact.display_name
self.panel.main_panel.OngoingCallPanel.caller_id_text.set(caller_id)
controllers.get(TopController).show_call_panel()
self.panel.main_panel.show_panel(OngoingCallPanel)
def _get_battery_status(self):
from pyphone.controllers import GammuController
def set_battery_status(name, result, error, percents):
if not self.stopped.isSet():
battery_percent = int(result["BatteryPercent"]) if error is None else 0
self.panel.battery_status_bar.configure(value=battery_percent)
self.panel.battery_status_text.configure(text="{} %".format(battery_percent))
controllers.get(GammuController).enqueue_command("GetBatteryCharge", callback=set_battery_status)
def _dial_number(self):
from pyphone.controllers import CallController, GammuController
def command_finished(name, result, error, percents):
if error is None:
controllers.get(CallController).show_ongoing_call_panel()
else:
controllers.get(CallController).show_error(
"Could not initiate call", error)
controllers.get(GammuController).enqueue_command(
"DialVoice", (self.get_phone_number(), ), command_finished)
def _answer_call(self):
from pyphone.controllers import CallController, GammuController
def command_finished(name, result, error, percents):
if error is None:
controllers.get(CallController).show_ongoing_call_panel()
else:
controllers.get(CallController).show_error(
"Could not accept call", error)
controllers.get(GammuController).enqueue_command(
"AnswerCall", (0, True), command_finished)
def _on_raise(self):
from pyphone.controllers import GAuthController, CallController
self._people_service = controllers.get(GAuthController).people_service
if self._people_service is None:
controllers.get(CallController).show_gauth_panel()
return
if self.contacts is None:
self.contacts = []
self._fetch_contacts_thread = threading.Thread(target=self._fetch_contacts_worker, daemon=True)
self._fetch_contacts_thread.start()
def __init__(self, panel):
from pyphone.controllers import TopController, WindowController
super().__init__(panel)
self.panel.call_button.configure(
command=lambda: controllers.get(TopController).show_call_panel())
self.panel.message_button.configure(command=lambda: controllers.get(
TopController).show_message_panel())
self.panel.info_button.configure(
command=lambda: controllers.get(TopController).show_info_panel())
self.panel.desktop_button.configure(
command=lambda: controllers.get(WindowController).exit())
def _get_connection_info(self):
from pyphone.controllers import GammuController
def set_connection_info(name, result, error, percents):
if not self.stopped.isSet():
signal_percent = int(result["SignalPercent"]) if error is None else 0
signal_strength = int(result["SignalStrength"]) if error is None else 0
self.panel.signal_status_bar.configure(value=signal_percent)
self.panel.signal_status_text.configure(text="{} dBm".format(signal_strength))
controllers.get(GammuController).enqueue_command("GetSignalQuality", callback=set_connection_info)
return
def _update_worker(self):
from pyphone.controllers import GammuController
while not self.stopped.isSet():
if self.panel_visible and controllers.get(GammuController).connected.isSet():
self._get_system_info()
self._get_connection_info()
self._get_battery_status()
time.sleep(5)
def _on_contacts_tree_select(self, event):
from pyphone.controllers import DialController, CallController
selection = self._contacts_tree.selection()
if len(selection) < 1:
return
item = self._contacts_tree.item(selection[0])
item_text = item["text"]
# expand / collapse item
self._contacts_tree.item(selection[0], open=not item["open"])
# copy to clipboard
pyperclip.copy(item_text)
# copy any phone number to dial pad
if re.match("^[+0-9]+$", item_text):
controllers.get(DialController).set_phone_number(item_text)
controllers.get(CallController).show_dial_panel()
def _authorize_worker(self):
from pyphone.controllers import CallController
try:
if self._client_id is None or self._client_secret is None:
raise ValueError("client_id and/or client_secret not set")
http = oauth2_flow.authorize(self._client_id, self._client_secret,
self._scope, self._user_agent,
_credentials_path)
self.people_service = build("people",
"v1",
http=http,
cache_discovery=False)
except Exception as e:
error_message = "{}: {}".format(type(e).__name__, e)
self._log.error("authorization failed: {}".format(error_message))
controllers.get(CallController).show_error("Authorization failed",
error_message)
self.panel.load_contacts_button.configure(state="normal")
controllers.get(CallController).show_contacts_panel()
def _get_system_info(self):
from pyphone.controllers import GammuController
system_info = []
system_info_commands = [
"GetManufacturer",
"GetModel",
"GetFirmware",
"GetNetworkInfo",
"GetSecurityStatus",
"GetDisplayStatus",
"GetSMSStatus",
"GetCalendarStatus",
"GetFileSystemStatus",
"GetIMEI",
"GetOriginalIMEI",
"GetSIMIMSI",
"GetPPM"
]
def add_system_info(name, result, error, percents):
system_info.append((name, result if error is None else error))
for command in system_info_commands:
controllers.get(GammuController).enqueue_command(command, callback=add_system_info)
while len(system_info) < len(system_info_commands):
if self.stopped.wait(0.1):
return
for entry in self.panel.system_info_tree.get_children():
self.panel.system_info_tree.delete(entry)
for entry in system_info:
key = entry[0]
value = entry[1] if entry[1] is not None else ""
self.panel.system_info_tree.insert("", END, text=key, values=(value,))
def show_call_panel(self):
from pyphone.controllers import CallController
if self.panel.show_panel is not CallPanel:
self.panel.show_panel(CallPanel)
controllers.get(CallController).show_dial_panel()
def _on_incoming_call(self, event):
from pyphone.controllers import DialController
controllers.get(DialController).set_phone_number(event.number)
self.show_incoming_call_panel()
def command_finished(name, result, error, percents):
if error is not None:
controllers.get(CallController).show_error(
"Could not decline call", error)
def command_finished(name, result, error, percents):
if error is None:
controllers.get(CallController).show_ongoing_call_panel()
else:
controllers.get(CallController).show_error(
"Could not accept call", error)
