diff --git a/.gitea/workflows/apk.yaml b/.gitea/workflows/apk.yaml
index db63776..5ddefac 100644
--- a/.gitea/workflows/apk.yaml
+++ b/.gitea/workflows/apk.yaml
@@ -10,8 +10,22 @@ jobs:
- uses: actions/checkout@v1
with:
subpath: dialer/
- - uses: icing/flutter@main
+ - uses: docker://git.gmoker.com/icing/flutter:main
- uses: actions/upload-artifact@v1
with:
name: icing-dialer-${{ gitea.ref_name }}-${{ gitea.run_id }}.apk
path: build/app/outputs/flutter-apk/app-release.apk
+
+ build-stealth:
+ runs-on: debian
+ steps:
+ - uses: actions/checkout@v1
+ with:
+ subpath: dialer/
+ - uses: docker://git.gmoker.com/icing/flutter:main
+ with:
+ args: "build apk --dart-define=STEALTH=true"
+ - uses: actions/upload-artifact@v1
+ with:
+ name: icing-dialer-stealth-${{ gitea.ref_name }}-${{ gitea.run_id }}.apk
+ path: build/app/outputs/flutter-apk/app-release.apk
diff --git a/dialer/android/.gitignore b/dialer/android/.gitignore
index e6d71b3..ebc61c7 100644
--- a/dialer/android/.gitignore
+++ b/dialer/android/.gitignore
@@ -7,6 +7,7 @@ gradle-wrapper.jar
/gradle.properties
GeneratedPluginRegistrant.java
gradle.properties
+.cxx
# Remember to never publicly share your keystore.
# See https://flutter.dev/to/reference-keystore
diff --git a/dialer/android/app/src/main/AndroidManifest.xml b/dialer/android/app/src/main/AndroidManifest.xml
index e0de6a4..95b4a91 100644
--- a/dialer/android/app/src/main/AndroidManifest.xml
+++ b/dialer/android/app/src/main/AndroidManifest.xml
@@ -1,13 +1,17 @@
-
-
+
+
+
+
-
-
-
+
+
+
+
+
-
+ android:name="io.flutter.embedding.android.NormalTheme"
+ android:resource="@style/NormalTheme" />
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
+
+
-
+
\ No newline at end of file
diff --git a/dialer/android/app/src/main/kotlin/com/icing/dialer/activities/MainActivity.kt b/dialer/android/app/src/main/kotlin/com/icing/dialer/activities/MainActivity.kt
index a2397d6..2fe4eb9 100644
--- a/dialer/android/app/src/main/kotlin/com/icing/dialer/activities/MainActivity.kt
+++ b/dialer/android/app/src/main/kotlin/com/icing/dialer/activities/MainActivity.kt
@@ -1,54 +1,91 @@
package com.icing.dialer.activities
+import android.Manifest
+import android.app.role.RoleManager
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
import android.database.Cursor
+import android.net.Uri
+import android.os.Build
import android.os.Bundle
import android.provider.CallLog
-import io.flutter.embedding.android.FlutterActivity
-import io.flutter.embedding.engine.FlutterEngine
-import io.flutter.plugin.common.MethodCall
-import io.flutter.plugin.common.MethodChannel
+import android.telecom.TelecomManager
+import android.util.Log
+import androidx.core.content.ContextCompat
import com.icing.dialer.KeystoreHelper
import com.icing.dialer.services.CallService
+import com.icing.dialer.services.MyInCallService
+import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.MethodChannel
-class MainActivity: FlutterActivity() {
- // Existing channel for keystore operations.
+class MainActivity : FlutterActivity() {
private val KEYSTORE_CHANNEL = "com.example.keystore"
- // New channel for call log access.
private val CALLLOG_CHANNEL = "com.example.calllog"
-
private val CALL_CHANNEL = "call_service"
+ private val TAG = "MainActivity"
+ private val REQUEST_CODE_SET_DEFAULT_DIALER = 1001
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ Log.d(TAG, "onCreate started")
+ Log.d(TAG, "Waiting for Flutter to signal permissions")
+ }
override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
super.configureFlutterEngine(flutterEngine)
+ Log.d(TAG, "Configuring Flutter engine")
- // Call service channel
- MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL).setMethodCallHandler { call, result ->
- when (call.method) {
- "makeGsmCall" -> {
- val phoneNumber = call.argument("phoneNumber")
- if (phoneNumber != null) {
- CallService.makeGsmCall(this, phoneNumber)
- result.success("Calling $phoneNumber")
- } else {
- result.error("INVALID_PHONE_NUMBER", "Phone number is required", null)
- }
- }
- "hangUpCall" -> {
- CallService.hangUpCall(this)
- result.success("Call ended")
- }
- else -> result.notImplemented()
- }
- }
-
- // Set up the keystore channel.
- MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL)
+ MyInCallService.channel = MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL)
+ MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL)
.setMethodCallHandler { call, result ->
- // Delegate method calls to KeystoreHelper.
- KeystoreHelper(call, result).handleMethodCall()
+ when (call.method) {
+ "permissionsGranted" -> {
+ Log.d(TAG, "Received permissionsGranted from Flutter")
+ checkAndRequestDefaultDialer()
+ result.success(true)
+ }
+ "makeGsmCall" -> {
+ val phoneNumber = call.argument("phoneNumber")
+ if (phoneNumber != null) {
+ val success = CallService.makeGsmCall(this, phoneNumber)
+ if (success) {
+ result.success(mapOf("status" to "calling", "phoneNumber" to phoneNumber))
+ } else {
+ result.error("CALL_FAILED", "Failed to initiate call", null)
+ }
+ } else {
+ result.error("INVALID_PHONE_NUMBER", "Phone number is required", null)
+ }
+ }
+ "hangUpCall" -> {
+ val success = CallService.hangUpCall(this)
+ if (success) {
+ result.success(mapOf("status" to "ended"))
+ } else {
+ result.error("HANGUP_FAILED", "Failed to end call", null)
+ }
+ }
+ "answerCall" -> {
+ val success = MyInCallService.currentCall?.let {
+ it.answer(0) // 0 for default video state (audio-only)
+ Log.d(TAG, "Answered call")
+ true
+ } ?: false
+ if (success) {
+ result.success(mapOf("status" to "answered"))
+ } else {
+ result.error("ANSWER_FAILED", "No active call to answer", null)
+ }
+ }
+ else -> result.notImplemented()
+ }
}
- // Set up the call log channel.
+ MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL)
+ .setMethodCallHandler { call, result -> KeystoreHelper(call, result).handleMethodCall() }
+
MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALLLOG_CHANNEL)
.setMethodCallHandler { call, result ->
if (call.method == "getCallLogs") {
@@ -60,35 +97,78 @@ class MainActivity: FlutterActivity() {
}
}
- /**
- * Queries the Android call log and returns a list of maps.
- * Each map contains keys: "number", "type", "date", and "duration".
- */
+ private fun checkAndRequestDefaultDialer() {
+ val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager
+ val currentDefault = telecomManager.defaultDialerPackage
+ Log.d(TAG, "Current default dialer: $currentDefault, My package: $packageName")
+
+ if (currentDefault != packageName) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ val roleManager = getSystemService(Context.ROLE_SERVICE) as RoleManager
+ if (roleManager.isRoleAvailable(RoleManager.ROLE_DIALER) && !roleManager.isRoleHeld(RoleManager.ROLE_DIALER)) {
+ val intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_DIALER)
+ startActivityForResult(intent, REQUEST_CODE_SET_DEFAULT_DIALER)
+ Log.d(TAG, "Launched RoleManager intent for default dialer on API 29+")
+ } else {
+ Log.d(TAG, "RoleManager: Available=${roleManager.isRoleAvailable(RoleManager.ROLE_DIALER)}, Held=${roleManager.isRoleHeld(RoleManager.ROLE_DIALER)}")
+ }
+ } else {
+ val intent = Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER)
+ .putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, packageName)
+ .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ try {
+ startActivityForResult(intent, REQUEST_CODE_SET_DEFAULT_DIALER)
+ Log.d(TAG, "Launched TelecomManager intent for default dialer")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to launch default dialer prompt: ${e.message}", e)
+ launchDefaultAppsSettings()
+ }
+ }
+ } else {
+ Log.d(TAG, "Already the default dialer")
+ }
+ }
+
+ private fun launchDefaultAppsSettings() {
+ val settingsIntent = Intent(android.provider.Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS)
+ startActivity(settingsIntent)
+ Log.d(TAG, "Opened default apps settings as fallback")
+ }
+
+ override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+ super.onActivityResult(requestCode, resultCode, data)
+ Log.d(TAG, "onActivityResult: requestCode=$requestCode, resultCode=$resultCode, data=$data")
+ if (requestCode == REQUEST_CODE_SET_DEFAULT_DIALER) {
+ if (resultCode == RESULT_OK) {
+ Log.d(TAG, "User accepted default dialer change")
+ } else {
+ Log.w(TAG, "Default dialer prompt canceled or failed (resultCode=$resultCode)")
+ launchDefaultAppsSettings()
+ }
+ }
+ }
+
private fun getCallLogs(): List> {
val logsList = mutableListOf>()
val cursor: Cursor? = contentResolver.query(
- CallLog.Calls.CONTENT_URI,
- null,
- null,
- null,
- CallLog.Calls.DATE + " DESC"
+ CallLog.Calls.CONTENT_URI, null, null, null, CallLog.Calls.DATE + " DESC"
)
- if (cursor != null) {
- while (cursor.moveToNext()) {
- val number = cursor.getString(cursor.getColumnIndexOrThrow(CallLog.Calls.NUMBER))
- val type = cursor.getInt(cursor.getColumnIndexOrThrow(CallLog.Calls.TYPE))
- val date = cursor.getLong(cursor.getColumnIndexOrThrow(CallLog.Calls.DATE))
- val duration = cursor.getLong(cursor.getColumnIndexOrThrow(CallLog.Calls.DURATION))
+ cursor?.use {
+ while (it.moveToNext()) {
+ val number = it.getString(it.getColumnIndexOrThrow(CallLog.Calls.NUMBER))
+ val type = it.getInt(it.getColumnIndexOrThrow(CallLog.Calls.TYPE))
+ val date = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DATE))
+ val duration = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DURATION))
- val map = HashMap()
- map["number"] = number
- map["type"] = type // Typically: 1 for incoming, 2 for outgoing, 3 for missed.
- map["date"] = date
- map["duration"] = duration
+ val map = mutableMapOf(
+ "number" to number,
+ "type" to type,
+ "date" to date,
+ "duration" to duration
+ )
logsList.add(map)
}
- cursor.close()
}
return logsList
}
-}
+}
\ No newline at end of file
diff --git a/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallConnectionService.kt b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallConnectionService.kt
new file mode 100644
index 0000000..c39d608
--- /dev/null
+++ b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallConnectionService.kt
@@ -0,0 +1,82 @@
+// package com.icing.dialer.services
+
+// import android.telecom.Connection
+// import android.telecom.ConnectionService
+// import android.telecom.PhoneAccountHandle
+// import android.telecom.TelecomManager
+// import android.telecom.DisconnectCause
+// import android.util.Log
+// import io.flutter.plugin.common.MethodChannel
+
+// class CallConnectionService : ConnectionService() {
+// companion object {
+// var channel: MethodChannel? = null
+// private const val TAG = "CallConnectionService"
+// }
+
+// init {
+// Log.d(TAG, "CallConnectionService initialized")
+// }
+
+// override fun onCreate() {
+// super.onCreate()
+// Log.d(TAG, "Service created")
+// }
+
+// override fun onDestroy() {
+// super.onDestroy()
+// Log.d(TAG, "Service destroyed")
+// }
+
+// override fun onCreateOutgoingConnection(
+// connectionManagerPhoneAccount: PhoneAccountHandle?,
+// request: android.telecom.ConnectionRequest
+// ): Connection {
+// Log.d(TAG, "Creating outgoing connection for ${request.address}, account: $connectionManagerPhoneAccount")
+// val connection = object : Connection() {
+// override fun onStateChanged(state: Int) {
+// super.onStateChanged(state)
+// Log.d(TAG, "Connection state changed: $state")
+// val stateStr = when (state) {
+// STATE_DIALING -> "dialing"
+// STATE_ACTIVE -> "active"
+// STATE_DISCONNECTED -> "disconnected"
+// else -> "unknown"
+// }
+// channel?.invokeMethod("callStateChanged", mapOf("state" to stateStr, "phoneNumber" to request.address.toString()))
+// }
+
+// override fun onDisconnect() {
+// Log.d(TAG, "Connection disconnected")
+// setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+// destroy()
+// }
+// }
+// connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED)
+// connection.setInitialized()
+// connection.setDialing()
+// return connection
+// }
+
+// override fun onCreateIncomingConnection(
+// connectionManagerPhoneAccount: PhoneAccountHandle?,
+// request: android.telecom.ConnectionRequest
+// ): Connection {
+// Log.d(TAG, "Creating incoming connection for ${request.address}, account: $connectionManagerPhoneAccount")
+// val connection = object : Connection() {
+// override fun onAnswer() {
+// Log.d(TAG, "Connection answered")
+// setActive()
+// }
+
+// override fun onDisconnect() {
+// Log.d(TAG, "Connection disconnected")
+// setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+// destroy()
+// }
+// }
+// connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED)
+// connection.setRinging()
+// return connection
+// }
+// }
\ No newline at end of file
diff --git a/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallService.kt b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallService.kt
index e0016dc..7958799 100644
--- a/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallService.kt
+++ b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallService.kt
@@ -1,30 +1,55 @@
package com.icing.dialer.services
import android.content.Context
-import android.content.Intent
import android.net.Uri
-import android.telecom.TelecomManager
import android.os.Build
+import android.os.Bundle
+import android.telecom.TelecomManager
import android.util.Log
+import androidx.core.content.ContextCompat
+import android.content.pm.PackageManager
+import android.Manifest
object CallService {
-
- fun makeGsmCall(context: Context, phoneNumber: String) {
- try {
- val intent = Intent(Intent.ACTION_CALL)
- intent.data = Uri.parse("tel:$phoneNumber")
- context.startActivity(intent)
+ private val TAG = "CallService"
+
+ fun makeGsmCall(context: Context, phoneNumber: String): Boolean {
+ return try {
+ val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+ val uri = Uri.parse("tel:$phoneNumber")
+
+ if (ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED) {
+ telecomManager.placeCall(uri, Bundle())
+ Log.d(TAG, "Initiated call to $phoneNumber")
+ true
+ } else {
+ Log.e(TAG, "CALL_PHONE permission not granted")
+ false
+ }
} catch (e: Exception) {
- Log.e("CallService", "Error making GSM call: ${e.message}")
+ Log.e(TAG, "Error making GSM call: ${e.message}", e)
+ false
}
}
- fun hangUpCall(context: Context) {
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
- val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
- telecomManager.endCall()
- } else {
- Log.e("CallService", "Hangup call is only supported on Android P or later.")
+ fun hangUpCall(context: Context): Boolean {
+ return try {
+ if (MyInCallService.currentCall != null) {
+ MyInCallService.currentCall?.disconnect()
+ Log.d(TAG, "Disconnected active call via MyInCallService")
+ true
+ } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+ telecomManager.endCall()
+ Log.d(TAG, "Ended call via TelecomManager (no active call in MyInCallService)")
+ true
+ } else {
+ Log.e(TAG, "No active call and hangup not supported below Android P")
+ false
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "Error hanging up call: ${e.message}", e)
+ false
}
}
}
\ No newline at end of file
diff --git a/dialer/android/app/src/main/kotlin/com/icing/dialer/services/MyInCallService.kt b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/MyInCallService.kt
new file mode 100644
index 0000000..48b7edd
--- /dev/null
+++ b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/MyInCallService.kt
@@ -0,0 +1,69 @@
+package com.icing.dialer.services
+
+import android.telecom.Call
+import android.telecom.InCallService
+import android.util.Log
+import io.flutter.plugin.common.MethodChannel
+
+class MyInCallService : InCallService() {
+ companion object {
+ var channel: MethodChannel? = null
+ var currentCall: Call? = null
+ private const val TAG = "MyInCallService"
+ }
+
+ private val callCallback = object : Call.Callback() {
+ override fun onStateChanged(call: Call, state: Int) {
+ super.onStateChanged(call, state)
+ val stateStr = when (state) {
+ Call.STATE_DIALING -> "dialing"
+ Call.STATE_ACTIVE -> "active"
+ Call.STATE_DISCONNECTED -> "disconnected"
+ Call.STATE_DISCONNECTING -> "disconnecting"
+ Call.STATE_RINGING -> "ringing"
+ else -> "unknown"
+ }
+ Log.d(TAG, "State changed: $stateStr for call ${call.details.handle}")
+ channel?.invokeMethod("callStateChanged", mapOf(
+ "callId" to call.details.handle.toString(),
+ "state" to stateStr
+ ))
+ if (state == Call.STATE_DISCONNECTED || state == Call.STATE_DISCONNECTING) {
+ Log.d(TAG, "Call ended: ${call.details.handle}")
+ channel?.invokeMethod("callEnded", mapOf("callId" to call.details.handle.toString()))
+ currentCall = null
+ }
+ }
+ }
+
+ override fun onCallAdded(call: Call) {
+ super.onCallAdded(call)
+ currentCall = call
+ val stateStr = when (call.state) {
+ Call.STATE_DIALING -> "dialing"
+ Call.STATE_ACTIVE -> "active"
+ Call.STATE_RINGING -> "ringing"
+ else -> "dialing" // Default for outgoing
+ }
+ Log.d(TAG, "Call added: ${call.details.handle}, state: $stateStr")
+ channel?.invokeMethod("callAdded", mapOf(
+ "callId" to call.details.handle.toString(),
+ "state" to stateStr
+ ))
+ call.registerCallback(callCallback)
+ }
+
+ override fun onCallRemoved(call: Call) {
+ super.onCallRemoved(call)
+ Log.d(TAG, "Call removed: ${call.details.handle}")
+ call.unregisterCallback(callCallback)
+ channel?.invokeMethod("callRemoved", mapOf("callId" to call.details.handle.toString()))
+ currentCall = null
+ }
+
+ override fun onCallAudioStateChanged(state: android.telecom.CallAudioState) {
+ super.onCallAudioStateChanged(state)
+ Log.d(TAG, "Audio state changed: route=${state.route}")
+ channel?.invokeMethod("audioStateChanged", mapOf("route" to state.route))
+ }
+}
\ No newline at end of file
diff --git a/dialer/build.sh b/dialer/build.sh
index 6416762..c8f5e05 100755
--- a/dialer/build.sh
+++ b/dialer/build.sh
@@ -2,4 +2,9 @@
IMG=git.gmoker.com/icing/flutter:main
-docker run --rm -v "$PWD:/app/" "$IMG" build apk
+if [ "$1" == '-s' ]; then
+ OPT+=(--dart-define=STEALTH=true)
+fi
+
+set -x
+docker run --rm -v "$PWD:/app/" "$IMG" build apk "${OPT[@]}"
diff --git a/dialer/lib/features/call/call_page.dart b/dialer/lib/features/call/call_page.dart
new file mode 100644
index 0000000..1416a98
--- /dev/null
+++ b/dialer/lib/features/call/call_page.dart
@@ -0,0 +1,324 @@
+import 'dart:typed_data';
+import 'package:flutter/material.dart';
+import 'package:dialer/services/call_service.dart';
+import 'package:dialer/services/obfuscate_service.dart';
+import 'package:dialer/widgets/username_color_generator.dart';
+
+class CallPage extends StatefulWidget {
+ final String displayName;
+ final String phoneNumber;
+ final Uint8List? thumbnail;
+
+ const CallPage({
+ super.key,
+ required this.displayName,
+ required this.phoneNumber,
+ this.thumbnail,
+ });
+
+ @override
+ _CallPageState createState() => _CallPageState();
+}
+
+class _CallPageState extends State {
+ final ObfuscateService _obfuscateService = ObfuscateService();
+ final CallService _callService = CallService();
+ bool isMuted = false;
+ bool isSpeakerOn = false;
+ bool isKeypadVisible = false;
+ bool icingProtocolOk = true;
+ String _typedDigits = "";
+
+ void _addDigit(String digit) {
+ setState(() {
+ _typedDigits += digit;
+ });
+ }
+
+ void _toggleMute() {
+ setState(() {
+ isMuted = !isMuted;
+ });
+ }
+
+ void _toggleSpeaker() {
+ setState(() {
+ isSpeakerOn = !isSpeakerOn;
+ });
+ }
+
+ void _toggleKeypad() {
+ setState(() {
+ isKeypadVisible = !isKeypadVisible;
+ });
+ }
+
+ void _toggleIcingProtocol() {
+ setState(() {
+ icingProtocolOk = !icingProtocolOk;
+ });
+ }
+
+ void _hangUp() async {
+ try {
+ await _callService.hangUpCall(context);
+ } catch (e) {
+ print("Error hanging up: $e");
+ }
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ final double avatarRadius = isKeypadVisible ? 45.0 : 45.0;
+ final double nameFontSize = isKeypadVisible ? 24.0 : 24.0;
+ final double statusFontSize = isKeypadVisible ? 16.0 : 16.0;
+
+ return Scaffold(
+ body: Container(
+ color: Colors.black,
+ child: SafeArea(
+ child: Column(
+ children: [
+ Container(
+ padding: const EdgeInsets.symmetric(vertical: 8.0),
+ child: Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ SizedBox(height: 35),
+ ObfuscatedAvatar(
+ imageBytes: widget.thumbnail, // Uses thumbnail if provided
+ radius: avatarRadius,
+ backgroundColor: generateColorFromName(widget.displayName),
+ fallbackInitial: widget.displayName,
+ ),
+ const SizedBox(height: 4),
+ Row(
+ mainAxisAlignment: MainAxisAlignment.center,
+ children: [
+ Icon(
+ icingProtocolOk ? Icons.lock : Icons.lock_open,
+ color: icingProtocolOk ? Colors.green : Colors.red,
+ size: 16,
+ ),
+ const SizedBox(width: 4),
+ Text(
+ 'Icing protocol: ${icingProtocolOk ? "ok" : "ko"}',
+ style: TextStyle(
+ color: icingProtocolOk ? Colors.green : Colors.red,
+ fontSize: 12,
+ fontWeight: FontWeight.bold,
+ ),
+ ),
+ ],
+ ),
+ const SizedBox(height: 4),
+ Text(
+ _obfuscateService.obfuscateData(widget.displayName),
+ style: TextStyle(
+ fontSize: nameFontSize,
+ color: Colors.white,
+ fontWeight: FontWeight.bold,
+ ),
+ ),
+ Text(
+ widget.phoneNumber,
+ style: TextStyle(fontSize: statusFontSize, color: Colors.white70),
+ ),
+ Text(
+ 'Calling...',
+ style: TextStyle(fontSize: statusFontSize, color: Colors.white70),
+ ),
+ ],
+ ),
+ ),
+ Expanded(
+ child: Column(
+ children: [
+ if (isKeypadVisible) ...[
+ const Spacer(flex: 2),
+ Padding(
+ padding: const EdgeInsets.symmetric(horizontal: 20.0),
+ child: Row(
+ mainAxisAlignment: MainAxisAlignment.spaceBetween,
+ children: [
+ Expanded(
+ child: Text(
+ _typedDigits,
+ maxLines: 1,
+ textAlign: TextAlign.right,
+ overflow: TextOverflow.ellipsis,
+ style: const TextStyle(
+ fontSize: 24,
+ color: Colors.white,
+ fontWeight: FontWeight.bold,
+ ),
+ ),
+ ),
+ IconButton(
+ padding: EdgeInsets.zero,
+ onPressed: _toggleKeypad,
+ icon: const Icon(Icons.close, color: Colors.white),
+ ),
+ ],
+ ),
+ ),
+ Container(
+ height: MediaQuery.of(context).size.height * 0.35,
+ margin: const EdgeInsets.symmetric(horizontal: 20),
+ child: GridView.count(
+ shrinkWrap: true,
+ physics: const NeverScrollableScrollPhysics(),
+ crossAxisCount: 3,
+ childAspectRatio: 1.3,
+ mainAxisSpacing: 8,
+ crossAxisSpacing: 8,
+ children: List.generate(12, (index) {
+ String label;
+ if (index < 9) {
+ label = '${index + 1}';
+ } else if (index == 9) {
+ label = '*';
+ } else if (index == 10) {
+ label = '0';
+ } else {
+ label = '#';
+ }
+ return GestureDetector(
+ onTap: () => _addDigit(label),
+ child: Container(
+ decoration: const BoxDecoration(
+ shape: BoxShape.circle,
+ color: Colors.transparent,
+ ),
+ child: Center(
+ child: Text(
+ label,
+ style: const TextStyle(fontSize: 32, color: Colors.white),
+ ),
+ ),
+ ),
+ );
+ }),
+ ),
+ ),
+ const Spacer(flex: 1),
+ ] else ...[
+ const Spacer(),
+ Padding(
+ padding: const EdgeInsets.symmetric(horizontal: 32.0),
+ child: Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ Row(
+ mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+ children: [
+ Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ IconButton(
+ onPressed: _toggleMute,
+ icon: Icon(
+ isMuted ? Icons.mic_off : Icons.mic,
+ color: Colors.white,
+ size: 32,
+ ),
+ ),
+ Text(
+ isMuted ? 'Unmute' : 'Mute',
+ style: const TextStyle(color: Colors.white, fontSize: 14),
+ ),
+ ],
+ ),
+ Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ IconButton(
+ onPressed: _toggleKeypad,
+ icon: const Icon(Icons.dialpad, color: Colors.white, size: 32),
+ ),
+ const Text(
+ 'Keypad',
+ style: TextStyle(color: Colors.white, fontSize: 14),
+ ),
+ ],
+ ),
+ Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ IconButton(
+ onPressed: _toggleSpeaker,
+ icon: Icon(
+ isSpeakerOn ? Icons.volume_up : Icons.volume_off,
+ color: isSpeakerOn ? Colors.amber : Colors.white,
+ size: 32,
+ ),
+ ),
+ const Text(
+ 'Speaker',
+ style: TextStyle(color: Colors.white, fontSize: 14),
+ ),
+ ],
+ ),
+ ],
+ ),
+ const SizedBox(height: 20),
+ Row(
+ mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+ children: [
+ Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ IconButton(
+ onPressed: () {},
+ icon: const Icon(Icons.person_add, color: Colors.white, size: 32),
+ ),
+ const Text('Add Contact',
+ style: TextStyle(color: Colors.white, fontSize: 14)),
+ ],
+ ),
+ Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ IconButton(
+ onPressed: () {},
+ icon: const Icon(Icons.sim_card, color: Colors.white, size: 32),
+ ),
+ const Text('Change SIM',
+ style: TextStyle(color: Colors.white, fontSize: 14)),
+ ],
+ ),
+ ],
+ ),
+ ],
+ ),
+ ),
+ const Spacer(flex: 3),
+ ],
+ ],
+ ),
+ ),
+ Padding(
+ padding: const EdgeInsets.only(bottom: 16.0),
+ child: GestureDetector(
+ onTap: _hangUp,
+ child: Container(
+ padding: const EdgeInsets.all(12),
+ decoration: const BoxDecoration(
+ color: Colors.red,
+ shape: BoxShape.circle,
+ ),
+ child: const Icon(
+ Icons.call_end,
+ color: Colors.white,
+ size: 32,
+ ),
+ ),
+ ),
+ ),
+ ],
+ ),
+ ),
+ ),
+ );
+ }
+}
\ No newline at end of file
diff --git a/dialer/lib/features/call/incoming_call_page.dart b/dialer/lib/features/call/incoming_call_page.dart
new file mode 100644
index 0000000..2bad2eb
--- /dev/null
+++ b/dialer/lib/features/call/incoming_call_page.dart
@@ -0,0 +1,181 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:dialer/services/call_service.dart';
+import 'package:dialer/services/obfuscate_service.dart';
+import 'package:dialer/widgets/username_color_generator.dart';
+import 'package:dialer/features/call/call_page.dart';
+
+class IncomingCallPage extends StatefulWidget {
+ final String displayName;
+ final String phoneNumber;
+ final Uint8List? thumbnail;
+
+ const IncomingCallPage({
+ super.key,
+ required this.displayName,
+ required this.phoneNumber,
+ this.thumbnail,
+ });
+
+ @override
+ _IncomingCallPageState createState() => _IncomingCallPageState();
+}
+
+class _IncomingCallPageState extends State {
+ static const MethodChannel _channel = MethodChannel('call_service');
+ final ObfuscateService _obfuscateService = ObfuscateService();
+ final CallService _callService = CallService();
+ bool icingProtocolOk = true;
+
+ void _toggleIcingProtocol() {
+ setState(() {
+ icingProtocolOk = !icingProtocolOk;
+ });
+ }
+
+ void _answerCall() async {
+ try {
+ final result = await _channel.invokeMethod('answerCall');
+ print('IncomingCallPage: Answer call result: $result');
+ if (result["status"] == "answered") {
+ Navigator.pushReplacement(
+ context,
+ MaterialPageRoute(
+ builder: (context) => CallPage(
+ displayName: widget.displayName,
+ phoneNumber: widget.phoneNumber,
+ thumbnail: widget.thumbnail,
+ ),
+ ),
+ );
+ }
+ } catch (e) {
+ print("IncomingCallPage: Error answering call: $e");
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text("Error answering call: $e")),
+ );
+ }
+ }
+
+ void _declineCall() async {
+ try {
+ await _callService.hangUpCall(context);
+ } catch (e) {
+ print("IncomingCallPage: Error declining call: $e");
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text("Error declining call: $e")),
+ );
+ }
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ const double avatarRadius = 45.0;
+ const double nameFontSize = 24.0;
+ const double statusFontSize = 16.0;
+
+ return Scaffold(
+ body: Container(
+ color: Colors.black,
+ child: SafeArea(
+ child: Column(
+ children: [
+ Container(
+ padding: const EdgeInsets.symmetric(vertical: 8.0),
+ child: Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ const SizedBox(height: 35),
+ ObfuscatedAvatar(
+ imageBytes: widget.thumbnail,
+ radius: avatarRadius,
+ backgroundColor: generateColorFromName(widget.displayName),
+ fallbackInitial: widget.displayName,
+ ),
+ const SizedBox(height: 4),
+ Row(
+ mainAxisAlignment: MainAxisAlignment.center,
+ children: [
+ Icon(
+ icingProtocolOk ? Icons.lock : Icons.lock_open,
+ color: icingProtocolOk ? Colors.green : Colors.red,
+ size: 16,
+ ),
+ const SizedBox(width: 4),
+ Text(
+ 'Icing protocol: ${icingProtocolOk ? "ok" : "ko"}',
+ style: TextStyle(
+ color: icingProtocolOk ? Colors.green : Colors.red,
+ fontSize: 12,
+ fontWeight: FontWeight.bold,
+ ),
+ ),
+ ],
+ ),
+ const SizedBox(height: 4),
+ Text(
+ _obfuscateService.obfuscateData(widget.displayName),
+ style: const TextStyle(
+ fontSize: nameFontSize,
+ color: Colors.white,
+ fontWeight: FontWeight.bold,
+ ),
+ ),
+ Text(
+ widget.phoneNumber,
+ style: const TextStyle(fontSize: statusFontSize, color: Colors.white70),
+ ),
+ const Text(
+ 'Incoming Call...',
+ style: TextStyle(fontSize: statusFontSize, color: Colors.white70),
+ ),
+ ],
+ ),
+ ),
+ const Spacer(),
+ Padding(
+ padding: const EdgeInsets.symmetric(horizontal: 32.0, vertical: 16.0),
+ child: Row(
+ mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+ children: [
+ GestureDetector(
+ onTap: _declineCall,
+ child: Container(
+ padding: const EdgeInsets.all(12),
+ decoration: const BoxDecoration(
+ color: Colors.red,
+ shape: BoxShape.circle,
+ ),
+ child: const Icon(
+ Icons.call_end,
+ color: Colors.white,
+ size: 32,
+ ),
+ ),
+ ),
+ GestureDetector(
+ onTap: _answerCall,
+ child: Container(
+ padding: const EdgeInsets.all(12),
+ decoration: const BoxDecoration(
+ color: Colors.green,
+ shape: BoxShape.circle,
+ ),
+ child: const Icon(
+ Icons.call,
+ color: Colors.white,
+ size: 32,
+ ),
+ ),
+ ),
+ ],
+ ),
+ ),
+ const SizedBox(height: 16),
+ ],
+ ),
+ ),
+ ),
+ );
+ }
+}
\ No newline at end of file
diff --git a/dialer/lib/features/composition/composition.dart b/dialer/lib/features/composition/composition.dart
index 9bde112..b3e33bd 100644
--- a/dialer/lib/features/composition/composition.dart
+++ b/dialer/lib/features/composition/composition.dart
@@ -76,7 +76,7 @@ class _CompositionPageState extends State {
// Function to call a contact's number using the CallService
void _makeCall(String phoneNumber) async {
try {
- await _callService.makeGsmCall(phoneNumber);
+ await _callService.makeGsmCall(context, phoneNumber: phoneNumber);
setState(() {
dialedNumber = phoneNumber;
});
diff --git a/dialer/lib/features/contacts/widgets/contact_modal.dart b/dialer/lib/features/contacts/widgets/contact_modal.dart
index 9f641ad..198f614 100644
--- a/dialer/lib/features/contacts/widgets/contact_modal.dart
+++ b/dialer/lib/features/contacts/widgets/contact_modal.dart
@@ -5,7 +5,7 @@ import 'package:url_launcher/url_launcher.dart';
import 'package:dialer/widgets/username_color_generator.dart';
import '../../../services/block_service.dart';
import '../../../services/contact_service.dart';
-import '../../../services/call_service.dart'; // Import CallService
+import '../../../services/call_service.dart';
class ContactModal extends StatefulWidget {
final Contact contact;
@@ -29,7 +29,7 @@ class _ContactModalState extends State {
late String phoneNumber;
bool isBlocked = false;
final ObfuscateService _obfuscateService = ObfuscateService();
- final CallService _callService = CallService(); // Instantiate CallService
+ final CallService _callService = CallService();
@override
void initState() {
@@ -126,7 +126,9 @@ class _ContactModalState extends State {
// Show success message
ScaffoldMessenger.of(context).showSnackBar(
- SnackBar(content: Text('${_obfuscateService.obfuscateData(widget.contact.displayName)} deleted')),
+ SnackBar(
+ content: Text(
+ '${_obfuscateService.obfuscateData(widget.contact.displayName)} deleted')),
);
// Close the modal
@@ -134,7 +136,9 @@ class _ContactModalState extends State {
} catch (e) {
// Handle errors and show a failure message
ScaffoldMessenger.of(context).showSnackBar(
- SnackBar(content: Text('Failed to delete ${widget.contact.displayName}: $e')),
+ SnackBar(
+ content:
+ Text('Failed to delete ${widget.contact.displayName}: $e')),
);
}
}
@@ -162,7 +166,7 @@ class _ContactModalState extends State {
decoration: BoxDecoration(
color: Colors.grey[900],
borderRadius:
- const BorderRadius.vertical(top: Radius.circular(20)),
+ const BorderRadius.vertical(top: Radius.circular(20)),
),
child: Column(
mainAxisSize: MainAxisSize.min,
@@ -216,7 +220,7 @@ class _ContactModalState extends State {
const PopupMenuItem(
value: 'create_shortcut',
child:
- Text('Create shortcut (to home screen)'),
+ Text('Create shortcut (to home screen)'),
),
const PopupMenuItem(
value: 'set_ringtone',
@@ -238,12 +242,13 @@ class _ContactModalState extends State {
imageBytes: widget.contact.thumbnail,
radius: 50,
backgroundColor:
- generateColorFromName(widget.contact.displayName),
+ generateColorFromName(widget.contact.displayName),
fallbackInitial: widget.contact.displayName,
),
const SizedBox(height: 10),
Text(
- _obfuscateService.obfuscateData(widget.contact.displayName),
+ _obfuscateService
+ .obfuscateData(widget.contact.displayName),
style: const TextStyle(
fontSize: 24,
fontWeight: FontWeight.bold,
@@ -262,7 +267,8 @@ class _ContactModalState extends State {
),
onTap: () async {
if (widget.contact.phones.isNotEmpty) {
- await _callService.makeGsmCall(phoneNumber);
+ await _callService.makeGsmCall(context,
+ phoneNumber: phoneNumber);
}
},
),
@@ -307,9 +313,8 @@ class _ContactModalState extends State {
icon: Icon(widget.isFavorite
? Icons.star
: Icons.star_border),
- label: Text(widget.isFavorite
- ? 'Unfavorite'
- : 'Favorite'),
+ label: Text(
+ widget.isFavorite ? 'Unfavorite' : 'Favorite'),
),
),
const SizedBox(height: 10),
diff --git a/dialer/lib/features/history/history_page.dart b/dialer/lib/features/history/history_page.dart
index 1108a2e..2ce20b8 100644
--- a/dialer/lib/features/history/history_page.dart
+++ b/dialer/lib/features/history/history_page.dart
@@ -11,6 +11,7 @@ import 'package:dialer/features/contacts/contact_state.dart';
import 'package:dialer/widgets/username_color_generator.dart';
import '../../services/block_service.dart';
import '../contacts/widgets/contact_modal.dart';
+import '../../services/call_service.dart';
class History {
final Contact contact;
@@ -20,12 +21,12 @@ class History {
final int attempts;
History(
- this.contact,
- this.date,
- this.callType,
- this.callStatus,
- this.attempts,
- );
+ this.contact,
+ this.date,
+ this.callType,
+ this.callStatus,
+ this.attempts,
+ );
}
class HistoryPage extends StatefulWidget {
@@ -41,6 +42,7 @@ class _HistoryPageState extends State
bool loading = true;
int? _expandedIndex;
final ObfuscateService _obfuscateService = ObfuscateService();
+ final CallService _callService = CallService();
// Create a MethodChannel instance.
static const MethodChannel _channel = MethodChannel('com.example.calllog');
@@ -83,8 +85,8 @@ class _HistoryPageState extends State
}
} catch (e) {
print("Error updating favorite status: $e");
- ScaffoldMessenger.of(context)
- .showSnackBar(SnackBar(content: Text('Failed to update favorite status')));
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text('Failed to update favorite status')));
}
}
@@ -155,7 +157,7 @@ class _HistoryPageState extends State
// Convert timestamp to DateTime.
DateTime callDate =
- DateTime.fromMillisecondsSinceEpoch(entry['date'] ?? 0);
+ DateTime.fromMillisecondsSinceEpoch(entry['date'] ?? 0);
int typeInt = entry['type'] ?? 0;
int duration = entry['duration'] ?? 0;
@@ -193,7 +195,8 @@ class _HistoryPageState extends State
);
}
- callHistories.add(History(matchedContact, callDate, callType, callStatus, 1));
+ callHistories
+ .add(History(matchedContact, callDate, callType, callStatus, 1));
}
// Sort histories by most recent.
@@ -218,7 +221,7 @@ class _HistoryPageState extends State
for (var history in historyList) {
final callDate =
- DateTime(history.date.year, history.date.month, history.date.day);
+ DateTime(history.date.year, history.date.month, history.date.day);
if (callDate == today) {
todayHistories.add(history);
} else if (callDate == yesterday) {
@@ -291,7 +294,7 @@ class _HistoryPageState extends State
}
List missedCalls =
- histories.where((h) => h.callStatus == 'missed').toList();
+ histories.where((h) => h.callStatus == 'missed').toList();
final allItems = _buildGroupedList(histories);
final missedItems = _buildGroupedList(missedCalls);
@@ -360,7 +363,8 @@ class _HistoryPageState extends State
onEdit: () async {
if (await FlutterContacts.requestPermission()) {
final updatedContact =
- await FlutterContacts.openExternalEdit(contact.id);
+ await FlutterContacts.openExternalEdit(
+ contact.id);
if (updatedContact != null) {
await _refreshContacts();
Navigator.of(context).pop();
@@ -415,18 +419,11 @@ class _HistoryPageState extends State
icon: const Icon(Icons.phone, color: Colors.green),
onPressed: () async {
if (contact.phones.isNotEmpty) {
- final Uri callUri =
- Uri(scheme: 'tel', path: contact.phones.first.number);
- if (await canLaunchUrl(callUri)) {
- await launchUrl(callUri);
- } else {
- ScaffoldMessenger.of(context).showSnackBar(
- const SnackBar(content: Text('Could not launch call')),
- );
- }
+ _callService.makeGsmCall(context, phoneNumber: contact.phones.first.number);
} else {
ScaffoldMessenger.of(context).showSnackBar(
- const SnackBar(content: Text('Contact has no phone number')),
+ const SnackBar(
+ content: Text('Contact has no phone number')),
);
}
},
@@ -444,7 +441,9 @@ class _HistoryPageState extends State
color: Colors.grey[850],
child: FutureBuilder(
future: BlockService().isNumberBlocked(
- contact.phones.isNotEmpty ? contact.phones.first.number : ''),
+ contact.phones.isNotEmpty
+ ? contact.phones.first.number
+ : ''),
builder: (context, snapshot) {
final isBlocked = snapshot.data ?? false;
return Row(
@@ -460,29 +459,37 @@ class _HistoryPageState extends State
await launchUrl(smsUri);
} else {
ScaffoldMessenger.of(context).showSnackBar(
- const SnackBar(content: Text('Could not send message')),
+ const SnackBar(
+ content:
+ Text('Could not send message')),
);
}
} else {
ScaffoldMessenger.of(context).showSnackBar(
- const SnackBar(content: Text('Contact has no phone number')),
+ const SnackBar(
+ content:
+ Text('Contact has no phone number')),
);
}
},
- icon: const Icon(Icons.message, color: Colors.white),
- label: const Text('Message', style: TextStyle(color: Colors.white)),
+ icon:
+ const Icon(Icons.message, color: Colors.white),
+ label: const Text('Message',
+ style: TextStyle(color: Colors.white)),
),
TextButton.icon(
onPressed: () {
Navigator.push(
context,
MaterialPageRoute(
- builder: (_) => CallDetailsPage(history: history),
+ builder: (_) =>
+ CallDetailsPage(history: history),
),
);
},
icon: const Icon(Icons.info, color: Colors.white),
- label: const Text('Details', style: TextStyle(color: Colors.white)),
+ label: const Text('Details',
+ style: TextStyle(color: Colors.white)),
),
TextButton.icon(
onPressed: () async {
@@ -491,24 +498,29 @@ class _HistoryPageState extends State
: null;
if (phoneNumber == null) {
ScaffoldMessenger.of(context).showSnackBar(
- const SnackBar(content: Text('Contact has no phone number')),
+ const SnackBar(
+ content:
+ Text('Contact has no phone number')),
);
return;
}
if (isBlocked) {
await BlockService().unblockNumber(phoneNumber);
ScaffoldMessenger.of(context).showSnackBar(
- SnackBar(content: Text('$phoneNumber unblocked')),
+ SnackBar(
+ content: Text('$phoneNumber unblocked')),
);
} else {
await BlockService().blockNumber(phoneNumber);
ScaffoldMessenger.of(context).showSnackBar(
- SnackBar(content: Text('$phoneNumber blocked')),
+ SnackBar(
+ content: Text('$phoneNumber blocked')),
);
}
setState(() {});
},
- icon: Icon(isBlocked ? Icons.lock_open : Icons.block,
+ icon: Icon(
+ isBlocked ? Icons.lock_open : Icons.block,
color: Colors.white),
label: Text(isBlocked ? 'Unblock' : 'Block',
style: const TextStyle(color: Colors.white)),
@@ -554,21 +566,22 @@ class CallDetailsPage extends StatelessWidget {
children: [
(contact.thumbnail != null && contact.thumbnail!.isNotEmpty)
? ObfuscatedAvatar(
- imageBytes: contact.thumbnail,
- radius: 30,
- backgroundColor: contactBg,
- fallbackInitial: contact.displayName,
- )
+ imageBytes: contact.thumbnail,
+ radius: 30,
+ backgroundColor: contactBg,
+ fallbackInitial: contact.displayName,
+ )
: CircleAvatar(
- backgroundColor: generateColorFromName(contact.displayName),
- radius: 30,
- child: Text(
- contact.displayName.isNotEmpty
- ? contact.displayName[0].toUpperCase()
- : '?',
- style: TextStyle(color: contactLetter),
- ),
- ),
+ backgroundColor:
+ generateColorFromName(contact.displayName),
+ radius: 30,
+ child: Text(
+ contact.displayName.isNotEmpty
+ ? contact.displayName[0].toUpperCase()
+ : '?',
+ style: TextStyle(color: contactLetter),
+ ),
+ ),
const SizedBox(width: 16),
Expanded(
child: Text(
@@ -600,7 +613,8 @@ class CallDetailsPage extends StatelessWidget {
if (contact.phones.isNotEmpty)
DetailRow(
label: 'Number:',
- value: _obfuscateService.obfuscateData(contact.phones.first.number),
+ value: _obfuscateService
+ .obfuscateData(contact.phones.first.number),
),
],
),
diff --git a/dialer/lib/features/home/home_page.dart b/dialer/lib/features/home/home_page.dart
index 97e2c88..65adaa8 100644
--- a/dialer/lib/features/home/home_page.dart
+++ b/dialer/lib/features/home/home_page.dart
@@ -8,6 +8,7 @@ import 'package:flutter_contacts/flutter_contacts.dart';
import 'package:dialer/features/settings/settings.dart';
import '../../services/contact_service.dart';
import 'package:dialer/features/voicemail/voicemail_page.dart';
+import '../contacts/widgets/contact_modal.dart';
class _MyHomePageState extends State
@@ -17,6 +18,8 @@ class _MyHomePageState extends State
List _contactSuggestions = [];
final ContactService _contactService = ContactService();
final ObfuscateService _obfuscateService = ObfuscateService();
+ final TextEditingController _searchController = TextEditingController();
+
@override
void initState() {
@@ -32,12 +35,15 @@ class _MyHomePageState extends State
setState(() {});
}
- void _onSearchChanged(String query) {
- print("Search query: $query");
+ void _clearSearch() {
+ _searchController.clear();
+ _onSearchChanged('');
+ }
+ void _onSearchChanged(String query) {
setState(() {
if (query.isEmpty) {
- _contactSuggestions = List.from(_allContacts);
+ _contactSuggestions = List.from(_allContacts); // Reset suggestions
} else {
_contactSuggestions = _allContacts.where((contact) {
return contact.displayName
@@ -50,6 +56,7 @@ class _MyHomePageState extends State
@override
void dispose() {
+ _searchController.dispose();
_tabController.removeListener(_handleTabIndex);
_tabController.dispose();
super.dispose();
@@ -59,6 +66,34 @@ class _MyHomePageState extends State
setState(() {});
}
+ void _toggleFavorite(Contact contact) async {
+ try {
+ if (await FlutterContacts.requestPermission()) {
+ Contact? fullContact = await FlutterContacts.getContact(contact.id,
+ withProperties: true,
+ withAccounts: true,
+ withPhoto: true,
+ withThumbnail: true);
+
+ if (fullContact != null) {
+ fullContact.isStarred = !fullContact.isStarred;
+ await FlutterContacts.updateContact(fullContact);
+ setState(() {
+ // Updating the contact list after toggling the favorite
+ _fetchContacts();
+ });
+ }
+ } else {
+ print("Could not fetch contact details");
+ }
+ } catch (e) {
+ print("Error updating favorite status: $e");
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text('Failed to update contact favorite status')),
+ );
+ }
+ }
+
@override
Widget build(BuildContext context) {
return Scaffold(
@@ -80,63 +115,109 @@ class _MyHomePageState extends State
decoration: BoxDecoration(
color: const Color.fromARGB(255, 30, 30, 30),
borderRadius: BorderRadius.circular(12.0),
- border: Border(
- top: BorderSide(color: Colors.grey.shade800, width: 1),
- left: BorderSide(color: Colors.grey.shade800, width: 1),
- right: BorderSide(color: Colors.grey.shade800, width: 1),
- bottom:
- BorderSide(color: Colors.grey.shade800, width: 2),
- ),
+ border: Border.all(color: Colors.grey.shade800, width: 1),
),
child: SearchAnchor(
builder:
(BuildContext context, SearchController controller) {
- return SearchBar(
- controller: controller,
- padding:
- WidgetStateProperty.all(
- const EdgeInsets.only(
- top: 6.0,
- bottom: 6.0,
- left: 16.0,
- right: 16.0,
- ),
- ),
+ return GestureDetector(
onTap: () {
- controller.openView();
- _onSearchChanged('');
+ controller.openView(); // Open the search view
},
- backgroundColor: WidgetStateProperty.all(
- const Color.fromARGB(255, 30, 30, 30)),
- hintText: 'Search contacts',
- hintStyle: WidgetStateProperty.all(
- const TextStyle(color: Colors.grey, fontSize: 16.0),
- ),
- leading: const Icon(
- Icons.search,
- color: Colors.grey,
- size: 24.0,
- ),
- shape:
- WidgetStateProperty.all(
- RoundedRectangleBorder(
+ child: Container(
+ decoration: BoxDecoration(
+ color: const Color.fromARGB(255, 30, 30, 30),
borderRadius: BorderRadius.circular(12.0),
+ border: Border.all(
+ color: Colors.grey.shade800, width: 1),
+ ),
+ padding: const EdgeInsets.symmetric(
+ vertical: 12.0, horizontal: 16.0),
+ child: Row(
+ children: [
+ const Icon(Icons.search,
+ color: Colors.grey, size: 24.0),
+ const SizedBox(width: 8.0),
+ Text(
+ _searchController.text.isEmpty
+ ? 'Search contacts'
+ : _searchController.text,
+ style: const TextStyle(
+ color: Colors.grey, fontSize: 16.0),
+ ),
+ const Spacer(),
+ if (_searchController.text.isNotEmpty)
+ GestureDetector(
+ onTap: _clearSearch,
+ child: const Icon(
+ Icons.clear,
+ color: Colors.grey,
+ size: 24.0,
+ ),
+ ),
+ ],
),
),
);
},
viewOnChanged: (query) {
- _onSearchChanged(query);
+ _onSearchChanged(query); // Update immediately
},
suggestionsBuilder:
(BuildContext context, SearchController controller) {
return _contactSuggestions.map((contact) {
- return ListTile(
+ return ListTile(
key: ValueKey(contact.id),
title: Text(_obfuscateService.obfuscateData(contact.displayName),
style: const TextStyle(color: Colors.white)),
onTap: () {
+ // Clear the search text input
+ controller.text = '';
+
+ // Close the search view
controller.closeView(contact.displayName);
+
+ // Show the ContactModal when a contact is tapped
+ showModalBottomSheet(
+ context: context,
+ isScrollControlled: true,
+ backgroundColor: Colors.transparent,
+ builder: (context) {
+ return ContactModal(
+ contact: contact,
+ onEdit: () async {
+ if (await FlutterContacts
+ .requestPermission()) {
+ final updatedContact =
+ await FlutterContacts
+ .openExternalEdit(contact.id);
+ if (updatedContact != null) {
+ _fetchContacts();
+ Navigator.of(context).pop();
+ ScaffoldMessenger.of(context)
+ .showSnackBar(
+ SnackBar(
+ content: Text(
+ '${contact.displayName} updated successfully!'),
+ ),
+ );
+ } else {
+ ScaffoldMessenger.of(context)
+ .showSnackBar(
+ SnackBar(
+ content: Text(
+ 'Edit canceled or failed.'),
+ ),
+ );
+ }
+ }
+ },
+ onToggleFavorite: () =>
+ _toggleFavorite(contact),
+ isFavorite: contact.isStarred,
+ );
+ },
+ );
},
);
}).toList();
diff --git a/dialer/lib/main.dart b/dialer/lib/main.dart
index afde3b9..d3513cf 100644
--- a/dialer/lib/main.dart
+++ b/dialer/lib/main.dart
@@ -1,8 +1,11 @@
import 'package:dialer/features/home/home_page.dart';
import 'package:flutter/material.dart';
import 'package:dialer/features/contacts/contact_state.dart';
+import 'package:dialer/services/call_service.dart';
+import 'package:flutter/services.dart';
import 'globals.dart' as globals;
import 'package:dialer/services/cryptography/asymmetric_crypto_service.dart';
+import 'package:permission_handler/permission_handler.dart';
import 'package:provider/provider.dart';
void main() async {
@@ -13,19 +16,38 @@ void main() async {
final AsymmetricCryptoService cryptoService = AsymmetricCryptoService();
await cryptoService.initializeDefaultKeyPair();
+ // Request permissions before running the app
+ await _requestPermissions();
+
+ CallService();
+
runApp(
MultiProvider(
providers: [
Provider(
create: (_) => cryptoService,
),
- // Add other providers here
],
child: Dialer(),
),
);
}
+Future _requestPermissions() async {
+ Map statuses = await [
+ Permission.phone,
+ Permission.contacts,
+ Permission.microphone,
+ ].request();
+ if (statuses.values.every((status) => status.isGranted)) {
+ print("All required permissions granted");
+ const channel = MethodChannel('call_service');
+ await channel.invokeMethod('permissionsGranted');
+ } else {
+ print("Permissions denied: ${statuses.entries.where((e) => !e.value.isGranted).map((e) => e.key).join(', ')}");
+ }
+}
+
class Dialer extends StatelessWidget {
const Dialer({super.key});
@@ -33,11 +55,12 @@ class Dialer extends StatelessWidget {
Widget build(BuildContext context) {
return ContactState(
child: MaterialApp(
+ navigatorKey: CallService.navigatorKey,
theme: ThemeData(
- brightness: Brightness.dark
+ brightness: Brightness.dark,
),
home: SafeArea(child: MyHomePage()),
- )
+ ),
);
}
-}
+}
\ No newline at end of file
diff --git a/dialer/lib/services/call_service.dart b/dialer/lib/services/call_service.dart
index c07027e..d42326e 100644
--- a/dialer/lib/services/call_service.dart
+++ b/dialer/lib/services/call_service.dart
@@ -1,26 +1,154 @@
+import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
+import '../features/call/call_page.dart';
+import '../features/call/incoming_call_page.dart'; // Import the new page
-// Service to manage call-related operations
class CallService {
static const MethodChannel _channel = MethodChannel('call_service');
+ static String? currentPhoneNumber;
+ static bool _isCallPageVisible = false;
- // Function to make a GSM call
- Future makeGsmCall(String phoneNumber) async {
+ static final GlobalKey navigatorKey = GlobalKey();
+
+ CallService() {
+ _channel.setMethodCallHandler((call) async {
+ final context = navigatorKey.currentContext;
+ print('CallService: Received method ${call.method} with args ${call.arguments}');
+ if (context == null) {
+ print('CallService: Navigator context is null, cannot navigate');
+ return;
+ }
+
+ switch (call.method) {
+ case "callAdded":
+ final phoneNumber = call.arguments["callId"] as String;
+ final state = call.arguments["state"] as String;
+ currentPhoneNumber = phoneNumber.replaceFirst('tel:', '');
+ print('CallService: Call added, number: $currentPhoneNumber, state: $state');
+ if (state == "ringing") {
+ _navigateToIncomingCallPage(context);
+ } else {
+ _navigateToCallPage(context);
+ }
+ break;
+ case "callStateChanged":
+ final state = call.arguments["state"] as String;
+ print('CallService: State changed to $state');
+ if (state == "disconnected" || state == "disconnecting") {
+ _closeCallPage(context);
+ } else if (state == "active" || state == "dialing") {
+ _navigateToCallPage(context);
+ } else if (state == "ringing") {
+ _navigateToIncomingCallPage(context);
+ }
+ break;
+ case "callEnded":
+ case "callRemoved":
+ print('CallService: Call ended/removed');
+ _closeCallPage(context);
+ currentPhoneNumber = null;
+ break;
+ }
+ });
+ }
+
+ void _navigateToCallPage(BuildContext context) {
+ if (_isCallPageVisible && ModalRoute.of(context)?.settings.name == '/call') {
+ print('CallService: CallPage already visible, skipping navigation');
+ return;
+ }
+ print('CallService: Navigating to CallPage');
+ Navigator.pushReplacement(
+ context,
+ MaterialPageRoute(
+ settings: const RouteSettings(name: '/call'),
+ builder: (context) => CallPage(
+ displayName: currentPhoneNumber!,
+ phoneNumber: currentPhoneNumber!,
+ thumbnail: null,
+ ),
+ ),
+ ).then((_) {
+ _isCallPageVisible = false;
+ });
+ _isCallPageVisible = true;
+ }
+
+ void _navigateToIncomingCallPage(BuildContext context) {
+ if (_isCallPageVisible && ModalRoute.of(context)?.settings.name == '/incoming_call') {
+ print('CallService: IncomingCallPage already visible, skipping navigation');
+ return;
+ }
+ print('CallService: Navigating to IncomingCallPage');
+ Navigator.push(
+ context,
+ MaterialPageRoute(
+ settings: const RouteSettings(name: '/incoming_call'),
+ builder: (context) => IncomingCallPage(
+ displayName: currentPhoneNumber!,
+ phoneNumber: currentPhoneNumber!,
+ thumbnail: null,
+ ),
+ ),
+ ).then((_) {
+ _isCallPageVisible = false;
+ });
+ _isCallPageVisible = true;
+ }
+
+ void _closeCallPage(BuildContext context) {
+ if (!_isCallPageVisible) {
+ print('CallService: CallPage not visible, skipping pop');
+ return;
+ }
+ if (Navigator.canPop(context)) {
+ print('CallService: Popping CallPage');
+ Navigator.pop(context);
+ _isCallPageVisible = false;
+ }
+ }
+
+ Future makeGsmCall(
+ BuildContext context, {
+ required String phoneNumber,
+ String? displayName,
+ Uint8List? thumbnail,
+ }) async {
try {
- await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber});
+ currentPhoneNumber = phoneNumber;
+ print('CallService: Making GSM call to $phoneNumber');
+ final result = await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber});
+ print('CallService: makeGsmCall result: $result');
+ if (result["status"] != "calling") {
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text("Failed to initiate call")),
+ );
+ }
} catch (e) {
- print("Error making call: $e");
+ print("CallService: Error making call: $e");
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text("Error making call: $e")),
+ );
rethrow;
}
}
- // Function to hang up the current call
- Future hangUpCall() async {
+ Future hangUpCall(BuildContext context) async {
try {
- await _channel.invokeMethod('hangUpCall');
+ print('CallService: Hanging up call');
+ final result = await _channel.invokeMethod('hangUpCall');
+ print('CallService: hangUpCall result: $result');
+ if (result["status"] != "ended") {
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text("Failed to end call")),
+ );
+ }
} catch (e) {
- print("Error hanging up call: $e");
+ print("CallService: Error hanging up call: $e");
+ ScaffoldMessenger.of(context).showSnackBar(
+ SnackBar(content: Text("Error hanging up call: $e")),
+ );
rethrow;
}
}
-}
+}
\ No newline at end of file
diff --git a/dialer/run.sh b/dialer/run.sh
index 3a8ccb7..2aa3244 100755
--- a/dialer/run.sh
+++ b/dialer/run.sh
@@ -2,4 +2,9 @@
IMG=git.gmoker.com/icing/flutter:main
-docker run --rm -p 5037:5037 -v "$PWD:/app/" "$IMG" run
+if [ "$1" == '-s' ]; then
+ OPT+=(--dart-define=STEALTH=true)
+fi
+
+set -x
+docker run --rm -p 5037:5037 -v "$PWD:/app/" "$IMG" run "${OPTS[@]}"
diff --git a/dialer/stealth_local_run.sh b/dialer/stealth_local_run.sh
index 95cc270..ae202a9 100755
--- a/dialer/stealth_local_run.sh
+++ b/dialer/stealth_local_run.sh
@@ -1,3 +1,4 @@
#!/usr/bin/env bash
+
echo "Running Icing Dialer in STEALTH mode..."
-flutter run --dart-define=STEALTH=true
\ No newline at end of file
+flutter run --dart-define=STEALTH=true
diff --git a/protocol_prototype/IcingProtocol.drawio b/protocol_prototype/IcingProtocol.drawio
index 06c3cb0..edefb16 100644
--- a/protocol_prototype/IcingProtocol.drawio
+++ b/protocol_prototype/IcingProtocol.drawio
@@ -1,6 +1,6 @@
-
-
-
+
+
+
@@ -42,25 +42,25 @@
-
+
-
+
-
+
-
+
-
+
@@ -70,37 +70,37 @@
-
+
-
+
-
+
-
+
-
+
-
+
-
+
@@ -111,83 +111,83 @@
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
@@ -195,12 +195,12 @@
-
+
-
+
@@ -209,29 +209,29 @@
-
+
-
+
-
+
-
+
-
+
-
+
-
+
@@ -239,24 +239,221 @@
-
+
-
+
-
+
-
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/protocol_prototype/cli.py b/protocol_prototype/cli.py
new file mode 100644
index 0000000..600376b
--- /dev/null
+++ b/protocol_prototype/cli.py
@@ -0,0 +1,113 @@
+import sys
+from protocol import IcingProtocol
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+BLUE = "\033[94m"
+RESET = "\033[0m"
+
+
+def main():
+ protocol = IcingProtocol()
+
+ print(f"{YELLOW}\n======================================")
+ print(" Icing Protocol - Manual CLI Demo ")
+ print("======================================\n" + RESET)
+
+ print(f"Listening on port: {protocol.local_port}")
+ print(f"Your identity public key (hex): {protocol.identity_pubkey.hex()}")
+ print("\nAvailable commands:")
+ print(" set_peer_identity ")
+ print(" connect ")
+ print(" generate_ephemeral_keys")
+ print(" send_ping")
+ print(" send_handshake")
+ print(" respond_ping <0|1>")
+ print(" generate_ecdhe ")
+ print(" auto_responder ")
+ print(" show_state")
+ print(" exit\n")
+
+ while True:
+ try:
+ line = input("Cmd> ").strip()
+ except EOFError:
+ break
+ if not line:
+ continue
+
+ parts = line.split()
+ cmd = parts[0].lower()
+
+ if cmd == "exit":
+ protocol.stop()
+ sys.exit(0)
+
+ elif cmd == "show_state":
+ protocol.show_state()
+
+ elif cmd == "set_peer_identity":
+ if len(parts) != 2:
+ print(f"{RED}Usage: set_peer_identity {RESET}")
+ continue
+ protocol.set_peer_identity(parts[1])
+
+ elif cmd == "connect":
+ if len(parts) != 2:
+ print(f"{RED}Usage: connect {RESET}")
+ continue
+ try:
+ port = int(parts[1])
+ protocol.connect_to_peer(port)
+ except ValueError:
+ print(f"{RED}Invalid port.{RESET}")
+
+ elif cmd == "generate_ephemeral_keys":
+ protocol.generate_ephemeral_keys()
+
+ elif cmd == "send_ping":
+ protocol.send_ping_request()
+
+ elif cmd == "send_handshake":
+ protocol.send_handshake()
+
+ elif cmd == "respond_ping":
+ if len(parts) != 3:
+ print(f"{RED}Usage: respond_ping {RESET}")
+ continue
+ try:
+ idx = int(parts[1])
+ ac = int(parts[2])
+ protocol.respond_to_ping(idx, ac)
+ except ValueError:
+ print(f"{RED}Index and answer_code must be integers.{RESET}")
+
+ elif cmd == "generate_ecdhe":
+ if len(parts) != 2:
+ print(f"{RED}Usage: generate_ecdhe {RESET}")
+ continue
+ try:
+ idx = int(parts[1])
+ protocol.generate_ecdhe(idx)
+ except ValueError:
+ print(f"{RED}Index must be an integer.{RESET}")
+
+ elif cmd == "auto_responder":
+ if len(parts) != 2:
+ print(f"{RED}Usage: auto_responder {RESET}")
+ continue
+ arg = parts[1].lower()
+ if arg == "on":
+ protocol.enable_auto_responder(True)
+ elif arg == "off":
+ protocol.enable_auto_responder(False)
+ else:
+ print(f"{RED}Usage: auto_responder {RESET}")
+
+ else:
+ print(f"{RED}[ERROR]{RESET} Unknown command: {cmd}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/protocol_prototype/crypto_utils.py b/protocol_prototype/crypto_utils.py
new file mode 100644
index 0000000..de0ce7c
--- /dev/null
+++ b/protocol_prototype/crypto_utils.py
@@ -0,0 +1,81 @@
+import os
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.ec import ECDH
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import utils
+from cryptography.exceptions import InvalidSignature
+
+
+def generate_identity_keys():
+ """
+ Generate an ECDSA (P-256) identity key pair.
+ Return (private_key, public_key_bytes).
+ public_key_bytes is raw x||y each 32 bytes (uncompressed minus the 0x04 prefix).
+ """
+ private_key = ec.generate_private_key(ec.SECP256R1())
+ public_numbers = private_key.public_key().public_numbers()
+
+ x_bytes = public_numbers.x.to_bytes(32, byteorder='big')
+ y_bytes = public_numbers.y.to_bytes(32, byteorder='big')
+ pubkey_bytes = x_bytes + y_bytes # 64 bytes
+
+ return private_key, pubkey_bytes
+
+
+def load_peer_identity_key(pubkey_bytes: bytes):
+ """
+ Given 64 bytes (x||y) for P-256, return a cryptography public key object.
+ """
+ if len(pubkey_bytes) != 64:
+ raise ValueError("Peer identity pubkey must be exactly 64 bytes (x||y).")
+ x_int = int.from_bytes(pubkey_bytes[:32], byteorder='big')
+ y_int = int.from_bytes(pubkey_bytes[32:], byteorder='big')
+ public_numbers = ec.EllipticCurvePublicNumbers(x_int, y_int, ec.SECP256R1())
+ return public_numbers.public_key()
+
+
+def sign_data(private_key, data: bytes) -> bytes:
+ """
+ Sign 'data' with ECDSA using P-256 private key.
+ Returns DER-encoded signature (variable length, up to ~70-72 bytes).
+ """
+ signature = private_key.sign(data, ec.ECDSA(hashes.SHA256()))
+ return signature
+
+
+def verify_signature(public_key, signature: bytes, data: bytes) -> bool:
+ """
+ Verify DER-encoded ECDSA signature with the given public key.
+ Return True if valid, False otherwise.
+ """
+ try:
+ public_key.verify(signature, data, ec.ECDSA(hashes.SHA256()))
+ return True
+ except InvalidSignature:
+ return False
+
+
+def get_ephemeral_keypair():
+ """
+ Generate ephemeral ECDH keypair (P-256).
+ Return (private_key, pubkey_bytes).
+ """
+ private_key = ec.generate_private_key(ec.SECP256R1())
+ numbers = private_key.public_key().public_numbers()
+ x_bytes = numbers.x.to_bytes(32, 'big')
+ y_bytes = numbers.y.to_bytes(32, 'big')
+ return private_key, x_bytes + y_bytes # 64 bytes
+
+
+def compute_ecdh_shared_key(private_key, peer_pubkey_bytes: bytes) -> bytes:
+ """
+ Given a local ECDH private_key and the peer's ephemeral pubkey (64 bytes),
+ compute the shared secret.
+ """
+ x_int = int.from_bytes(peer_pubkey_bytes[:32], 'big')
+ y_int = int.from_bytes(peer_pubkey_bytes[32:], 'big')
+ peer_public_numbers = ec.EllipticCurvePublicNumbers(x_int, y_int, ec.SECP256R1())
+ peer_public_key = peer_public_numbers.public_key()
+ shared_key = private_key.exchange(ec.ECDH(), peer_public_key)
+ return shared_key
diff --git a/protocol_prototype/messages.py b/protocol_prototype/messages.py
new file mode 100644
index 0000000..7194e73
--- /dev/null
+++ b/protocol_prototype/messages.py
@@ -0,0 +1,232 @@
+import os
+import struct
+import time
+import zlib
+import hashlib
+
+def crc32_of(data: bytes) -> int:
+ """
+ Compute CRC-32 of 'data'.
+ """
+ return zlib.crc32(data) & 0xffffffff
+
+
+# =============================================================================
+# 1) Ping Request (295 bits)
+# - 256-bit nonce
+# - 7-bit version
+# - 32-bit CRC
+# = 295 bits total
+# In practice, we store 37 bytes (296 bits); 1 bit is unused.
+# =============================================================================
+
+def build_ping_request(version: int) -> bytes:
+ """
+ Build a Ping request with:
+ - 256-bit nonce (32 bytes)
+ - 7-bit version
+ - 32-bit CRC
+ We do bit-packing. The final result is 37 bytes (296 bits), with 1 unused bit.
+ """
+ if not (0 <= version < 128):
+ raise ValueError("Version must fit in 7 bits (0..127)")
+
+ # 1) Generate 256-bit nonce
+ nonce = os.urandom(32) # 32 bytes = 256 bits
+
+ # We'll build partial_data = [nonce (256 bits), version (7 bits)] as an integer
+ # Then compute CRC-32 over those bytes, then append 32 bits of CRC.
+ partial_int = int.from_bytes(nonce, 'big') << 7 # shift left 7 bits
+ partial_int |= version # put version in the low 7 bits
+
+ # Convert partial to bytes
+ # partial is 256+7=263 bits => needs 33 bytes to store
+ partial_bytes = partial_int.to_bytes(33, 'big')
+
+ # Compute CRC over partial_bytes
+ cval = crc32_of(partial_bytes)
+
+ # Now combine partial_data (263 bits) with 32 bits of CRC => 295 bits
+ # We'll store that in a single integer
+ final_int = (int.from_bytes(partial_bytes, 'big') << 32) | cval
+ # final_int is 263+32=295 bits, needs 37 bytes to store (the last bit is unused).
+ final_bytes = final_int.to_bytes(37, 'big')
+ return final_bytes
+
+
+def parse_ping_request(data: bytes):
+ """
+ Parse a Ping request (37 bytes = 295 bits).
+ Returns (nonce, version) or None if invalid.
+ """
+ if len(data) != 37:
+ return None
+
+ # Convert to int
+ val_295 = int.from_bytes(data, 'big') # 295 bits in a 37-byte integer
+ # Extract CRC (lowest 32 bits)
+ crc_in = val_295 & 0xffffffff
+ # Then shift right 32 bits to get partial_data
+ partial_val = val_295 >> 32 # 263 bits
+
+ # Convert partial_val back to bytes
+ partial_bytes = partial_val.to_bytes(33, 'big')
+
+ # Recompute CRC
+ crc_calc = crc32_of(partial_bytes)
+ if crc_calc != crc_in:
+ return None
+
+ # Now parse out nonce (256 bits) and version (7 bits)
+ # partial_val is 263 bits
+ version = partial_val & 0x7f # low 7 bits
+ nonce_val = partial_val >> 7 # high 256 bits
+ nonce_bytes = nonce_val.to_bytes(32, 'big')
+
+ return (nonce_bytes, version)
+
+
+# =============================================================================
+# 2) Ping Response (72 bits)
+# - 32-bit timestamp
+# - 7-bit version + 1-bit answer => 8 bits
+# - 32-bit CRC
+# = 72 bits total => 9 bytes
+# =============================================================================
+
+def build_ping_response(version: int, answer: int) -> bytes:
+ """
+ Build a Ping response:
+ - 32-bit timestamp (lowest 32 bits of current time in ms)
+ - 7-bit version + 1-bit answer
+ - 32-bit CRC
+ => 72 bits = 9 bytes
+ """
+ if not (0 <= version < 128):
+ raise ValueError("Version must fit in 7 bits.")
+ if answer not in (0, 1):
+ raise ValueError("Answer must be 0 or 1.")
+
+ # 32-bit timestamp = current time in ms, truncated to 32 bits
+ t_ms = int(time.time() * 1000) & 0xffffffff
+
+ # partial = [timestamp (32 bits), version (7 bits), answer (1 bit)] => 40 bits
+ partial_val = (t_ms << 8) | ((version << 1) & 0xfe) | (answer & 0x01)
+ # partial_val is 40 bits => 5 bytes
+ partial_bytes = partial_val.to_bytes(5, 'big')
+
+ # CRC over these 5 bytes
+ cval = crc32_of(partial_bytes)
+
+ # Combine partial (40 bits) with 32 bits of CRC => 72 bits total
+ final_val = (int.from_bytes(partial_bytes, 'big') << 32) | cval
+ final_bytes = final_val.to_bytes(9, 'big')
+ return final_bytes
+
+
+def parse_ping_response(data: bytes):
+ """
+ Parse a Ping response (72 bits = 9 bytes).
+ Return (timestamp_ms, version, answer) or None if invalid.
+ """
+ if len(data) != 9:
+ return None
+
+ val_72 = int.from_bytes(data, 'big') # 72 bits
+ crc_in = val_72 & 0xffffffff
+ partial_val = val_72 >> 32 # 40 bits
+
+ partial_bytes = partial_val.to_bytes(5, 'big')
+ crc_calc = crc32_of(partial_bytes)
+ if crc_calc != crc_in:
+ return None
+
+ # Now parse partial_val
+ # partial_val = [timestamp(32 bits), version(7 bits), answer(1 bit)]
+ t_ms = (partial_val >> 8) & 0xffffffff
+ va = partial_val & 0xff # 8 bits = [7 bits version, 1 bit answer]
+ version = (va >> 1) & 0x7f
+ answer = va & 0x01
+
+ return (t_ms, version, answer)
+
+
+# =============================================================================
+# 3) Handshake
+# - 32-bit timestamp
+# - 64-byte ephemeral pubkey (raw x||y = 512 bits)
+# - 64-byte ephemeral signature (raw r||s = 512 bits)
+# - 32-byte PFS hash (256 bits)
+# - 32-bit CRC
+# => total 4 + 64 + 64 + 32 + 4 = 168 bytes = 1344 bits
+# =============================================================================
+
+def build_handshake_message(timestamp: int,
+ ephemeral_pubkey: bytes,
+ ephemeral_signature: bytes,
+ pfs_hash: bytes) -> bytes:
+ """
+ Build handshake:
+ - 4 bytes: timestamp
+ - 64 bytes: ephemeral_pubkey (x||y, raw)
+ - 64 bytes: ephemeral_signature (r||s, raw)
+ - 32 bytes: pfs_hash
+ - 4 bytes: CRC-32
+ => 168 bytes total
+ """
+ if len(ephemeral_pubkey) != 64:
+ raise ValueError("ephemeral_pubkey must be 64 bytes (raw x||y).")
+ if len(ephemeral_signature) != 64:
+ raise ValueError("ephemeral_signature must be 64 bytes (raw r||s).")
+ if len(pfs_hash) != 32:
+ raise ValueError("pfs_hash must be 32 bytes.")
+
+ partial = struct.pack("!I", timestamp) \
+ + ephemeral_pubkey \
+ + ephemeral_signature \
+ + pfs_hash
+ cval = crc32_of(partial)
+ return partial + struct.pack("!I", cval)
+
+
+def parse_handshake_message(data: bytes):
+ """
+ Parse handshake message (168 bytes).
+ Return (timestamp, ephemeral_pub, ephemeral_sig, pfs_hash) or None if invalid.
+ """
+ if len(data) != 168:
+ return None
+ partial = data[:-4] # first 164 bytes
+ crc_in = struct.unpack("!I", data[-4:])[0]
+ crc_calc = crc32_of(partial)
+ if crc_calc != crc_in:
+ return None
+
+ # Now parse fields
+ timestamp = struct.unpack("!I", partial[:4])[0]
+ ephemeral_pub = partial[4:4+64]
+ ephemeral_sig = partial[68:68+64]
+ pfs_hash = partial[132:132+32]
+ return (timestamp, ephemeral_pub, ephemeral_sig, pfs_hash)
+
+
+# =============================================================================
+# 4) PFS Hash Helper
+# If no previous session, return 32 zero bytes
+# Otherwise, compute sha256(session_number || last_shared_secret).
+# =============================================================================
+
+def compute_pfs_hash(session_number: int, shared_secret_hex: str) -> bytes:
+ """
+ Return 32 bytes (256 bits) for the PFS field.
+ If session_number < 0 => means no previous session => 32 zero bytes.
+ Otherwise => sha256( session_number (4 bytes) || shared_secret ).
+ """
+ if session_number < 0:
+ return b"\x00" * 32
+
+ # Convert shared_secret_hex to raw bytes
+ secret_bytes = bytes.fromhex(shared_secret_hex)
+ # Pack session_number as 4 bytes
+ sn_bytes = struct.pack("!I", session_number)
+ return hashlib.sha256(sn_bytes + secret_bytes).digest()
diff --git a/protocol_prototype/protocol.py b/protocol_prototype/protocol.py
new file mode 100644
index 0000000..2e777d3
--- /dev/null
+++ b/protocol_prototype/protocol.py
@@ -0,0 +1,390 @@
+import random
+import time
+import threading
+from typing import List, Dict, Any
+
+from crypto_utils import (
+ generate_identity_keys,
+ load_peer_identity_key,
+ sign_data,
+ verify_signature,
+ get_ephemeral_keypair,
+ compute_ecdh_shared_key
+)
+from messages import (
+ build_ping_request, parse_ping_request,
+ build_ping_response, parse_ping_response,
+ build_handshake_message, parse_handshake_message,
+ compute_pfs_hash
+)
+import transmission
+
+# ANSI colors
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+BLUE = "\033[94m"
+RESET = "\033[0m"
+
+
+class IcingProtocol:
+ def __init__(self):
+ # Identity keys
+ self.identity_privkey, self.identity_pubkey = generate_identity_keys()
+
+ # Peer identity
+ self.peer_identity_pubkey_obj = None
+ self.peer_identity_pubkey_bytes = None
+
+ # Ephemeral keys
+ self.ephemeral_privkey = None
+ self.ephemeral_pubkey = None
+
+ # Last computed shared secret (hex)
+ self.shared_secret = None
+
+ # For PFS: track session_number + last_shared_secret per peer identity
+ # Key: bytes(64) peer identity pubkey
+ # Value: (int session_number, str last_shared_secret_hex)
+ self.pfs_history: Dict[bytes, (int, str)] = {}
+
+ # Inbound messages are stored for manual or auto handling
+ # Each entry: { 'type': str, 'raw': bytes, 'parsed': Any, 'connection': PeerConnection }
+ self.inbound_messages: List[Dict[str, Any]] = []
+
+ # Simple dictionary to track protocol flags
+ self.state = {
+ "ping_sent": False,
+ "ping_received": False,
+ "handshake_sent": False,
+ "handshake_received": False,
+ }
+
+ # Auto-responder toggle
+ self.auto_responder = False
+
+ # Connections
+ self.connections = []
+
+ # Listening port
+ self.local_port = random.randint(30000, 40000)
+ self.server_listener = transmission.ServerListener(
+ host="127.0.0.1",
+ port=self.local_port,
+ on_new_connection=self.on_new_connection,
+ on_data_received=self.on_data_received
+ )
+ self.server_listener.start()
+
+ # -------------------------------------------------------------------------
+ # Transport callbacks
+ # -------------------------------------------------------------------------
+
+ def on_new_connection(self, conn: transmission.PeerConnection):
+ print(f"{GREEN}[IcingProtocol]{RESET} New incoming connection.")
+ self.connections.append(conn)
+
+ def on_data_received(self, conn: transmission.PeerConnection, data: bytes):
+ """
+ Called whenever data arrives on any open PeerConnection.
+ We'll parse and store the message, then handle automatically if auto_responder is on.
+ """
+ # Print data size in bits, not bytes
+ bits_count = len(data)*8
+ print(f"{GREEN}[RECV]{RESET} {bits_count} bits from peer: {data.hex()[:60]}{'...' if len(data.hex())>60 else ''}")
+
+ # Attempt to parse Ping request
+ if len(data) == 37:
+ parsed = parse_ping_request(data)
+ if parsed:
+ nonce, version = parsed
+ self.state["ping_received"] = True
+ index = len(self.inbound_messages)
+ msg = {
+ "type": "PING_REQUEST",
+ "raw": data,
+ "parsed": {"nonce": nonce, "version": version},
+ "connection": conn
+ }
+ self.inbound_messages.append(msg)
+ print(f"{YELLOW}[NOTICE]{RESET} Stored inbound PING request (nonce={nonce.hex()}) at index={index}.")
+
+ if self.auto_responder:
+ # Schedule an automatic response after 2 seconds
+ threading.Timer(2.0, self._auto_respond_ping, args=(index,)).start()
+
+ return
+
+ # Attempt to parse Ping response
+ if len(data) == 9:
+ parsed = parse_ping_response(data)
+ if parsed:
+ ts, version, answer_code = parsed
+ index = len(self.inbound_messages)
+ msg = {
+ "type": "PING_RESPONSE",
+ "raw": data,
+ "parsed": {"timestamp": ts, "version": version, "answer_code": answer_code},
+ "connection": conn
+ }
+ self.inbound_messages.append(msg)
+ print(f"{YELLOW}[NOTICE]{RESET} Stored inbound PING response (answer_code={answer_code}) at index={index}.")
+ return
+
+ # Attempt to parse handshake
+ if len(data) == 168:
+ parsed = parse_handshake_message(data)
+ if parsed:
+ ts, ephemeral_pub, ephemeral_sig, pfs_hash = parsed
+ self.state["handshake_received"] = True
+ index = len(self.inbound_messages)
+ msg = {
+ "type": "HANDSHAKE",
+ "raw": data,
+ "parsed": {
+ "ephemeral_pub": ephemeral_pub,
+ "ephemeral_sig": ephemeral_sig,
+ "timestamp": ts,
+ "pfs hash": pfs_hash
+ },
+ "connection": conn
+ }
+ self.inbound_messages.append(msg)
+ print(f"{YELLOW}[NOTICE]{RESET} Stored inbound HANDSHAKE at index={index}. ephemeral_pub={ephemeral_pub.hex()[:20]}...")
+
+ if self.auto_responder:
+ # Schedule an automatic handshake "response" after 2 seconds
+ threading.Timer(2.0, self._auto_respond_handshake, args=(index,)).start()
+
+ return
+
+ # Otherwise, unrecognized
+ index = len(self.inbound_messages)
+ msg = {
+ "type": "UNKNOWN",
+ "raw": data,
+ "parsed": None,
+ "connection": conn
+ }
+ self.inbound_messages.append(msg)
+ print(f"{RED}[WARNING]{RESET} Unrecognized or malformed message stored at index={index}.")
+
+ # -------------------------------------------------------------------------
+ # Auto-responder helpers
+ # -------------------------------------------------------------------------
+
+ def _auto_respond_ping(self, index: int):
+ """
+ Called by a Timer to respond automatically to a PING_REQUEST after 2s.
+ """
+ print(f"{BLUE}[AUTO]{RESET} Delayed responding to PING at index={index}")
+ self.respond_to_ping(index, answer_code=0)
+ self.show_state()
+
+ def _auto_respond_handshake(self, index: int):
+ """
+ Called by a Timer to handle inbound HANDSHAKE automatically.
+ 1) Generate ephemeral keys if not already set
+ 2) Compute ECDH with the inbound ephemeral pub (generate_ecdhe)
+ 3) Send our handshake back
+ 4) Show state
+ """
+ print(f"{BLUE}[AUTO]{RESET} Delayed ECDH process for HANDSHAKE at index={index}")
+
+ # 1) Generate ephemeral keys if we don't have them
+ if not self.ephemeral_privkey or not self.ephemeral_pubkey:
+ self.generate_ephemeral_keys()
+
+ # 2) Compute ECDH from inbound ephemeral pub
+ self.generate_ecdhe(index)
+
+ # 3) Send our handshake to the peer
+ self.send_handshake()
+
+ # 4) Show final state
+ self.show_state()
+
+ # -------------------------------------------------------------------------
+ # Public Methods
+ # -------------------------------------------------------------------------
+
+ def connect_to_peer(self, port: int):
+ conn = transmission.connect_to_peer("127.0.0.1", port, self.on_data_received)
+ self.connections.append(conn)
+ print(f"{GREEN}[IcingProtocol]{RESET} Outgoing connection to port {port} established.")
+
+ def set_peer_identity(self, peer_pubkey_hex: str):
+ pubkey_bytes = bytes.fromhex(peer_pubkey_hex)
+ self.peer_identity_pubkey_obj = load_peer_identity_key(pubkey_bytes)
+ self.peer_identity_pubkey_bytes = pubkey_bytes
+ print(f"{GREEN}[IcingProtocol]{RESET} Stored peer identity pubkey (hex={peer_pubkey_hex[:16]}...).")
+
+ def generate_ephemeral_keys(self):
+ self.ephemeral_privkey, self.ephemeral_pubkey = get_ephemeral_keypair()
+ print(f"{GREEN}[IcingProtocol]{RESET} Generated ephemeral key pair: pubkey={self.ephemeral_pubkey.hex()[:16]}...")
+
+ def send_ping_request(self):
+ if not self.connections:
+ print(f"{RED}[ERROR]{RESET} No active connections.")
+ return
+ pkt = build_ping_request(version=0)
+ self._send_packet(self.connections[0], pkt, "PING_REQUEST")
+ self.state["ping_sent"] = True
+
+ def send_handshake(self):
+ """
+ Build and send handshake:
+ - 32-bit timestamp
+ - ephemeral_pubkey (64 bytes, raw x||y)
+ - ephemeral_signature (64 bytes, raw r||s)
+ - pfs_hash (32 bytes)
+ - 32-bit CRC
+ """
+ if not self.connections:
+ print(f"{RED}[ERROR]{RESET} No active connections.")
+ return
+ if not self.ephemeral_privkey or not self.ephemeral_pubkey:
+ print(f"{RED}[ERROR]{RESET} Ephemeral keys not generated.")
+ return
+ if self.peer_identity_pubkey_bytes is None:
+ print(f"{RED}[ERROR]{RESET} Peer identity not set; needed for PFS tracking.")
+ return
+
+ # 1) Sign ephemeral_pubkey as r||s
+ # Instead of DER, we do raw r||s each 32 bytes
+ sig_der = sign_data(self.identity_privkey, self.ephemeral_pubkey)
+ # Convert DER -> (r, s) -> raw 64 bytes
+ # Quick approach to parse DER using cryptography, or do a custom parse
+ from cryptography.hazmat.primitives.asymmetric.utils import decode_dss_signature
+ r_int, s_int = decode_dss_signature(sig_der)
+ r_bytes = r_int.to_bytes(32, 'big')
+ s_bytes = s_int.to_bytes(32, 'big')
+ raw_signature = r_bytes + s_bytes # 64 bytes
+
+ # 2) PFS hash
+ session_number, last_secret_hex = self.pfs_history.get(self.peer_identity_pubkey_bytes, (-1, ""))
+ pfs = compute_pfs_hash(session_number, last_secret_hex)
+
+ # 3) Build handshake
+ timestamp_32 = int(time.time() * 1000) & 0xffffffff
+ pkt = build_handshake_message(
+ timestamp_32,
+ self.ephemeral_pubkey, # 64 bytes raw
+ raw_signature, # 64 bytes raw
+ pfs # 32 bytes
+ )
+
+ # 4) Send
+ self._send_packet(self.connections[0], pkt, "HANDSHAKE")
+ self.state["handshake_sent"] = True
+
+ def enable_auto_responder(self, enable: bool):
+ self.auto_responder = enable
+ print(f"{BLUE}[AUTO]{RESET} Auto responder set to {enable}.")
+
+ # -------------------------------------------------------------------------
+ # Manual Responses
+ # -------------------------------------------------------------------------
+
+ def respond_to_ping(self, index: int, answer_code: int):
+ """
+ Manually respond to an inbound PING_REQUEST in inbound_messages[index].
+ """
+ if index < 0 or index >= len(self.inbound_messages):
+ print(f"{RED}[ERROR]{RESET} Invalid index {index}.")
+ return
+ msg = self.inbound_messages[index]
+ if msg["type"] != "PING_REQUEST":
+ print(f"{RED}[ERROR]{RESET} inbound_messages[{index}] is not a PING_REQUEST.")
+ return
+
+ version = msg["parsed"]["version"]
+ conn = msg["connection"]
+ resp = build_ping_response(version, answer_code)
+ self._send_packet(conn, resp, "PING_RESPONSE")
+ print(f"{BLUE}[MANUAL]{RESET} Responded to ping with answer_code={answer_code}.")
+
+ def generate_ecdhe(self, index: int):
+ """
+ Formerly 'respond_to_handshake' - this verifies the inbound ephemeral signature
+ and computes the ECDH shared secret, storing it in self.shared_secret.
+ It does NOT send a handshake back.
+ """
+ if index < 0 or index >= len(self.inbound_messages):
+ print(f"{RED}[ERROR]{RESET} Invalid index {index}.")
+ return
+ msg = self.inbound_messages[index]
+ if msg["type"] != "HANDSHAKE":
+ print(f"{RED}[ERROR]{RESET} inbound_messages[{index}] is not a HANDSHAKE.")
+ return
+
+ ephemeral_pub = msg["parsed"]["ephemeral_pub"]
+ ephemeral_sig = msg["parsed"]["ephemeral_sig"]
+
+ # Verify ephemeral signature
+ if not self.peer_identity_pubkey_obj:
+ print(f"{RED}[ERROR]{RESET} Peer identity not set, cannot verify ephemeral signature.")
+ return
+ ok = verify_signature(self.peer_identity_pubkey_obj, ephemeral_sig, ephemeral_pub)
+ if not ok:
+ print(f"{RED}[ERROR]{RESET} Ephemeral signature is invalid.")
+ return
+ print(f"{GREEN}[OK]{RESET} Ephemeral signature verified successfully.")
+
+ # If we have ephemeral_privkey, compute ECDH shared key
+ if self.ephemeral_privkey:
+ shared = compute_ecdh_shared_key(self.ephemeral_privkey, ephemeral_pub)
+ self.shared_secret = shared.hex()
+ print(f"{GREEN}[OK]{RESET} Derived ECDH shared key = {self.shared_secret}")
+ else:
+ print(f"{YELLOW}[WARN]{RESET} No ephemeral_privkey available, cannot compute ECDH shared key.")
+
+ # -------------------------------------------------------------------------
+ # Utility
+ # -------------------------------------------------------------------------
+
+ def _send_packet(self, conn: transmission.PeerConnection, data: bytes, label: str):
+ bits_count = len(data) * 8
+ print(f"{BLUE}[SEND]{RESET} {label} -> {bits_count} bits: {data.hex()[:60]}{'...' if len(data.hex())>60 else ''}")
+ conn.send(data)
+
+ def show_state(self):
+ print(f"\n{YELLOW}=== Global State ==={RESET}")
+ print(f"Listening Port: {self.local_port}")
+ print(f"Identity PubKey: 512 bits => {self.identity_pubkey.hex()[:16]}...")
+
+ if self.peer_identity_pubkey_bytes:
+ print(f"Peer Identity PubKey: 512 bits => {self.peer_identity_pubkey_bytes.hex()[:16]}...")
+ else:
+ print("Peer Identity PubKey: [None]")
+
+ print("\nEphemeral Keys:")
+ if self.ephemeral_pubkey:
+ print(f" ephemeral_pubkey: 512 bits => {self.ephemeral_pubkey.hex()[:16]}...")
+ else:
+ print(" ephemeral_pubkey: [None]")
+
+ print(f"\nShared Secret: {self.shared_secret if self.shared_secret else '[None]'}")
+
+ print("\nProtocol Flags:")
+ for k, v in self.state.items():
+ print(f" {k}: {v}")
+
+ print("\nAuto Responder:", self.auto_responder)
+
+ print("\nActive Connections:")
+ for i, c in enumerate(self.connections):
+ print(f" [{i}] Alive={c.alive}")
+
+ print("\nInbound Message Queue:")
+ for i, m in enumerate(self.inbound_messages):
+ print(f" [{i}] type={m['type']} len={len(m['raw'])} bytes => {len(m['raw']) * 8} bits")
+ print()
+
+ def stop(self):
+ self.server_listener.stop()
+ for c in self.connections:
+ c.close()
+ self.connections.clear()
+ self.inbound_messages.clear()
+ print(f"{RED}[STOP]{RESET} Protocol stopped.")
diff --git a/protocol_prototype/transmission.py b/protocol_prototype/transmission.py
new file mode 100644
index 0000000..35f3a21
--- /dev/null
+++ b/protocol_prototype/transmission.py
@@ -0,0 +1,100 @@
+import socket
+import threading
+from typing import Callable
+
+class PeerConnection:
+ """
+ Represents a live, two-way connection to a peer.
+ We keep a socket open, read data in a background thread,
+ and can send data from the main thread at any time.
+ """
+ def __init__(self, sock: socket.socket, on_data_received: Callable[['PeerConnection', bytes], None]):
+ self.sock = sock
+ self.on_data_received = on_data_received
+ self.alive = True
+
+ self.read_thread = threading.Thread(target=self.read_loop, daemon=True)
+ self.read_thread.start()
+
+ def read_loop(self):
+ while self.alive:
+ try:
+ data = self.sock.recv(4096)
+ if not data:
+ break
+ self.on_data_received(self, data)
+ except OSError:
+ break
+ self.alive = False
+ self.sock.close()
+ print("[PeerConnection] Connection closed.")
+
+ def send(self, data: bytes):
+ if not self.alive:
+ print("[PeerConnection.send] Cannot send, connection not alive.")
+ return
+ try:
+ self.sock.sendall(data)
+ except OSError:
+ print("[PeerConnection.send] Send failed, connection might be closed.")
+ self.alive = False
+
+ def close(self):
+ self.alive = False
+ try:
+ self.sock.shutdown(socket.SHUT_RDWR)
+ except OSError:
+ pass
+ self.sock.close()
+
+
+class ServerListener(threading.Thread):
+ """
+ A thread that listens on a given port. When a new client connects,
+ it creates a PeerConnection for that client.
+ """
+ def __init__(self, host: str, port: int,
+ on_new_connection: Callable[[PeerConnection], None],
+ on_data_received: Callable[[PeerConnection, bytes], None]):
+ super().__init__(daemon=True)
+ self.host = host
+ self.port = port
+ self.on_new_connection = on_new_connection
+ self.on_data_received = on_data_received
+ self.server_socket = None
+ self.stop_event = threading.Event()
+
+ def run(self):
+ self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ self.server_socket.bind((self.host, self.port))
+ self.server_socket.listen(5)
+ self.server_socket.settimeout(1.0)
+ print(f"[ServerListener] Listening on {self.host}:{self.port}")
+
+ while not self.stop_event.is_set():
+ try:
+ client_sock, addr = self.server_socket.accept()
+ print(f"[ServerListener] Accepted connection from {addr}")
+ conn = PeerConnection(client_sock, self.on_data_received)
+ self.on_new_connection(conn)
+ except socket.timeout:
+ pass
+ except OSError:
+ break
+
+ if self.server_socket:
+ self.server_socket.close()
+
+ def stop(self):
+ self.stop_event.set()
+ if self.server_socket:
+ self.server_socket.close()
+
+
+def connect_to_peer(host: str, port: int,
+ on_data_received: Callable[[PeerConnection, bytes], None]) -> PeerConnection:
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.connect((host, port))
+ print(f"[connect_to_peer] Connected to {host}:{port}")
+ conn = PeerConnection(sock, on_data_received)
+ return conn