',
+ text,
+ flags=re.MULTILINE,
+ )
+
+ # Lists - Simple single level for now to keep it predictable
+ def unordered_list_repl(match):
+ items = match.group(0).strip().split("\n")
+ html_items = ""
+ for i in items:
+ # Check if it's already a task list item
+ if 'type="checkbox"' in i:
+ html_items += i
+ else:
+ content = i[2:].strip()
+ html_items += f'
{content}
'
+ return f'
{html_items}
'
+
+ text = re.sub(
+ r"((?:^[*-] .*\n?)+)", unordered_list_repl, text, flags=re.MULTILINE
+ )
+
+ def ordered_list_repl(match):
+ items = match.group(0).strip().split("\n")
+ html_items = ""
+ for i in items:
+ content = re.sub(r"^\d+\. ", "", i).strip()
+ html_items += f'
{content}
'
+ return f'{html_items}'
+
+ text = re.sub(
+ r"((?:^\d+\. .*\n?)+)", ordered_list_repl, text, flags=re.MULTILINE
+ )
+
+ # Paragraphs - double newline to p tag
+ parts = text.split("\n\n")
+ processed_parts = []
+ for part in parts:
+ part = part.strip()
+ if not part:
+ continue
+
+ # If it's a placeholder for code block, don't wrap in
+ if part.startswith("[[CB") and part.endswith("]]"):
+ processed_parts.append(part)
+ continue
+
+ # If it already starts with a block tag, don't wrap in
+ if re.match(r"^<(h\d|ul|ol|li|blockquote|hr|div)", part):
+ processed_parts.append(part)
+ else:
+ # Replace single newlines with for line breaks within paragraphs
+ part = part.replace("\n", " ")
+ processed_parts.append(
+ f'
{part}
'
+ )
+
+ text = "\n".join(processed_parts)
+
+ # Restore code blocks
+ for i, code_html in enumerate(code_blocks):
+ text = text.replace(f"[[CB{i}]]", code_html)
+
+ return text
diff --git a/meshchatx/src/backend/meshchat_utils.py b/meshchatx/src/backend/meshchat_utils.py
new file mode 100644
index 0000000..26159da
--- /dev/null
+++ b/meshchatx/src/backend/meshchat_utils.py
@@ -0,0 +1,151 @@
+import base64
+import json
+
+import LXMF
+import RNS.vendor.umsgpack as msgpack
+from LXMF import LXMRouter
+
+
+def parse_bool_query_param(value: str | None) -> bool:
+ if value is None:
+ return False
+ value = value.lower()
+ return value in {"1", "true", "yes", "on"}
+
+
+def message_fields_have_attachments(fields_json: str | None):
+ if not fields_json:
+ return False
+ try:
+ fields = json.loads(fields_json)
+ except Exception:
+ return False
+ if "image" in fields or "audio" in fields:
+ return True
+ if "file_attachments" in fields and isinstance(
+ fields["file_attachments"],
+ list,
+ ):
+ return len(fields["file_attachments"]) > 0
+ return False
+
+
+def has_attachments(lxmf_fields: dict) -> bool:
+ try:
+ if LXMF.FIELD_FILE_ATTACHMENTS in lxmf_fields:
+ return len(lxmf_fields[LXMF.FIELD_FILE_ATTACHMENTS]) > 0
+ if LXMF.FIELD_IMAGE in lxmf_fields:
+ return True
+ if LXMF.FIELD_AUDIO in lxmf_fields:
+ return True
+ return False
+ except Exception:
+ return False
+
+
+def convert_propagation_node_state_to_string(state):
+ state_map = {
+ LXMRouter.PR_IDLE: "idle",
+ LXMRouter.PR_PATH_REQUESTED: "path_requested",
+ LXMRouter.PR_LINK_ESTABLISHING: "link_establishing",
+ LXMRouter.PR_LINK_ESTABLISHED: "link_established",
+ LXMRouter.PR_REQUEST_SENT: "request_sent",
+ LXMRouter.PR_RECEIVING: "receiving",
+ LXMRouter.PR_RESPONSE_RECEIVED: "response_received",
+ LXMRouter.PR_COMPLETE: "complete",
+ LXMRouter.PR_NO_PATH: "no_path",
+ LXMRouter.PR_LINK_FAILED: "link_failed",
+ LXMRouter.PR_TRANSFER_FAILED: "transfer_failed",
+ LXMRouter.PR_NO_IDENTITY_RCVD: "no_identity_received",
+ LXMRouter.PR_NO_ACCESS: "no_access",
+ LXMRouter.PR_FAILED: "failed",
+ }
+
+ if state in state_map:
+ return state_map[state]
+ return "unknown"
+
+
+def convert_db_favourite_to_dict(favourite):
+ created_at = str(favourite["created_at"])
+ if created_at and "+" not in created_at and "Z" not in created_at:
+ created_at += "Z"
+
+ updated_at = str(favourite["updated_at"])
+ if updated_at and "+" not in updated_at and "Z" not in updated_at:
+ updated_at += "Z"
+
+ return {
+ "id": favourite["id"],
+ "destination_hash": favourite["destination_hash"],
+ "display_name": favourite["display_name"],
+ "aspect": favourite["aspect"],
+ "created_at": created_at,
+ "updated_at": updated_at,
+ }
+
+
+def parse_lxmf_display_name(
+ app_data_base64: str | None,
+ default_value: str | None = "Anonymous Peer",
+):
+ if app_data_base64 is None:
+ return default_value
+
+ try:
+ app_data_bytes = base64.b64decode(app_data_base64)
+ display_name = LXMF.display_name_from_app_data(app_data_bytes)
+ if display_name is not None:
+ return display_name
+ except Exception as e:
+ print(f"Failed to parse LXMF display name: {e}")
+
+ return default_value
+
+
+def parse_lxmf_stamp_cost(app_data_base64: str | None):
+ if app_data_base64 is None:
+ return None
+
+ try:
+ app_data_bytes = base64.b64decode(app_data_base64)
+ return LXMF.stamp_cost_from_app_data(app_data_bytes)
+ except Exception as e:
+ print(f"Failed to parse LXMF stamp cost: {e}")
+ return None
+
+
+def parse_nomadnetwork_node_display_name(
+ app_data_base64: str | None,
+ default_value: str | None = "Anonymous Node",
+):
+ if app_data_base64 is None:
+ return default_value
+
+ try:
+ app_data_bytes = base64.b64decode(app_data_base64)
+ return app_data_bytes.decode("utf-8")
+ except Exception as e:
+ print(f"Failed to parse NomadNetwork display name: {e}")
+ return default_value
+
+
+def parse_lxmf_propagation_node_app_data(app_data_base64: str | None):
+ if app_data_base64 is None:
+ return None
+
+ try:
+ app_data_bytes = base64.b64decode(app_data_base64)
+ data = msgpack.unpackb(app_data_bytes)
+
+ if not isinstance(data, list) or len(data) < 4:
+ return None
+
+ return {
+ "enabled": bool(data[2]) if data[2] is not None else False,
+ "timebase": int(data[1]) if data[1] is not None else 0,
+ "per_transfer_limit": int(data[3]) if data[3] is not None else 0,
+ }
+ except Exception as e:
+ print(f"Failed to parse LXMF propagation node app data: {e}")
+ return None
diff --git a/meshchatx/src/backend/message_handler.py b/meshchatx/src/backend/message_handler.py
index 2bdd495..2bdd299 100644
--- a/meshchatx/src/backend/message_handler.py
+++ b/meshchatx/src/backend/message_handler.py
@@ -16,10 +16,9 @@ class MessageHandler:
):
query = """
SELECT * FROM lxmf_messages
- WHERE ((source_hash = ? AND destination_hash = ?)
- OR (destination_hash = ? AND source_hash = ?))
+ WHERE peer_hash = ?
"""
- params = [local_hash, destination_hash, local_hash, destination_hash]
+ params = [destination_hash]
if after_id:
query += " AND id > ?"
@@ -34,75 +33,88 @@ class MessageHandler:
return self.db.provider.fetchall(query, params)
def delete_conversation(self, local_hash, destination_hash):
- query = """
- DELETE FROM lxmf_messages
- WHERE ((source_hash = ? AND destination_hash = ?)
- OR (destination_hash = ? AND source_hash = ?))
- """
- self.db.provider.execute(
- query,
- [local_hash, destination_hash, local_hash, destination_hash],
- )
+ query = "DELETE FROM lxmf_messages WHERE peer_hash = ?"
+ self.db.provider.execute(query, [destination_hash])
def search_messages(self, local_hash, search_term):
like_term = f"%{search_term}%"
query = """
- SELECT source_hash, destination_hash, MAX(timestamp) as max_ts
+ SELECT peer_hash, MAX(timestamp) as max_ts
FROM lxmf_messages
- WHERE (source_hash = ? OR destination_hash = ?)
- AND (title LIKE ? OR content LIKE ? OR source_hash LIKE ? OR destination_hash LIKE ?)
- GROUP BY source_hash, destination_hash
+ WHERE title LIKE ? OR content LIKE ? OR peer_hash LIKE ?
+ GROUP BY peer_hash
"""
- params = [local_hash, local_hash, like_term, like_term, like_term, like_term]
+ params = [like_term, like_term, like_term]
return self.db.provider.fetchall(query, params)
- def get_conversations(self, local_hash, filter_unread=False):
- # Implementation using window functions for better performance
- # This requires SQLite 3.25+
+ def get_conversations(
+ self,
+ local_hash,
+ search=None,
+ filter_unread=False,
+ filter_failed=False,
+ filter_has_attachments=False,
+ limit=None,
+ offset=0,
+ ):
+ # Optimized using peer_hash column and JOINs to avoid N+1 queries
query = """
- WITH RankedMessages AS (
- SELECT *,
- CASE WHEN source_hash = ? THEN destination_hash ELSE source_hash END as peer_hash,
- ROW_NUMBER() OVER (
- PARTITION BY CASE WHEN source_hash = ? THEN destination_hash ELSE source_hash END
- ORDER BY timestamp DESC
- ) as rn
+ SELECT
+ m1.*,
+ a.app_data as peer_app_data,
+ c.display_name as custom_display_name,
+ con.custom_image as contact_image,
+ i.icon_name, i.foreground_colour, i.background_colour,
+ r.last_read_at,
+ (SELECT COUNT(*) FROM lxmf_messages m_failed
+ WHERE m_failed.peer_hash = m1.peer_hash AND m_failed.state = 'failed') as failed_count
+ FROM lxmf_messages m1
+ INNER JOIN (
+ SELECT peer_hash, MAX(timestamp) as max_ts
FROM lxmf_messages
- WHERE source_hash = ? OR destination_hash = ?
- )
- SELECT * FROM RankedMessages WHERE rn = 1
+ WHERE peer_hash IS NOT NULL
+ GROUP BY peer_hash
+ ) m2 ON m1.peer_hash = m2.peer_hash AND m1.timestamp = m2.max_ts
+ LEFT JOIN announces a ON a.destination_hash = m1.peer_hash
+ LEFT JOIN custom_destination_display_names c ON c.destination_hash = m1.peer_hash
+ LEFT JOIN contacts con ON con.remote_identity_hash = m1.peer_hash
+ LEFT JOIN lxmf_user_icons i ON i.destination_hash = m1.peer_hash
+ LEFT JOIN lxmf_conversation_read_state r ON r.destination_hash = m1.peer_hash
"""
- params = [
- local_hash,
- local_hash,
- local_hash,
- local_hash,
- ]
+ params = []
+ where_clauses = []
if filter_unread:
- # For filtering unread, we need to check if there are any received messages from that peer
- query = """
- WITH RankedMessages AS (
- SELECT *,
- CASE WHEN source_hash = ? THEN destination_hash ELSE source_hash END as peer_hash,
- ROW_NUMBER() OVER (
- PARTITION BY CASE WHEN source_hash = ? THEN destination_hash ELSE source_hash END
- ORDER BY timestamp DESC
- ) as rn
- FROM lxmf_messages
- WHERE source_hash = ? OR destination_hash = ?
- )
- SELECT * FROM RankedMessages WHERE rn = 1
- AND EXISTS (
- SELECT 1 FROM lxmf_messages m3
- WHERE m3.source_hash = peer_hash
- AND m3.destination_hash = ?
- AND m3.state = 'received'
- AND m3.is_incoming = 1
- )
- """
- params.append(local_hash)
+ where_clauses.append(
+ "(r.last_read_at IS NULL OR m1.timestamp > strftime('%s', r.last_read_at))"
+ )
- query += " ORDER BY timestamp DESC"
+ if filter_failed:
+ where_clauses.append("m1.state = 'failed'")
+
+ if filter_has_attachments:
+ where_clauses.append(
+ "(m1.fields IS NOT NULL AND m1.fields != '{}' AND m1.fields != '')"
+ )
+
+ if search:
+ like_term = f"%{search}%"
+ # Search in latest message info OR search across ALL messages for this peer
+ where_clauses.append("""
+ (m1.title LIKE ? OR m1.content LIKE ? OR m1.peer_hash LIKE ? OR c.display_name LIKE ?
+ OR m1.peer_hash IN (SELECT peer_hash FROM lxmf_messages WHERE title LIKE ? OR content LIKE ?))
+ """)
+ params.extend(
+ [like_term, like_term, like_term, like_term, like_term, like_term]
+ )
+
+ if where_clauses:
+ query += " WHERE " + " AND ".join(where_clauses)
+
+ query += " GROUP BY m1.peer_hash ORDER BY m1.timestamp DESC"
+
+ if limit is not None:
+ query += " LIMIT ? OFFSET ?"
+ params.extend([limit, offset])
return self.db.provider.fetchall(query, params)
diff --git a/meshchatx/src/backend/nomadnet_downloader.py b/meshchatx/src/backend/nomadnet_downloader.py
new file mode 100644
index 0000000..1c2901a
--- /dev/null
+++ b/meshchatx/src/backend/nomadnet_downloader.py
@@ -0,0 +1,268 @@
+import asyncio
+import io
+import os
+import time
+from collections.abc import Callable
+
+import RNS
+
+# global cache for nomadnet links to avoid re-establishing them for every request
+nomadnet_cached_links = {}
+
+
+class NomadnetDownloader:
+ def __init__(
+ self,
+ destination_hash: bytes,
+ path: str,
+ data: str | None,
+ on_download_success: Callable[[RNS.RequestReceipt], None],
+ on_download_failure: Callable[[str], None],
+ on_progress_update: Callable[[float], None],
+ timeout: int | None = None,
+ ):
+ self.app_name = "nomadnetwork"
+ self.aspects = "node"
+ self.destination_hash = destination_hash
+ self.path = path
+ self.data = data
+ self.timeout = timeout
+ self._download_success_callback = on_download_success
+ self._download_failure_callback = on_download_failure
+ self.on_progress_update = on_progress_update
+ self.request_receipt = None
+ self.is_cancelled = False
+ self.link = None
+
+ # cancel the download
+ def cancel(self):
+ self.is_cancelled = True
+
+ # cancel the request if it exists
+ if self.request_receipt is not None:
+ try:
+ self.request_receipt.cancel()
+ except Exception as e:
+ print(f"Failed to cancel request: {e}")
+
+ # clean up the link if we created it
+ if self.link is not None:
+ try:
+ self.link.teardown()
+ except Exception as e:
+ print(f"Failed to teardown link: {e}")
+
+ # notify that download was cancelled
+ self._download_failure_callback("cancelled")
+
+ # setup link to destination and request download
+ async def download(
+ self,
+ path_lookup_timeout: int = 15,
+ link_establishment_timeout: int = 15,
+ ):
+ # check if cancelled before starting
+ if self.is_cancelled:
+ return
+
+ # use existing established link if it's active
+ if self.destination_hash in nomadnet_cached_links:
+ link = nomadnet_cached_links[self.destination_hash]
+ if link.status is RNS.Link.ACTIVE:
+ print("[NomadnetDownloader] using existing link for request")
+ self.link_established(link)
+ return
+
+ # determine when to timeout
+ timeout_after_seconds = time.time() + path_lookup_timeout
+
+ # check if we have a path to the destination
+ if not RNS.Transport.has_path(self.destination_hash):
+ # we don't have a path, so we need to request it
+ RNS.Transport.request_path(self.destination_hash)
+
+ # wait until we have a path, or give up after the configured timeout
+ while (
+ not RNS.Transport.has_path(self.destination_hash)
+ and time.time() < timeout_after_seconds
+ ):
+ # check if cancelled during path lookup
+ if self.is_cancelled:
+ return
+ await asyncio.sleep(0.1)
+
+ # if we still don't have a path, we can't establish a link, so bail out
+ if not RNS.Transport.has_path(self.destination_hash):
+ self._download_failure_callback("Could not find path to destination.")
+ return
+
+ # check if cancelled before establishing link
+ if self.is_cancelled:
+ return
+
+ # create destination to nomadnet node
+ identity = RNS.Identity.recall(self.destination_hash)
+ destination = RNS.Destination(
+ identity,
+ RNS.Destination.OUT,
+ RNS.Destination.SINGLE,
+ self.app_name,
+ self.aspects,
+ )
+
+ # create link to destination
+ print("[NomadnetDownloader] establishing new link for request")
+ link = RNS.Link(destination, established_callback=self.link_established)
+ self.link = link
+
+ # determine when to timeout
+ timeout_after_seconds = time.time() + link_establishment_timeout
+
+ # wait until we have established a link, or give up after the configured timeout
+ while (
+ link.status is not RNS.Link.ACTIVE and time.time() < timeout_after_seconds
+ ):
+ # check if cancelled during link establishment
+ if self.is_cancelled:
+ return
+ await asyncio.sleep(0.1)
+
+ # if we still haven't established a link, bail out
+ if link.status is not RNS.Link.ACTIVE:
+ self._download_failure_callback("Could not establish link to destination.")
+
+ # link to destination was established, we should now request the download
+ def link_established(self, link):
+ # check if cancelled before requesting
+ if self.is_cancelled:
+ return
+
+ # cache link for using in future requests
+ nomadnet_cached_links[self.destination_hash] = link
+
+ # request download over link
+ self.request_receipt = link.request(
+ self.path,
+ data=self.data,
+ response_callback=self.on_response,
+ failed_callback=self.on_failed,
+ progress_callback=self.on_progress,
+ timeout=self.timeout,
+ )
+
+ # handle successful download
+ def on_response(self, request_receipt: RNS.RequestReceipt):
+ self._download_success_callback(request_receipt)
+
+ # handle failure
+ def on_failed(self, request_receipt=None):
+ self._download_failure_callback("request_failed")
+
+ # handle download progress
+ def on_progress(self, request_receipt):
+ self.on_progress_update(request_receipt.progress)
+
+
+class NomadnetPageDownloader(NomadnetDownloader):
+ def __init__(
+ self,
+ destination_hash: bytes,
+ page_path: str,
+ data: str | None,
+ on_page_download_success: Callable[[str], None],
+ on_page_download_failure: Callable[[str], None],
+ on_progress_update: Callable[[float], None],
+ timeout: int | None = None,
+ ):
+ self.on_page_download_success = on_page_download_success
+ self.on_page_download_failure = on_page_download_failure
+ super().__init__(
+ destination_hash,
+ page_path,
+ data,
+ self.on_download_success,
+ self.on_download_failure,
+ on_progress_update,
+ timeout,
+ )
+
+ # page download was successful, decode the response and send to provided callback
+ def on_download_success(self, request_receipt: RNS.RequestReceipt):
+ micron_markup_response = request_receipt.response.decode("utf-8")
+ self.on_page_download_success(micron_markup_response)
+
+ # page download failed, send error to provided callback
+ def on_download_failure(self, failure_reason):
+ self.on_page_download_failure(failure_reason)
+
+
+class NomadnetFileDownloader(NomadnetDownloader):
+ def __init__(
+ self,
+ destination_hash: bytes,
+ page_path: str,
+ on_file_download_success: Callable[[str, bytes], None],
+ on_file_download_failure: Callable[[str], None],
+ on_progress_update: Callable[[float], None],
+ timeout: int | None = None,
+ ):
+ self.on_file_download_success = on_file_download_success
+ self.on_file_download_failure = on_file_download_failure
+ super().__init__(
+ destination_hash,
+ page_path,
+ None,
+ self.on_download_success,
+ self.on_download_failure,
+ on_progress_update,
+ timeout,
+ )
+
+ # file download was successful, decode the response and send to provided callback
+ def on_download_success(self, request_receipt: RNS.RequestReceipt):
+ # get response
+ response = request_receipt.response
+
+ # handle buffered reader response
+ if isinstance(response, io.BufferedReader):
+ # get file name from metadata
+ file_name = "downloaded_file"
+ metadata = request_receipt.metadata
+ if metadata is not None and "name" in metadata:
+ file_path = metadata["name"].decode("utf-8")
+ file_name = os.path.basename(file_path)
+
+ # get file data
+ file_data: bytes = response.read()
+
+ self.on_file_download_success(file_name, file_data)
+ return
+
+ # check for list response with bytes in position 0, and metadata dict in position 1
+ # e.g: [file_bytes, {name: "filename.ext"}]
+ if isinstance(response, list) and isinstance(response[1], dict):
+ file_data: bytes = response[0]
+ metadata: dict = response[1]
+
+ # get file name from metadata
+ file_name = "downloaded_file"
+ if metadata is not None and "name" in metadata:
+ file_path = metadata["name"].decode("utf-8")
+ file_name = os.path.basename(file_path)
+
+ self.on_file_download_success(file_name, file_data)
+ return
+
+ # try using original response format
+ # unsure if this is actually used anymore now that a buffered reader is provided
+ # have left here just in case...
+ try:
+ file_name: str = response[0]
+ file_data: bytes = response[1]
+ self.on_file_download_success(file_name, file_data)
+ except Exception:
+ self.on_download_failure("unsupported_response")
+
+ # page download failed, send error to provided callback
+ def on_download_failure(self, failure_reason):
+ self.on_file_download_failure(failure_reason)
diff --git a/meshchatx/src/backend/nomadnet_utils.py b/meshchatx/src/backend/nomadnet_utils.py
new file mode 100644
index 0000000..8c202cc
--- /dev/null
+++ b/meshchatx/src/backend/nomadnet_utils.py
@@ -0,0 +1,61 @@
+def convert_nomadnet_string_data_to_map(path_data: str | None):
+ data = {}
+ if path_data is not None:
+ for field in path_data.split("|"):
+ if "=" in field:
+ parts = field.split("=", 1)
+ if len(parts) == 2:
+ variable_name, variable_value = parts
+ data[f"var_{variable_name}"] = variable_value
+ else:
+ print(f"unhandled field: {field}")
+ return data
+
+
+def convert_nomadnet_field_data_to_map(field_data):
+ data = {}
+ if field_data is not None or "{}":
+ try:
+ json_data = field_data
+ if isinstance(json_data, dict):
+ data = {f"field_{key}": value for key, value in json_data.items()}
+ else:
+ return None
+ except Exception as e:
+ print(f"skipping invalid field data: {e}")
+
+ return data
+
+
+class NomadNetworkManager:
+ def __init__(self, config, archiver_manager, database):
+ self.config = config
+ self.archiver_manager = archiver_manager
+ self.database = database
+
+ def archive_page(
+ self,
+ destination_hash: str,
+ page_path: str,
+ content: str,
+ is_manual: bool = False,
+ ):
+ if not is_manual and not self.config.page_archiver_enabled.get():
+ return
+
+ self.archiver_manager.archive_page(
+ destination_hash,
+ page_path,
+ content,
+ max_versions=self.config.page_archiver_max_versions.get(),
+ max_storage_gb=self.config.archives_max_storage_gb.get(),
+ )
+
+ def get_archived_page_versions(self, destination_hash: str, page_path: str):
+ return self.database.misc.get_archived_page_versions(
+ destination_hash,
+ page_path,
+ )
+
+ def flush_all_archived_pages(self):
+ self.database.misc.delete_archived_pages()
diff --git a/meshchatx/src/backend/recovery/__init__.py b/meshchatx/src/backend/recovery/__init__.py
new file mode 100644
index 0000000..5992cca
--- /dev/null
+++ b/meshchatx/src/backend/recovery/__init__.py
@@ -0,0 +1,3 @@
+from .crash_recovery import CrashRecovery
+
+__all__ = ["CrashRecovery"]
diff --git a/meshchatx/src/backend/recovery/crash_recovery.py b/meshchatx/src/backend/recovery/crash_recovery.py
new file mode 100644
index 0000000..9e88b72
--- /dev/null
+++ b/meshchatx/src/backend/recovery/crash_recovery.py
@@ -0,0 +1,301 @@
+import sys
+import os
+import traceback
+import platform
+import shutil
+import sqlite3
+import psutil
+import RNS
+
+
+class CrashRecovery:
+ """
+ A diagnostic utility that intercepts application crashes and provides
+ meaningful error reports and system state analysis.
+ """
+
+ def __init__(
+ self,
+ storage_dir=None,
+ database_path=None,
+ public_dir=None,
+ reticulum_config_dir=None,
+ ):
+ self.storage_dir = storage_dir
+ self.database_path = database_path
+ self.public_dir = public_dir
+ self.reticulum_config_dir = reticulum_config_dir
+ self.enabled = True
+
+ # Check environment variable to allow disabling the recovery system
+ env_val = os.environ.get("MESHCHAT_NO_CRASH_RECOVERY", "").lower()
+ if env_val in ("true", "1", "yes", "on"):
+ self.enabled = False
+
+ def install(self):
+ """
+ Installs the crash recovery exception hook into the system.
+ """
+ if not self.enabled:
+ return
+
+ sys.excepthook = self.handle_exception
+
+ def disable(self):
+ """
+ Disables the crash recovery system manually.
+ """
+ self.enabled = False
+
+ def update_paths(
+ self,
+ storage_dir=None,
+ database_path=None,
+ public_dir=None,
+ reticulum_config_dir=None,
+ ):
+ """
+ Updates the internal paths used for system diagnosis.
+ """
+ if storage_dir:
+ self.storage_dir = storage_dir
+ if database_path:
+ self.database_path = database_path
+ if public_dir:
+ self.public_dir = public_dir
+ if reticulum_config_dir:
+ self.reticulum_config_dir = reticulum_config_dir
+
+ def handle_exception(self, exc_type, exc_value, exc_traceback):
+ """
+ Intercepts unhandled exceptions to provide a detailed diagnosis report.
+ """
+ # Let keyboard interrupts pass through normally
+ if issubclass(exc_type, KeyboardInterrupt):
+ sys.__excepthook__(exc_type, exc_value, exc_traceback)
+ return
+
+ # Use stderr for everything to ensure correct ordering in logs and console
+ out = sys.stderr
+
+ # Print visual separator
+ out.write("\n" + "=" * 70 + "\n")
+ out.write("!!! APPLICATION CRASH DETECTED !!!\n")
+ out.write("=" * 70 + "\n")
+
+ out.write("\nError Summary:\n")
+ out.write(f" Type: {exc_type.__name__}\n")
+ out.write(f" Message: {exc_value}\n")
+
+ out.write("\nSystem Environment Diagnosis:\n")
+ try:
+ self.run_diagnosis(file=out)
+ except Exception as e:
+ out.write(f" [ERROR] Failed to complete diagnosis: {e}\n")
+
+ out.write("\nTechnical Traceback:\n")
+ traceback.print_exception(exc_type, exc_value, exc_traceback, file=out)
+
+ out.write("\n" + "=" * 70 + "\n")
+ out.write("Recovery Suggestions:\n")
+ out.write(" 1. Review the 'System Environment Diagnosis' section above.\n")
+ out.write(
+ " 2. Verify that all dependencies are installed (poetry install or pip install -r requirements.txt).\n"
+ )
+ out.write(
+ " 3. If database corruption is suspected, try starting with --auto-recover.\n"
+ )
+ out.write(
+ " 4. If the issue persists, report it to Ivan over another LXMF client: 7cc8d66b4f6a0e0e49d34af7f6077b5a\n"
+ )
+ out.write("=" * 70 + "\n\n")
+ out.flush()
+
+ # Exit with error code
+ sys.exit(1)
+
+ def run_diagnosis(self, file=sys.stderr):
+ """
+ Performs a series of OS-agnostic checks on the application's environment.
+ """
+ # Basic System Info
+ file.write(
+ f"- OS: {platform.system()} {platform.release()} ({platform.machine()})\n"
+ )
+ file.write(f"- Python: {sys.version.split()[0]}\n")
+
+ # Resource Monitoring
+ try:
+ mem = psutil.virtual_memory()
+ file.write(
+ f"- Memory: {mem.percent}% used ({mem.available / (1024**2):.1f} MB available)\n"
+ )
+ if mem.percent > 95:
+ file.write(" [CRITICAL] System memory is dangerously low!\n")
+ except Exception:
+ pass
+
+ # Filesystem Status
+ if self.storage_dir:
+ file.write(f"- Storage Path: {self.storage_dir}\n")
+ if not os.path.exists(self.storage_dir):
+ file.write(
+ " [ERROR] Storage path does not exist. Check MESHCHAT_STORAGE_DIR.\n"
+ )
+ else:
+ if not os.access(self.storage_dir, os.W_OK):
+ file.write(
+ " [ERROR] Storage path is NOT writable. Check filesystem permissions.\n"
+ )
+
+ try:
+ usage = shutil.disk_usage(self.storage_dir)
+ free_mb = usage.free / (1024**2)
+ file.write(f" - Disk Space: {free_mb:.1f} MB free\n")
+ if free_mb < 50:
+ file.write(
+ " [CRITICAL] Disk space is critically low (< 50MB)!\n"
+ )
+ except Exception:
+ pass
+
+ # Database Integrity
+ if self.database_path:
+ file.write(f"- Database: {self.database_path}\n")
+ if os.path.exists(self.database_path):
+ if os.path.getsize(self.database_path) == 0:
+ file.write(
+ " [WARNING] Database file exists but is empty (0 bytes).\n"
+ )
+ else:
+ try:
+ # Open in read-only mode for safety during crash handling
+ conn = sqlite3.connect(
+ f"file:{self.database_path}?mode=ro", uri=True
+ )
+ cursor = conn.cursor()
+ cursor.execute("PRAGMA integrity_check")
+ res = cursor.fetchone()[0]
+ if res != "ok":
+ file.write(
+ f" [ERROR] Database corruption detected: {res}\n"
+ )
+ else:
+ file.write(" - Integrity: OK\n")
+ conn.close()
+ except sqlite3.DatabaseError as e:
+ file.write(
+ f" [ERROR] Database is unreadable or not a SQLite file: {e}\n"
+ )
+ except Exception as e:
+ file.write(f" [ERROR] Database check failed: {e}\n")
+ else:
+ file.write(" - Database: File not yet created\n")
+
+ # Frontend Assets
+ if self.public_dir:
+ file.write(f"- Frontend Assets: {self.public_dir}\n")
+ if not os.path.exists(self.public_dir):
+ file.write(
+ " [ERROR] Frontend directory is missing. Web interface will fail to load.\n"
+ )
+ else:
+ index_path = os.path.join(self.public_dir, "index.html")
+ if not os.path.exists(index_path):
+ file.write(
+ " [ERROR] index.html not found in frontend directory!\n"
+ )
+ else:
+ file.write(" - Frontend Status: Assets verified\n")
+
+ # Reticulum Status
+ self.run_reticulum_diagnosis(file=file)
+
+ def run_reticulum_diagnosis(self, file=sys.stderr):
+ """
+ Diagnoses the Reticulum Network Stack environment.
+ """
+ file.write("- Reticulum Network Stack:\n")
+
+ # Check config directory
+ config_dir = self.reticulum_config_dir or RNS.Reticulum.configpath
+ file.write(f" - Config Directory: {config_dir}\n")
+
+ if not os.path.exists(config_dir):
+ file.write(" [ERROR] Reticulum config directory does not exist.\n")
+ return
+
+ config_file = os.path.join(config_dir, "config")
+ if not os.path.exists(config_file):
+ file.write(" [ERROR] Reticulum config file is missing.\n")
+ else:
+ try:
+ # Basic config validation
+ with open(config_file, "r") as f:
+ content = f.read()
+ if "[reticulum]" not in content:
+ file.write(
+ " [ERROR] Reticulum config file is invalid (missing [reticulum] section).\n"
+ )
+ else:
+ file.write(" - Config File: OK\n")
+ except Exception as e:
+ file.write(f" [ERROR] Could not read Reticulum config: {e}\n")
+
+ # Extract recent RNS log entries if possible
+ # Check common log file locations
+ log_paths = [
+ os.path.join(config_dir, "logfile"),
+ os.path.join(config_dir, "rnsd.log"),
+ "/var/log/rnsd.log",
+ ]
+
+ found_logs = False
+ for logfile in log_paths:
+ if os.path.exists(logfile):
+ file.write(f" - Recent Log Entries ({logfile}):\n")
+ try:
+ with open(logfile, "r") as f:
+ lines = f.readlines()
+ if not lines:
+ file.write(" (Log file is empty)\n")
+ else:
+ for line in lines[-15:]:
+ if "ERROR" in line or "CRITICAL" in line:
+ file.write(f" > [ALERT] {line.strip()}\n")
+ else:
+ file.write(f" > {line.strip()}\n")
+ found_logs = True
+ break # Stop at first found log file
+ except Exception as e:
+ file.write(f" [ERROR] Could not read logfile: {e}\n")
+
+ if not found_logs:
+ file.write(" - Logs: No RNS log files found in standard locations.\n")
+
+ # Check for interfaces and transport status
+ try:
+ # Try to get more info from RNS if it's already running
+ if hasattr(RNS.Transport, "interfaces") and RNS.Transport.interfaces:
+ file.write(f" - Active Interfaces: {len(RNS.Transport.interfaces)}\n")
+ for iface in RNS.Transport.interfaces:
+ status = "Active" if iface.online else "Offline"
+ file.write(f" > {iface} [{status}]\n")
+ else:
+ file.write(
+ " - Active Interfaces: None registered (Reticulum may not be initialized yet)\n"
+ )
+ except Exception:
+ pass
+
+ # Check for common port conflicts
+ common_ports = [4242, 8000, 8080] # Reticulum default is often 4242
+ for port in common_ports:
+ try:
+ for conn in psutil.net_connections():
+ if conn.laddr.port == port and conn.status == "LISTEN":
+ file.write(
+ f" [ALERT] Port {port} is already in use by PID {conn.pid}. Potential conflict.\n"
+ )
+ except Exception:
+ pass
diff --git a/meshchatx/src/backend/ringtone_manager.py b/meshchatx/src/backend/ringtone_manager.py
index 8164ce6..7a87b6e 100644
--- a/meshchatx/src/backend/ringtone_manager.py
+++ b/meshchatx/src/backend/ringtone_manager.py
@@ -38,7 +38,7 @@ class RingtoneManager:
filename = f"ringtone_{secrets.token_hex(8)}.opus"
opus_path = os.path.join(self.storage_dir, filename)
- subprocess.run(
+ subprocess.run( # noqa: S603
[
self.ffmpeg_path,
"-i",
diff --git a/meshchatx/src/backend/telephone_manager.py b/meshchatx/src/backend/telephone_manager.py
index 9320aff..9b22c17 100644
--- a/meshchatx/src/backend/telephone_manager.py
+++ b/meshchatx/src/backend/telephone_manager.py
@@ -1,10 +1,34 @@
import asyncio
+import os
import time
import RNS
from LXST import Telephone
+class Tee:
+ def __init__(self, sink):
+ self.sinks = [sink]
+
+ def add_sink(self, sink):
+ if sink not in self.sinks:
+ self.sinks.append(sink)
+
+ def remove_sink(self, sink):
+ if sink in self.sinks:
+ self.sinks.remove(sink)
+
+ def handle_frame(self, frame, source):
+ for sink in self.sinks:
+ try:
+ sink.handle_frame(frame, source)
+ except Exception as e:
+ RNS.log(f"Tee: Error in sink handle_frame: {e}", RNS.LOG_ERROR)
+
+ def can_receive(self, from_source=None):
+ return any(sink.can_receive(from_source) for sink in self.sinks)
+
+
class TelephoneManager:
# LXST Status Constants for reference:
# 0: STATUS_BUSY
@@ -15,9 +39,20 @@ class TelephoneManager:
# 5: STATUS_CONNECTING
# 6: STATUS_ESTABLISHED
- def __init__(self, identity: RNS.Identity, config_manager=None):
+ def __init__(
+ self, identity: RNS.Identity, config_manager=None, storage_dir=None, db=None
+ ):
self.identity = identity
self.config_manager = config_manager
+ self.storage_dir = storage_dir
+ self.db = db
+ self.get_name_for_identity_hash = None
+ self.recordings_dir = (
+ os.path.join(storage_dir, "recordings") if storage_dir else None
+ )
+ if self.recordings_dir:
+ os.makedirs(self.recordings_dir, exist_ok=True)
+
self.telephone = None
self.on_ringing_callback = None
self.on_established_callback = None
@@ -27,6 +62,19 @@ class TelephoneManager:
self.call_status_at_end = None
self.call_is_incoming = False
+ # Manual mute overrides in case LXST internal muting is buggy
+ self.transmit_muted = False
+ self.receive_muted = False
+
+ self.initiation_status = None
+ self.initiation_target_hash = None
+ self.on_initiation_status_callback = None
+
+ @property
+ def is_recording(self):
+ # Disabled for now
+ return False
+
def init_telephone(self):
if self.telephone is not None:
return
@@ -34,6 +82,12 @@ class TelephoneManager:
self.telephone = Telephone(self.identity)
# Disable busy tone played on caller side when remote side rejects, or doesn't answer
self.telephone.set_busy_tone_time(0)
+
+ # Set initial profile from config
+ if self.config_manager:
+ profile_id = self.config_manager.telephone_audio_profile_id.get()
+ self.telephone.switch_profile(profile_id)
+
self.telephone.set_ringing_callback(self.on_telephone_ringing)
self.telephone.set_established_callback(self.on_telephone_call_established)
self.telephone.set_ended_callback(self.on_telephone_call_ended)
@@ -61,6 +115,11 @@ class TelephoneManager:
def on_telephone_call_established(self, caller_identity: RNS.Identity):
# Update start time to when it was actually established for duration calculation
self.call_start_time = time.time()
+
+ # Recording disabled for now due to stability issues with LXST
+ # if self.config_manager and self.config_manager.call_recording_enabled.get():
+ # self.start_recording()
+
if self.on_established_callback:
self.on_established_callback(caller_identity)
@@ -72,34 +131,170 @@ class TelephoneManager:
if self.on_ended_callback:
self.on_ended_callback(caller_identity)
+ def start_recording(self):
+ # Disabled for now as LXST does not have a Tee to use
+ pass
+
+ def stop_recording(self):
+ # Disabled for now
+ pass
+
def announce(self, attached_interface=None):
if self.telephone:
self.telephone.announce(attached_interface=attached_interface)
+ def _update_initiation_status(self, status, target_hash=None):
+ self.initiation_status = status
+ if target_hash is not None or status is None:
+ self.initiation_target_hash = target_hash
+ if self.on_initiation_status_callback:
+ try:
+ self.on_initiation_status_callback(
+ self.initiation_status, self.initiation_target_hash
+ )
+ except Exception as e:
+ RNS.log(
+ f"TelephoneManager: Error in initiation status callback: {e}",
+ RNS.LOG_ERROR,
+ )
+
async def initiate(self, destination_hash: bytes, timeout_seconds: int = 15):
if self.telephone is None:
msg = "Telephone is not initialized"
raise RuntimeError(msg)
- # Find destination identity
- destination_identity = RNS.Identity.recall(destination_hash)
- if destination_identity is None:
- # If not found by identity hash, try as destination hash
- destination_identity = RNS.Identity.recall(
- destination_hash,
- ) # Identity.recall takes identity hash
-
- if destination_identity is None:
- msg = "Destination identity not found"
+ if self.telephone.busy or self.initiation_status:
+ msg = "Telephone is already in use"
raise RuntimeError(msg)
- # In LXST, we just call the identity. Telephone class handles path requests.
- # But we might want to ensure a path exists first for better UX,
- # similar to how the old MeshChat did it.
+ destination_hash_hex = destination_hash.hex()
+ self._update_initiation_status("Resolving identity...", destination_hash_hex)
- # For now, let's just use the telephone.call method which is threaded.
- # We need to run it in a thread since it might block.
- self.call_start_time = time.time()
- self.call_is_incoming = False
- await asyncio.to_thread(self.telephone.call, destination_identity)
- return self.telephone.active_call
+ try:
+ # Find destination identity
+ destination_identity = RNS.Identity.recall(destination_hash)
+
+ # If identity not found, check if it's a destination hash in our announces
+ if destination_identity is None and self.db:
+ announce = self.db.announces.get_announce_by_hash(destination_hash_hex)
+ if announce:
+ identity_hash = bytes.fromhex(announce["identity_hash"])
+ destination_identity = RNS.Identity.recall(identity_hash)
+
+ if destination_identity is None:
+ self._update_initiation_status("Discovering path/identity...")
+ RNS.Transport.request_path(destination_hash)
+
+ # Wait for identity to appear
+ start_wait = time.time()
+ while time.time() - start_wait < timeout_seconds:
+ await asyncio.sleep(0.5)
+ destination_identity = RNS.Identity.recall(destination_hash)
+ if destination_identity:
+ break
+
+ if self.db:
+ announce = self.db.announces.get_announce_by_hash(
+ destination_hash_hex
+ )
+ if announce:
+ identity_hash = bytes.fromhex(announce["identity_hash"])
+ destination_identity = RNS.Identity.recall(identity_hash)
+ if destination_identity:
+ break
+
+ if destination_identity is None:
+ self._update_initiation_status(None, None)
+ msg = "Destination identity not found"
+ raise RuntimeError(msg)
+
+ if not RNS.Transport.has_path(destination_hash):
+ self._update_initiation_status("Requesting path...")
+ RNS.Transport.request_path(destination_hash)
+
+ self._update_initiation_status("Dialing...")
+ self.call_start_time = time.time()
+ self.call_is_incoming = False
+
+ # Use a thread for the blocking LXST call
+ await asyncio.to_thread(self.telephone.call, destination_identity)
+ return self.telephone.active_call
+
+ except Exception as e:
+ self._update_initiation_status(f"Failed: {str(e)}")
+ await asyncio.sleep(3)
+ raise
+ finally:
+ self._update_initiation_status(None, None)
+
+ def mute_transmit(self):
+ if self.telephone:
+ # Manual override as LXST internal muting can be buggy
+ if hasattr(self.telephone, "audio_input") and self.telephone.audio_input:
+ try:
+ self.telephone.audio_input.stop()
+ except Exception as e:
+ RNS.log(f"Failed to stop audio input for mute: {e}", RNS.LOG_ERROR)
+
+ # Still call the internal method just in case it does something useful
+ try:
+ self.telephone.mute_transmit()
+ except Exception: # noqa: S110
+ pass
+
+ self.transmit_muted = True
+
+ def unmute_transmit(self):
+ if self.telephone:
+ # Manual override as LXST internal muting can be buggy
+ if hasattr(self.telephone, "audio_input") and self.telephone.audio_input:
+ try:
+ self.telephone.audio_input.start()
+ except Exception as e:
+ RNS.log(
+ f"Failed to start audio input for unmute: {e}", RNS.LOG_ERROR
+ )
+
+ # Still call the internal method just in case
+ try:
+ self.telephone.unmute_transmit()
+ except Exception: # noqa: S110
+ pass
+
+ self.transmit_muted = False
+
+ def mute_receive(self):
+ if self.telephone:
+ # Manual override as LXST internal muting can be buggy
+ if hasattr(self.telephone, "audio_output") and self.telephone.audio_output:
+ try:
+ self.telephone.audio_output.stop()
+ except Exception as e:
+ RNS.log(f"Failed to stop audio output for mute: {e}", RNS.LOG_ERROR)
+
+ # Still call the internal method just in case
+ try:
+ self.telephone.mute_receive()
+ except Exception: # noqa: S110
+ pass
+
+ self.receive_muted = True
+
+ def unmute_receive(self):
+ if self.telephone:
+ # Manual override as LXST internal muting can be buggy
+ if hasattr(self.telephone, "audio_output") and self.telephone.audio_output:
+ try:
+ self.telephone.audio_output.start()
+ except Exception as e:
+ RNS.log(
+ f"Failed to start audio output for unmute: {e}", RNS.LOG_ERROR
+ )
+
+ # Still call the internal method just in case
+ try:
+ self.telephone.unmute_receive()
+ except Exception: # noqa: S110
+ pass
+
+ self.receive_muted = False
diff --git a/meshchatx/src/backend/translator_handler.py b/meshchatx/src/backend/translator_handler.py
index 3946acc..ac12b3f 100644
--- a/meshchatx/src/backend/translator_handler.py
+++ b/meshchatx/src/backend/translator_handler.py
@@ -64,7 +64,8 @@ LANGUAGE_CODE_TO_NAME = {
class TranslatorHandler:
- def __init__(self, libretranslate_url: str | None = None):
+ def __init__(self, libretranslate_url: str | None = None, enabled: bool = False):
+ self.enabled = enabled
self.libretranslate_url = libretranslate_url or os.getenv(
"LIBRETRANSLATE_URL",
"http://localhost:5000",
@@ -76,6 +77,9 @@ class TranslatorHandler:
def get_supported_languages(self, libretranslate_url: str | None = None):
languages = []
+ if not self.enabled:
+ return languages
+
url = libretranslate_url or self.libretranslate_url
if self.has_requests:
@@ -131,6 +135,10 @@ class TranslatorHandler:
use_argos: bool = False,
libretranslate_url: str | None = None,
) -> dict[str, Any]:
+ if not self.enabled:
+ msg = "Translator is disabled"
+ raise RuntimeError(msg)
+
if not text:
msg = "Text cannot be empty"
raise ValueError(msg)
diff --git a/meshchatx/src/backend/voicemail_manager.py b/meshchatx/src/backend/voicemail_manager.py
index ebbd1e2..47e4f44 100644
--- a/meshchatx/src/backend/voicemail_manager.py
+++ b/meshchatx/src/backend/voicemail_manager.py
@@ -141,8 +141,34 @@ class VoicemailManager:
wav_path = os.path.join(self.greetings_dir, "greeting.wav")
try:
- # espeak-ng to WAV
- subprocess.run([self.espeak_path, "-w", wav_path, text], check=True)
+ # espeak-ng to WAV with improved parameters
+ speed = str(self.config.voicemail_tts_speed.get())
+ pitch = str(self.config.voicemail_tts_pitch.get())
+ voice = self.config.voicemail_tts_voice.get()
+ gap = str(self.config.voicemail_tts_word_gap.get())
+
+ cmd = [
+ self.espeak_path,
+ "-s",
+ speed,
+ "-p",
+ pitch,
+ "-g",
+ gap,
+ "-k",
+ "10",
+ "-v",
+ voice,
+ "-w",
+ wav_path,
+ text,
+ ]
+
+ RNS.log(
+ f"Voicemail: Generating greeting with command: {' '.join(cmd)}",
+ RNS.LOG_DEBUG,
+ )
+ subprocess.run(cmd, check=True) # noqa: S603
# Convert WAV to Opus
return self.convert_to_greeting(wav_path)
@@ -160,7 +186,7 @@ class VoicemailManager:
if os.path.exists(opus_path):
os.remove(opus_path)
- subprocess.run(
+ subprocess.run( # noqa: S603
[
self.ffmpeg_path,
"-i",
@@ -169,6 +195,10 @@ class VoicemailManager:
"libopus",
"-b:a",
"16k",
+ "-ar",
+ "48000",
+ "-ac",
+ "1",
"-vbr",
"on",
opus_path,
@@ -214,11 +244,16 @@ class VoicemailManager:
RNS.LOG_DEBUG,
)
+ active_call_remote_identity = (
+ telephone.active_call.get_remote_identity()
+ if (telephone and telephone.active_call)
+ else None
+ )
if (
telephone
and telephone.active_call
- and telephone.active_call.get_remote_identity().hash
- == caller_identity.hash
+ and active_call_remote_identity
+ and active_call_remote_identity.hash == caller_identity.hash
and telephone.call_status == 4 # Ringing
):
RNS.log(
@@ -232,10 +267,17 @@ class VoicemailManager:
RNS.LOG_DEBUG,
)
if telephone.active_call:
- RNS.log(
- f"Voicemail: Active call remote: {RNS.prettyhexrep(telephone.active_call.get_remote_identity().hash)}",
- RNS.LOG_DEBUG,
- )
+ remote_identity = telephone.active_call.get_remote_identity()
+ if remote_identity:
+ RNS.log(
+ f"Voicemail: Active call remote: {RNS.prettyhexrep(remote_identity.hash)}",
+ RNS.LOG_DEBUG,
+ )
+ else:
+ RNS.log(
+ "Voicemail: Active call remote identity not found",
+ RNS.LOG_DEBUG,
+ )
threading.Thread(target=voicemail_job, daemon=True).start()
@@ -360,6 +402,9 @@ class VoicemailManager:
threading.Thread(target=session_job, daemon=True).start()
def start_recording(self, caller_identity):
+ # Disabled for now
+ return
+
telephone = self.telephone_manager.telephone
if not telephone or not telephone.active_call:
return
@@ -370,17 +415,12 @@ class VoicemailManager:
try:
self.recording_sink = OpusFileSink(filepath)
- # Ensure samplerate is set to avoid TypeError in LXST Opus codec
- # which expects sink to have a valid samplerate attribute
self.recording_sink.samplerate = 48000
- # Connect the caller's audio source to our sink
- # active_call.audio_source is a LinkSource that feeds into receive_mixer
- # We want to record what we receive.
self.recording_pipeline = Pipeline(
- source=telephone.active_call.audio_source,
- codec=Null(),
- sink=self.recording_sink,
+ telephone.active_call.audio_source,
+ Null(),
+ self.recording_sink,
)
self.recording_pipeline.start()
@@ -402,7 +442,13 @@ class VoicemailManager:
try:
duration = int(time.time() - self.recording_start_time)
- self.recording_pipeline.stop()
+
+ if self.recording_pipeline:
+ self.recording_pipeline.stop()
+
+ if self.recording_sink:
+ self.recording_sink.stop()
+
self.recording_sink = None
self.recording_pipeline = None
@@ -446,6 +492,9 @@ class VoicemailManager:
self.is_recording = False
def start_greeting_recording(self):
+ # Disabled for now
+ return
+
telephone = self.telephone_manager.telephone
if not telephone:
return
@@ -469,11 +518,12 @@ class VoicemailManager:
self.greeting_recording_sink.samplerate = 48000
self.greeting_recording_pipeline = Pipeline(
- source=telephone.audio_input,
- codec=Null(),
- sink=self.greeting_recording_sink,
+ telephone.audio_input,
+ Null(),
+ self.greeting_recording_sink,
)
self.greeting_recording_pipeline.start()
+
self.is_greeting_recording = True
RNS.log("Voicemail: Started recording greeting from mic", RNS.LOG_DEBUG)
except Exception as e:
@@ -487,7 +537,12 @@ class VoicemailManager:
return
try:
- self.greeting_recording_pipeline.stop()
+ if self.greeting_recording_pipeline:
+ self.greeting_recording_pipeline.stop()
+
+ if self.greeting_recording_sink:
+ self.greeting_recording_sink.stop()
+
self.greeting_recording_sink = None
self.greeting_recording_pipeline = None
self.is_greeting_recording = False