From 7c7a4f28f4446224efb838132d58e0c94a649ae5 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 14:20:56 +0100 Subject: [PATCH 01/21] feat: call page UI --- dialer/android/.gitignore | 1 + .../android/app/src/main/AndroidManifest.xml | 61 ++-- .../icing/dialer/activities/MainActivity.kt | 96 ++++-- .../dialer/services/CallConnectionService.kt | 53 +++ .../com/icing/dialer/services/CallService.kt | 51 ++- dialer/lib/features/call/call_page.dart | 324 ++++++++++++++++++ .../lib/features/composition/composition.dart | 2 +- .../contacts/widgets/contact_modal.dart | 2 +- dialer/lib/services/call_service.dart | 38 +- 9 files changed, 550 insertions(+), 78 deletions(-) create mode 100644 dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallConnectionService.kt create mode 100644 dialer/lib/features/call/call_page.dart 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..cc51efb 100644 --- a/dialer/android/app/src/main/AndroidManifest.xml +++ b/dialer/android/app/src/main/AndroidManifest.xml @@ -1,13 +1,15 @@ - - + + - - - + + + + + - + 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..53f93d7 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 @@ -3,52 +3,77 @@ package com.icing.dialer.activities import android.database.Cursor import android.os.Bundle import android.provider.CallLog +import android.telecom.TelecomManager +import android.telecom.PhoneAccountHandle +import android.telecom.PhoneAccount +import android.content.Intent +import android.content.ComponentName 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 com.icing.dialer.KeystoreHelper import com.icing.dialer.services.CallService +import com.icing.dialer.services.CallConnectionService -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" + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + registerPhoneAccount() + checkAndRequestDefaultDialer() + } + + private fun registerPhoneAccount() { + val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager + val phoneAccountHandle = PhoneAccountHandle( + ComponentName(this, CallConnectionService::class.java), + "IcingDialerAccount" + ) + val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "Icing Dialer") + .setCapabilities(PhoneAccount.CAPABILITY_CALL_PROVIDER) + .build() + telecomManager.registerPhoneAccount(phoneAccount) + } + override fun configureFlutterEngine(flutterEngine: FlutterEngine) { super.configureFlutterEngine(flutterEngine) - // 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") + 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" -> { - CallService.hangUpCall(this) - result.success("Call ended") + val success = CallService.hangUpCall(this) + if (success) { + result.success(mapOf("status" to "ended")) + } else { + result.error("HANGUP_FAILED", "Failed to end call", null) + } } else -> result.notImplemented() } } - // Set up the keystore channel. MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL) .setMethodCallHandler { call, result -> - // Delegate method calls to KeystoreHelper. KeystoreHelper(call, result).handleMethodCall() } - // Set up the call log channel. MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALLLOG_CHANNEL) .setMethodCallHandler { call, result -> if (call.method == "getCallLogs") { @@ -60,35 +85,38 @@ 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 tm = getSystemService(TELECOM_SERVICE) as TelecomManager + tm.defaultDialerPackage?.let { + if (it != packageName) { + val intent = Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER) + .putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, packageName) + startActivity(intent) + } + } + } + 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..8464027 --- /dev/null +++ b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/CallConnectionService.kt @@ -0,0 +1,53 @@ +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.net.Uri +import android.os.Bundle +import android.util.Log + +class CallConnectionService : ConnectionService() { + override fun onCreateOutgoingConnection( + connectionManagerPhoneAccount: PhoneAccountHandle?, + request: android.telecom.ConnectionRequest + ): Connection { + val connection = object : Connection() { + override fun onStateChanged(state: Int) { + super.onStateChanged(state) + Log.d("CallConnectionService", "Connection state changed: $state") + // Update Flutter UI via MethodChannel if needed + } + + override fun onDisconnect() { + setDisconnected(DisconnectCause(DisconnectCause.LOCAL)) + destroy() + } + } + connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED) + connection.setInitialized() + connection.setActive() + return connection + } + + override fun onCreateIncomingConnection( + connectionManagerPhoneAccount: PhoneAccountHandle?, + request: android.telecom.ConnectionRequest + ): Connection { + val connection = object : Connection() { + override fun onAnswer() { + setActive() + } + + override fun onDisconnect() { + 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..b9c6bd9 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.Manifest import android.content.Context import android.content.Intent import android.net.Uri -import android.telecom.TelecomManager import android.os.Build +import android.telecom.TelecomManager +import android.telephony.TelephonyManager import android.util.Log +import androidx.core.content.ContextCompat +import android.content.pm.PackageManager object CallService { - - fun makeGsmCall(context: Context, phoneNumber: String) { - try { - val intent = Intent(Intent.ACTION_CALL) - intent.data = Uri.parse("tel:$phoneNumber") - context.startActivity(intent) + + fun makeGsmCall(context: Context, phoneNumber: String): Boolean { + return try { + val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager + val uri = Uri.parse("tel:$phoneNumber") + + // Check CALL_PHONE permission + if (ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { + telecomManager.placeCall(uri, null) + true + } else { + Log.e("CallService", "GSM call not supported below Android M") + false + } + } else { + Log.e("CallService", "CALL_PHONE permission not granted") + false + } } catch (e: Exception) { Log.e("CallService", "Error making GSM call: ${e.message}") + 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 (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager + telecomManager.endCall() + true + } else { + Log.e("CallService", "Hangup call only supported on Android P or later") + false + } + } catch (e: Exception) { + Log.e("CallService", "Error hanging up call: ${e.message}") + false } } } \ No newline at end of file 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/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..c9d3760 100644 --- a/dialer/lib/features/contacts/widgets/contact_modal.dart +++ b/dialer/lib/features/contacts/widgets/contact_modal.dart @@ -262,7 +262,7 @@ class _ContactModalState extends State { ), onTap: () async { if (widget.contact.phones.isNotEmpty) { - await _callService.makeGsmCall(phoneNumber); + await _callService.makeGsmCall(context, phoneNumber: phoneNumber); } }, ), diff --git a/dialer/lib/services/call_service.dart b/dialer/lib/services/call_service.dart index c07027e..f02f745 100644 --- a/dialer/lib/services/call_service.dart +++ b/dialer/lib/services/call_service.dart @@ -1,23 +1,47 @@ import 'package:flutter/services.dart'; +import 'package:flutter/material.dart'; +import '../features/call/call_page.dart'; -// Service to manage call-related operations class CallService { static const MethodChannel _channel = MethodChannel('call_service'); - // Function to make a GSM call - Future makeGsmCall(String phoneNumber) async { + Future makeGsmCall( + BuildContext context, { + required String phoneNumber, + String? displayName, + Uint8List? thumbnail, // Added optional thumbnail + }) async { try { - await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber}); + final result = await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber}); + if (result["status"] == "calling") { + Navigator.push( + context, + MaterialPageRoute( + builder: (context) => CallPage( + displayName: displayName ?? phoneNumber, // Fallback to phoneNumber if no name + phoneNumber: phoneNumber, + thumbnail: thumbnail, // Pass the thumbnail + ), + ), + ); + } else if (result["status"] == "pending_default_dialer") { + print("Waiting for user to set app as default dialer"); + ScaffoldMessenger.of(context).showSnackBar( + SnackBar(content: Text("Please set this app as your default dialer to proceed")), + ); + } } catch (e) { print("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'); + final result = await _channel.invokeMethod('hangUpCall'); + if (result["status"] == "ended") { + Navigator.pop(context); + } } catch (e) { print("Error hanging up call: $e"); rethrow; From ef78e4c17d0be43d449bbe97ce7d3457866a3aea Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 13:05:42 +0000 Subject: [PATCH 02/21] fix: call correctly in history page (#41) Reviewed-on: https://git.gmoker.com/icing/monorepo/pulls/41 Co-authored-by: Florian Griffon Co-committed-by: Florian Griffon --- dialer/lib/features/history/history_page.dart | 112 ++++++++++-------- 1 file changed, 63 insertions(+), 49 deletions(-) diff --git a/dialer/lib/features/history/history_page.dart b/dialer/lib/features/history/history_page.dart index 1108a2e..117d1e8 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(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), ), ], ), From b7ebacec85c159ee52454bb2c224f8534a38b6a6 Mon Sep 17 00:00:00 2001 From: ange Date: Tue, 4 Mar 2025 13:06:08 +0000 Subject: [PATCH 03/21] cicd-stealth (#40) Reviewed-on: https://git.gmoker.com/icing/monorepo/pulls/40 Co-authored-by: ange Co-committed-by: ange --- .gitea/workflows/apk.yaml | 16 +++++++++++++++- dialer/build.sh | 7 ++++++- dialer/run.sh | 7 ++++++- dialer/stealth_local_run.sh | 3 ++- 4 files changed, 29 insertions(+), 4 deletions(-) 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/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/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 From 9bfb55821dca3fa883cbca53cfe52251a871c33e Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 13:10:42 +0000 Subject: [PATCH 04/21] fix: search bar upgrade (#42) Reviewed-on: https://git.gmoker.com/icing/monorepo/pulls/42 Co-authored-by: Florian Griffon Co-committed-by: Florian Griffon --- dialer/lib/features/home/home_page.dart | 159 ++++++++++++++++++------ 1 file changed, 120 insertions(+), 39 deletions(-) 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(); From b042a68a8e2bc6ec930bb5274e56e87629959e99 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 14:23:02 +0100 Subject: [PATCH 05/21] fix: makeGsmCall in historypage --- dialer/lib/features/history/history_page.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dialer/lib/features/history/history_page.dart b/dialer/lib/features/history/history_page.dart index 117d1e8..2ce20b8 100644 --- a/dialer/lib/features/history/history_page.dart +++ b/dialer/lib/features/history/history_page.dart @@ -419,7 +419,7 @@ class _HistoryPageState extends State icon: const Icon(Icons.phone, color: Colors.green), onPressed: () async { if (contact.phones.isNotEmpty) { - _callService.makeGsmCall(contact.phones.first.number); + _callService.makeGsmCall(context, phoneNumber: contact.phones.first.number); } else { ScaffoldMessenger.of(context).showSnackBar( const SnackBar( From 24dc5a9bbe27d95cbf6fac66831189b54cc0489c Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 18:43:48 +0100 Subject: [PATCH 06/21] feat: update flutter UI via methodchannel, permissions via flutter at startup --- .../android/app/src/main/AndroidManifest.xml | 3 +- .../icing/dialer/activities/MainActivity.kt | 232 +++++++++++++----- .../dialer/services/CallConnectionService.kt | 15 +- 3 files changed, 184 insertions(+), 66 deletions(-) diff --git a/dialer/android/app/src/main/AndroidManifest.xml b/dialer/android/app/src/main/AndroidManifest.xml index cc51efb..43eb3c3 100644 --- a/dialer/android/app/src/main/AndroidManifest.xml +++ b/dialer/android/app/src/main/AndroidManifest.xml @@ -1,4 +1,6 @@ + + @@ -48,7 +50,6 @@ - , + // grantResults: IntArray + // ) { + // super.onRequestPermissionsResult(requestCode, permissions, grantResults) + // Log.d(TAG, "onRequestPermissionsResult: $requestCode, ${grantResults.joinToString()}") + // if (requestCode == REQUEST_CALL_PERMISSIONS && + // grantResults.all { it == PackageManager.PERMISSION_GRANTED } + // ) { + // Log.d(TAG, "All permissions granted") + // registerPhoneAccount() + // checkAndRequestDefaultDialer() + // } else { + // Log.e( + // TAG, + // "Required permissions not granted: ${permissions.joinToString()}, + // ${grantResults.joinToString()}" + // ) + // } + // } + private fun registerPhoneAccount() { val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager - val phoneAccountHandle = PhoneAccountHandle( - ComponentName(this, CallConnectionService::class.java), - "IcingDialerAccount" - ) - val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "Icing Dialer") - .setCapabilities(PhoneAccount.CAPABILITY_CALL_PROVIDER) - .build() + val phoneAccountHandle = + PhoneAccountHandle( + ComponentName(this, CallConnectionService::class.java), + "IcingDialerAccount" + ) + val phoneAccount = + PhoneAccount.builder(phoneAccountHandle, "Icing Dialer") + .setCapabilities( + PhoneAccount.CAPABILITY_CALL_PROVIDER or + PhoneAccount.CAPABILITY_CONNECTION_MANAGER + ) + .build() telecomManager.registerPhoneAccount(phoneAccount) + CallService.setPhoneAccountHandle(phoneAccountHandle) + Log.d(TAG, "PhoneAccount registered: ${phoneAccountHandle.id}") + Log.d( + TAG, + "Registered PhoneAccounts: ${telecomManager.callCapablePhoneAccounts.joinToString()}" + ) } override fun configureFlutterEngine(flutterEngine: FlutterEngine) { super.configureFlutterEngine(flutterEngine) - MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL).setMethodCallHandler { call, result -> - when (call.method) { - "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) + MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL) + .setMethodCallHandler { call, result -> + when (call.method) { + "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 + ) + } } - } 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) + } + } + else -> result.notImplemented() } } - "hangUpCall" -> { - val success = CallService.hangUpCall(this) - if (success) { - result.success(mapOf("status" to "ended")) - } else { - result.error("HANGUP_FAILED", "Failed to end call", null) - } - } - else -> result.notImplemented() - } - } MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL) - .setMethodCallHandler { call, result -> - KeystoreHelper(call, result).handleMethodCall() - } + .setMethodCallHandler { call, result -> + KeystoreHelper(call, result).handleMethodCall() + } MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALLLOG_CHANNEL) - .setMethodCallHandler { call, result -> - if (call.method == "getCallLogs") { - val callLogs = getCallLogs() - result.success(callLogs) - } else { - result.notImplemented() + .setMethodCallHandler { call, result -> + if (call.method == "getCallLogs") { + val callLogs = getCallLogs() + result.success(callLogs) + } else { + result.notImplemented() + } } - } } private fun checkAndRequestDefaultDialer() { val tm = getSystemService(TELECOM_SERVICE) as TelecomManager - tm.defaultDialerPackage?.let { - if (it != packageName) { - val intent = Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER) - .putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, packageName) - startActivity(intent) + val currentDefault = tm.defaultDialerPackage + Log.d(TAG, "Current default dialer: $currentDefault, My package: $packageName") + if (currentDefault != packageName) { + val intent = + Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER) + .putExtra( + TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, + packageName + ) + try { + startActivityForResult(intent, 1001) // Use startActivityForResult to track response + Log.d(TAG, "Default dialer prompt launched with requestCode 1001") + } catch (e: Exception) { + Log.e(TAG, "Failed to launch default dialer prompt: ${e.message}", e) + } + } else { + Log.d(TAG, "Already the default dialer") + } + } + + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { + super.onActivityResult(requestCode, resultCode, data) + Log.d(TAG, "onActivityResult: requestCode=$requestCode, resultCode=$resultCode") + if (requestCode == 1001) { + if (resultCode == RESULT_OK) { + Log.d(TAG, "User accepted default dialer change") + } else { + Log.d(TAG, "User rejected or canceled default dialer change") } } } private fun getCallLogs(): List> { val logsList = mutableListOf>() - val cursor: Cursor? = contentResolver.query( - CallLog.Calls.CONTENT_URI, null, null, null, CallLog.Calls.DATE + " DESC" - ) + val cursor: Cursor? = + contentResolver.query( + CallLog.Calls.CONTENT_URI, + null, + null, + null, + CallLog.Calls.DATE + " DESC" + ) cursor?.use { while (it.moveToNext()) { val number = it.getString(it.getColumnIndexOrThrow(CallLog.Calls.NUMBER)) @@ -108,15 +213,16 @@ class MainActivity : FlutterActivity() { val date = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DATE)) val duration = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DURATION)) - val map = mutableMapOf( - "number" to number, - "type" to type, - "date" to date, - "duration" to duration - ) + val map = + mutableMapOf( + "number" to number, + "type" to type, + "date" to date, + "duration" to duration + ) logsList.add(map) } } 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 index 8464027..ea5e1f0 100644 --- 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 @@ -8,8 +8,13 @@ import android.telecom.DisconnectCause import android.net.Uri import android.os.Bundle import android.util.Log +import io.flutter.plugin.common.MethodChannel class CallConnectionService : ConnectionService() { + companion object { + var channel: MethodChannel? = null + } + override fun onCreateOutgoingConnection( connectionManagerPhoneAccount: PhoneAccountHandle?, request: android.telecom.ConnectionRequest @@ -18,7 +23,13 @@ class CallConnectionService : ConnectionService() { override fun onStateChanged(state: Int) { super.onStateChanged(state) Log.d("CallConnectionService", "Connection state changed: $state") - // Update Flutter UI via MethodChannel if needed + 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() { @@ -28,7 +39,7 @@ class CallConnectionService : ConnectionService() { } connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED) connection.setInitialized() - connection.setActive() + connection.setDialing() // Start in dialing state return connection } From c886e29d752ab2c2dee6b25855f3bfb10b5b1dff Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 18:44:55 +0100 Subject: [PATCH 07/21] feat: perms & UI methodchannel --- .../com/icing/dialer/services/CallService.kt | 12 +++++- dialer/lib/main.dart | 27 ++++++++++-- dialer/lib/services/call_service.dart | 41 ++++++++++++++----- 3 files changed, 63 insertions(+), 17 deletions(-) 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 b9c6bd9..8dbf4c1 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 @@ -5,23 +5,31 @@ import android.content.Context import android.content.Intent import android.net.Uri import android.os.Build +import android.os.Bundle import android.telecom.TelecomManager +import android.telecom.PhoneAccountHandle import android.telephony.TelephonyManager import android.util.Log import androidx.core.content.ContextCompat import android.content.pm.PackageManager object CallService { + private var phoneAccountHandle: PhoneAccountHandle? = null + + fun setPhoneAccountHandle(handle: PhoneAccountHandle) { + phoneAccountHandle = handle + } fun makeGsmCall(context: Context, phoneNumber: String): Boolean { return try { val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager val uri = Uri.parse("tel:$phoneNumber") - // Check CALL_PHONE permission if (ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { - telecomManager.placeCall(uri, null) + val extras = Bundle() + extras.putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle) + telecomManager.placeCall(uri, extras) true } else { Log.e("CallService", "GSM call not supported below Android M") diff --git a/dialer/lib/main.dart b/dialer/lib/main.dart index afde3b9..4aa2170 100644 --- a/dialer/lib/main.dart +++ b/dialer/lib/main.dart @@ -1,8 +1,10 @@ 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 '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 +15,35 @@ void main() async { final AsymmetricCryptoService cryptoService = AsymmetricCryptoService(); await cryptoService.initializeDefaultKeyPair(); + // Request permissions before running the app + await _requestPermissions(); + + CallService(); // Initialize CallService + runApp( MultiProvider( providers: [ Provider( create: (_) => cryptoService, ), - // Add other providers here ], child: Dialer(), ), ); } +Future _requestPermissions() async { + Map statuses = await [ + Permission.phone, + Permission.contacts, + ].request(); + if (statuses.values.every((status) => status.isGranted)) { + print("All required permissions granted"); + } 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 +51,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 f02f745..21fef7c 100644 --- a/dialer/lib/services/call_service.dart +++ b/dialer/lib/services/call_service.dart @@ -4,26 +4,45 @@ import '../features/call/call_page.dart'; class CallService { static const MethodChannel _channel = MethodChannel('call_service'); + static String? currentPhoneNumber; + + CallService() { + _channel.setMethodCallHandler((call) async { + if (call.method == "callStateChanged") { + final state = call.arguments["state"] as String; + final phoneNumber = call.arguments["phoneNumber"] as String; + if (state == "dialing" || state == "active") { + Navigator.push( + navigatorKey.currentContext!, + MaterialPageRoute( + builder: (context) => CallPage( + displayName: phoneNumber, // Replace with contact lookup if available + phoneNumber: phoneNumber, + thumbnail: null, + ), + ), + ); + } else if (state == "disconnected") { + Navigator.pop(navigatorKey.currentContext!); + } + } + }); + } + + // Add a GlobalKey for Navigator + static final GlobalKey navigatorKey = GlobalKey(); Future makeGsmCall( BuildContext context, { required String phoneNumber, String? displayName, - Uint8List? thumbnail, // Added optional thumbnail + Uint8List? thumbnail, }) async { try { + currentPhoneNumber = phoneNumber; final result = await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber}); if (result["status"] == "calling") { - Navigator.push( - context, - MaterialPageRoute( - builder: (context) => CallPage( - displayName: displayName ?? phoneNumber, // Fallback to phoneNumber if no name - phoneNumber: phoneNumber, - thumbnail: thumbnail, // Pass the thumbnail - ), - ), - ); + // CallPage will be shown via CallConnectionService callback } else if (result["status"] == "pending_default_dialer") { print("Waiting for user to set app as default dialer"); ScaffoldMessenger.of(context).showSnackBar( From 5529a6e038cd61799fa1b79f89c8e8f9e2c945c5 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Wed, 5 Mar 2025 16:04:05 +0100 Subject: [PATCH 08/21] feat: request perm in flutter, wait for perm before trying to become main dialer --- .../icing/dialer/activities/MainActivity.kt | 115 ++++++++---------- .../dialer/services/CallConnectionService.kt | 26 +++- dialer/lib/main.dart | 4 + 3 files changed, 77 insertions(+), 68 deletions(-) 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 7df838e..9a8ff2e 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,14 +1,18 @@ package com.icing.dialer.activities +import android.Manifest import android.content.ComponentName import android.content.Intent +import android.content.pm.PackageManager import android.database.Cursor +import android.net.Uri import android.os.Bundle import android.provider.CallLog import android.telecom.PhoneAccount import android.telecom.PhoneAccountHandle import android.telecom.TelecomManager import android.util.Log +import androidx.core.content.ContextCompat import com.icing.dialer.KeystoreHelper import com.icing.dialer.services.CallConnectionService import com.icing.dialer.services.CallService @@ -20,69 +24,14 @@ class MainActivity : FlutterActivity() { private val KEYSTORE_CHANNEL = "com.example.keystore" private val CALLLOG_CHANNEL = "com.example.calllog" private val CALL_CHANNEL = "call_service" - private val REQUEST_CALL_PERMISSIONS = 1 private val TAG = "MainActivity" override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) Log.d(TAG, "onCreate started") - registerPhoneAccount() - checkAndRequestDefaultDialer() - Log.d(TAG, "onCreate completed") + Log.d(TAG, "Waiting for Flutter to signal permissions") } - // private fun checkPermissions(): Boolean { - // val permissions = - // arrayOf( - // Manifest.permission.CALL_PHONE, - // Manifest.permission.READ_PHONE_STATE, - // Manifest.permission.MANAGE_OWN_CALLS, - // Manifest.permission.READ_CONTACTS // Add this - // ) - // return permissions - // .all { - // ContextCompat.checkSelfPermission(this, it) == - // PackageManager.PERMISSION_GRANTED - // } - // .also { Log.d(TAG, "Permissions check result: $it") } - // } - - // private fun requestPermissions() { - // ActivityCompat.requestPermissions( - // this, - // arrayOf( - // Manifest.permission.CALL_PHONE, - // Manifest.permission.READ_PHONE_STATE, - // Manifest.permission.MANAGE_OWN_CALLS, - // Manifest.permission.READ_CONTACTS // Add this - // ), - // REQUEST_CALL_PERMISSIONS - // ) - // Log.d(TAG, "Permission request dispatched") - // } - - // override fun onRequestPermissionsResult( - // requestCode: Int, - // permissions: Array, - // grantResults: IntArray - // ) { - // super.onRequestPermissionsResult(requestCode, permissions, grantResults) - // Log.d(TAG, "onRequestPermissionsResult: $requestCode, ${grantResults.joinToString()}") - // if (requestCode == REQUEST_CALL_PERMISSIONS && - // grantResults.all { it == PackageManager.PERMISSION_GRANTED } - // ) { - // Log.d(TAG, "All permissions granted") - // registerPhoneAccount() - // checkAndRequestDefaultDialer() - // } else { - // Log.e( - // TAG, - // "Required permissions not granted: ${permissions.joinToString()}, - // ${grantResults.joinToString()}" - // ) - // } - // } - private fun registerPhoneAccount() { val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager val phoneAccountHandle = @@ -90,6 +39,7 @@ class MainActivity : FlutterActivity() { ComponentName(this, CallConnectionService::class.java), "IcingDialerAccount" ) + Log.d(TAG, "PhoneAccountHandle component: ${phoneAccountHandle.componentName}") val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "Icing Dialer") .setCapabilities( @@ -100,18 +50,46 @@ class MainActivity : FlutterActivity() { telecomManager.registerPhoneAccount(phoneAccount) CallService.setPhoneAccountHandle(phoneAccountHandle) Log.d(TAG, "PhoneAccount registered: ${phoneAccountHandle.id}") - Log.d( - TAG, - "Registered PhoneAccounts: ${telecomManager.callCapablePhoneAccounts.joinToString()}" - ) + + val registeredAccounts = telecomManager.callCapablePhoneAccounts + Log.d(TAG, "Registered PhoneAccounts: ${registeredAccounts.joinToString()}") + if (!registeredAccounts.contains(phoneAccountHandle)) { + Log.w(TAG, "PhoneAccount not found in callCapablePhoneAccounts") + if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) == + PackageManager.PERMISSION_GRANTED + ) { + val uri = Uri.parse("tel:1234567890") + val extras = + Bundle().apply { + putParcelable( + TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, + phoneAccountHandle + ) + } + telecomManager.placeCall(uri, extras) + Log.d(TAG, "Triggered dummy call to bind CallConnectionService") + } else { + Log.w(TAG, "CALL_PHONE permission not granted, cannot test binding") + } + } else { + Log.d(TAG, "PhoneAccount successfully found in callCapablePhoneAccounts") + } } override fun configureFlutterEngine(flutterEngine: FlutterEngine) { super.configureFlutterEngine(flutterEngine) - + Log.d(TAG, "Configuring Flutter engine") + CallConnectionService.channel = + MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL) MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL) .setMethodCallHandler { call, result -> when (call.method) { + "permissionsGranted" -> { + Log.d(TAG, "Received permissionsGranted from Flutter") + registerPhoneAccount() + checkAndRequestDefaultDialer() + result.success(true) + } "makeGsmCall" -> { val phoneNumber = call.argument("phoneNumber") if (phoneNumber != null) { @@ -173,25 +151,34 @@ class MainActivity : FlutterActivity() { TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, packageName ) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) try { - startActivityForResult(intent, 1001) // Use startActivityForResult to track response + startActivityForResult(intent, 1001) Log.d(TAG, "Default dialer prompt launched with requestCode 1001") } 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") + Log.d(TAG, "onActivityResult: requestCode=$requestCode, resultCode=$resultCode, data=$data") if (requestCode == 1001) { if (resultCode == RESULT_OK) { Log.d(TAG, "User accepted default dialer change") } else { - Log.d(TAG, "User rejected or canceled default dialer change") + Log.d(TAG, "Default dialer prompt canceled (resultCode=$resultCode)") + launchDefaultAppsSettings() } } } 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 index ea5e1f0..53d73b2 100644 --- 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 @@ -5,24 +5,38 @@ import android.telecom.ConnectionService import android.telecom.PhoneAccountHandle import android.telecom.TelecomManager import android.telecom.DisconnectCause -import android.net.Uri -import android.os.Bundle 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("CallConnectionService", "Connection state changed: $state") + Log.d(TAG, "Connection state changed: $state") val stateStr = when (state) { STATE_DIALING -> "dialing" STATE_ACTIVE -> "active" @@ -33,13 +47,14 @@ class CallConnectionService : ConnectionService() { } override fun onDisconnect() { + Log.d(TAG, "Connection disconnected") setDisconnected(DisconnectCause(DisconnectCause.LOCAL)) destroy() } } connection.setAddress(request.address, TelecomManager.PRESENTATION_ALLOWED) connection.setInitialized() - connection.setDialing() // Start in dialing state + connection.setDialing() return connection } @@ -47,12 +62,15 @@ class CallConnectionService : ConnectionService() { 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() } diff --git a/dialer/lib/main.dart b/dialer/lib/main.dart index 4aa2170..80751b2 100644 --- a/dialer/lib/main.dart +++ b/dialer/lib/main.dart @@ -2,6 +2,7 @@ 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'; @@ -39,6 +40,9 @@ Future _requestPermissions() async { ].request(); if (statuses.values.every((status) => status.isGranted)) { print("All required permissions granted"); + // Signal MainActivity + 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(', ')}"); } From 98f199f4500d016c6c470fc6d048463e08178908 Mon Sep 17 00:00:00 2001 From: alexis Date: Fri, 7 Mar 2025 22:40:16 +0000 Subject: [PATCH 09/21] Add CallPage for initiating calls with contact details (#37) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Demo call page avec les features de base: - Haut parleur - Couper/activer micro - keypad - raccrocher - Display Icing state (toucher pour switch l'état) S'active en faisant un appui long sur le bouton d'appel depuis les détails du contact. Compatible avec l'obfuscation des contacts. Co-authored-by: AlexisDanlos <91090088+AlexisDanlos@users.noreply.github.com> Reviewed-on: https://git.gmoker.com/icing/monorepo/pulls/37 Co-authored-by: alexis Co-committed-by: alexis --- .../features/contacts/widgets/contact_modal.dart | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/dialer/lib/features/contacts/widgets/contact_modal.dart b/dialer/lib/features/contacts/widgets/contact_modal.dart index c9d3760..be97803 100644 --- a/dialer/lib/features/contacts/widgets/contact_modal.dart +++ b/dialer/lib/features/contacts/widgets/contact_modal.dart @@ -5,6 +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 '../../../features/call/call_page.dart'; import '../../../services/call_service.dart'; // Import CallService class ContactModal extends StatefulWidget { @@ -265,6 +266,18 @@ class _ContactModalState extends State { await _callService.makeGsmCall(context, phoneNumber: phoneNumber); } }, + onLongPress: () { + // Navigate to the beautiful calling page demo + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => CallPage( + displayName: widget.contact.displayName, + thumbnail: widget.contact.thumbnail, + ), + ), + ); + }, ), ListTile( leading: const Icon(Icons.message, color: Colors.blue), From 26316cf97153e5088950f3978d805b94370a7f55 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 14:20:56 +0100 Subject: [PATCH 10/21] feat: call page UI --- .../android/app/src/main/AndroidManifest.xml | 31 +++++++++++++++++-- .../icing/dialer/activities/MainActivity.kt | 2 +- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/dialer/android/app/src/main/AndroidManifest.xml b/dialer/android/app/src/main/AndroidManifest.xml index 43eb3c3..9c369ce 100644 --- a/dialer/android/app/src/main/AndroidManifest.xml +++ b/dialer/android/app/src/main/AndroidManifest.xml @@ -1,8 +1,8 @@ - - + + @@ -12,6 +12,11 @@ + + + + + + android:name="io.flutter.embedding.android.NormalTheme" + android:resource="@style/NormalTheme" /> + + + + + + + + + + + + + + + + + @@ -65,10 +89,13 @@ android:value="2" /> + + + \ 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 9a8ff2e..5e66145 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 @@ -212,4 +212,4 @@ class MainActivity : FlutterActivity() { } return logsList } -} +} \ No newline at end of file From e4ad9726aeac3d2510838b1aca2e04557c554936 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Thu, 13 Mar 2025 22:45:14 +0200 Subject: [PATCH 11/21] rebase --- .../features/contacts/widgets/contact_modal.dart | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/dialer/lib/features/contacts/widgets/contact_modal.dart b/dialer/lib/features/contacts/widgets/contact_modal.dart index be97803..c9d3760 100644 --- a/dialer/lib/features/contacts/widgets/contact_modal.dart +++ b/dialer/lib/features/contacts/widgets/contact_modal.dart @@ -5,7 +5,6 @@ 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 '../../../features/call/call_page.dart'; import '../../../services/call_service.dart'; // Import CallService class ContactModal extends StatefulWidget { @@ -266,18 +265,6 @@ class _ContactModalState extends State { await _callService.makeGsmCall(context, phoneNumber: phoneNumber); } }, - onLongPress: () { - // Navigate to the beautiful calling page demo - Navigator.push( - context, - MaterialPageRoute( - builder: (_) => CallPage( - displayName: widget.contact.displayName, - thumbnail: widget.contact.thumbnail, - ), - ), - ); - }, ), ListTile( leading: const Icon(Icons.message, color: Colors.blue), From 5704fa1607f01630852a3a756af6412056b8d168 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Fri, 14 Mar 2025 00:21:21 +0200 Subject: [PATCH 12/21] feat: APP IS DEFAULT DIALER --- .../android/app/src/main/AndroidManifest.xml | 56 ++--- .../icing/dialer/activities/MainActivity.kt | 213 +++++++----------- .../dialer/services/CallConnectionService.kt | 146 ++++++------ .../com/icing/dialer/services/CallService.kt | 38 ++-- .../icing/dialer/services/MyInCallService.kt | 60 +++++ dialer/lib/main.dart | 1 + dialer/lib/services/call_service.dart | 86 ++++--- 7 files changed, 314 insertions(+), 286 deletions(-) create mode 100644 dialer/android/app/src/main/kotlin/com/icing/dialer/services/MyInCallService.kt diff --git a/dialer/android/app/src/main/AndroidManifest.xml b/dialer/android/app/src/main/AndroidManifest.xml index 9c369ce..95b4a91 100644 --- a/dialer/android/app/src/main/AndroidManifest.xml +++ b/dialer/android/app/src/main/AndroidManifest.xml @@ -1,8 +1,8 @@ - - + + @@ -12,11 +12,6 @@ - - - - - - + - - - - - android:name="io.flutter.embedding.android.NormalTheme" - android:resource="@style/NormalTheme" /> - - - - - - - - - - - - - - + + + + + + @@ -75,27 +56,36 @@ + + + + + + + + - - - - \ 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 5e66145..8354324 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,21 +1,21 @@ package com.icing.dialer.activities import android.Manifest -import android.content.ComponentName +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 android.telecom.PhoneAccount -import android.telecom.PhoneAccountHandle import android.telecom.TelecomManager import android.util.Log import androidx.core.content.ContextCompat import com.icing.dialer.KeystoreHelper -import com.icing.dialer.services.CallConnectionService 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 @@ -25,6 +25,7 @@ class MainActivity : FlutterActivity() { 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) @@ -32,132 +33,84 @@ class MainActivity : FlutterActivity() { Log.d(TAG, "Waiting for Flutter to signal permissions") } - private fun registerPhoneAccount() { - val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager - val phoneAccountHandle = - PhoneAccountHandle( - ComponentName(this, CallConnectionService::class.java), - "IcingDialerAccount" - ) - Log.d(TAG, "PhoneAccountHandle component: ${phoneAccountHandle.componentName}") - val phoneAccount = - PhoneAccount.builder(phoneAccountHandle, "Icing Dialer") - .setCapabilities( - PhoneAccount.CAPABILITY_CALL_PROVIDER or - PhoneAccount.CAPABILITY_CONNECTION_MANAGER - ) - .build() - telecomManager.registerPhoneAccount(phoneAccount) - CallService.setPhoneAccountHandle(phoneAccountHandle) - Log.d(TAG, "PhoneAccount registered: ${phoneAccountHandle.id}") - - val registeredAccounts = telecomManager.callCapablePhoneAccounts - Log.d(TAG, "Registered PhoneAccounts: ${registeredAccounts.joinToString()}") - if (!registeredAccounts.contains(phoneAccountHandle)) { - Log.w(TAG, "PhoneAccount not found in callCapablePhoneAccounts") - if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) == - PackageManager.PERMISSION_GRANTED - ) { - val uri = Uri.parse("tel:1234567890") - val extras = - Bundle().apply { - putParcelable( - TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, - phoneAccountHandle - ) - } - telecomManager.placeCall(uri, extras) - Log.d(TAG, "Triggered dummy call to bind CallConnectionService") - } else { - Log.w(TAG, "CALL_PHONE permission not granted, cannot test binding") - } - } else { - Log.d(TAG, "PhoneAccount successfully found in callCapablePhoneAccounts") - } - } - override fun configureFlutterEngine(flutterEngine: FlutterEngine) { super.configureFlutterEngine(flutterEngine) Log.d(TAG, "Configuring Flutter engine") - CallConnectionService.channel = - MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL) + + MyInCallService.channel = MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL) MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALL_CHANNEL) - .setMethodCallHandler { call, result -> - when (call.method) { - "permissionsGranted" -> { - Log.d(TAG, "Received permissionsGranted from Flutter") - registerPhoneAccount() - 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) - } - } - else -> result.notImplemented() + .setMethodCallHandler { call, result -> + 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) + } + } + else -> result.notImplemented() } + } MethodChannel(flutterEngine.dartExecutor.binaryMessenger, KEYSTORE_CHANNEL) - .setMethodCallHandler { call, result -> - KeystoreHelper(call, result).handleMethodCall() - } + .setMethodCallHandler { call, result -> KeystoreHelper(call, result).handleMethodCall() } MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CALLLOG_CHANNEL) - .setMethodCallHandler { call, result -> - if (call.method == "getCallLogs") { - val callLogs = getCallLogs() - result.success(callLogs) - } else { - result.notImplemented() - } + .setMethodCallHandler { call, result -> + if (call.method == "getCallLogs") { + val callLogs = getCallLogs() + result.success(callLogs) + } else { + result.notImplemented() } + } } private fun checkAndRequestDefaultDialer() { - val tm = getSystemService(TELECOM_SERVICE) as TelecomManager - val currentDefault = tm.defaultDialerPackage + val telecomManager = getSystemService(TELECOM_SERVICE) as TelecomManager + val currentDefault = telecomManager.defaultDialerPackage Log.d(TAG, "Current default dialer: $currentDefault, My package: $packageName") + if (currentDefault != packageName) { - 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, 1001) - Log.d(TAG, "Default dialer prompt launched with requestCode 1001") - } catch (e: Exception) { - Log.e(TAG, "Failed to launch default dialer prompt: ${e.message}", e) - launchDefaultAppsSettings() + 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") @@ -173,11 +126,11 @@ class MainActivity : FlutterActivity() { 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 == 1001) { + if (requestCode == REQUEST_CODE_SET_DEFAULT_DIALER) { if (resultCode == RESULT_OK) { Log.d(TAG, "User accepted default dialer change") } else { - Log.d(TAG, "Default dialer prompt canceled (resultCode=$resultCode)") + Log.w(TAG, "Default dialer prompt canceled or failed (resultCode=$resultCode)") launchDefaultAppsSettings() } } @@ -185,14 +138,13 @@ class MainActivity : FlutterActivity() { private fun getCallLogs(): List> { val logsList = mutableListOf>() - val cursor: Cursor? = - contentResolver.query( - CallLog.Calls.CONTENT_URI, - null, - null, - null, - CallLog.Calls.DATE + " DESC" - ) + val cursor: Cursor? = contentResolver.query( + CallLog.Calls.CONTENT_URI, + null, + null, + null, + CallLog.Calls.DATE + " DESC" + ) cursor?.use { while (it.moveToNext()) { val number = it.getString(it.getColumnIndexOrThrow(CallLog.Calls.NUMBER)) @@ -200,13 +152,12 @@ class MainActivity : FlutterActivity() { val date = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DATE)) val duration = it.getLong(it.getColumnIndexOrThrow(CallLog.Calls.DURATION)) - val map = - mutableMapOf( - "number" to number, - "type" to type, - "date" to date, - "duration" to duration - ) + val map = mutableMapOf( + "number" to number, + "type" to type, + "date" to date, + "duration" to duration + ) logsList.add(map) } } 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 index 53d73b2..c39d608 100644 --- 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 @@ -1,82 +1,82 @@ -package com.icing.dialer.services +// 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 +// 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" - } +// class CallConnectionService : ConnectionService() { +// companion object { +// var channel: MethodChannel? = null +// private const val TAG = "CallConnectionService" +// } - init { - Log.d(TAG, "CallConnectionService initialized") - } +// init { +// Log.d(TAG, "CallConnectionService initialized") +// } - override fun onCreate() { - super.onCreate() - Log.d(TAG, "Service created") - } +// override fun onCreate() { +// super.onCreate() +// Log.d(TAG, "Service created") +// } - override fun onDestroy() { - super.onDestroy() - Log.d(TAG, "Service destroyed") - } +// 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 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 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 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 +// 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 8dbf4c1..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,24 +1,17 @@ package com.icing.dialer.services -import android.Manifest import android.content.Context -import android.content.Intent import android.net.Uri import android.os.Build import android.os.Bundle import android.telecom.TelecomManager -import android.telecom.PhoneAccountHandle -import android.telephony.TelephonyManager import android.util.Log import androidx.core.content.ContextCompat import android.content.pm.PackageManager +import android.Manifest object CallService { - private var phoneAccountHandle: PhoneAccountHandle? = null - - fun setPhoneAccountHandle(handle: PhoneAccountHandle) { - phoneAccountHandle = handle - } + private val TAG = "CallService" fun makeGsmCall(context: Context, phoneNumber: String): Boolean { return try { @@ -26,37 +19,36 @@ object CallService { val uri = Uri.parse("tel:$phoneNumber") if (ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED) { - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { - val extras = Bundle() - extras.putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle) - telecomManager.placeCall(uri, extras) - true - } else { - Log.e("CallService", "GSM call not supported below Android M") - false - } + telecomManager.placeCall(uri, Bundle()) + Log.d(TAG, "Initiated call to $phoneNumber") + true } else { - Log.e("CallService", "CALL_PHONE permission not granted") + 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): Boolean { return try { - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + 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("CallService", "Hangup call only supported on Android P or later") + Log.e(TAG, "No active call and hangup not supported below Android P") false } } catch (e: Exception) { - Log.e("CallService", "Error hanging up call: ${e.message}") + Log.e(TAG, "Error hanging up call: ${e.message}", e) false } } 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..c4b67c7 --- /dev/null +++ b/dialer/android/app/src/main/kotlin/com/icing/dialer/services/MyInCallService.kt @@ -0,0 +1,60 @@ +package com.icing.dialer.services + +import android.telecom.Call +import android.telecom.InCallService +import io.flutter.plugin.common.MethodChannel + +class MyInCallService : InCallService() { + companion object { + var channel: MethodChannel? = null + var currentCall: Call? = null + } + + 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" + else -> "unknown" + } + channel?.invokeMethod("callStateChanged", mapOf( + "callId" to call.details.handle.toString(), + "state" to stateStr + )) + if (state == Call.STATE_DISCONNECTED || state == Call.STATE_DISCONNECTING) { + 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" + else -> "unknown" + } + channel?.invokeMethod("callAdded", mapOf( + "callId" to call.details.handle.toString(), + "state" to stateStr + )) + call.registerCallback(callCallback) + } + + override fun onCallRemoved(call: Call) { + super.onCallRemoved(call) + 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) + channel?.invokeMethod("audioStateChanged", mapOf("route" to state.route)) + } +} \ No newline at end of file diff --git a/dialer/lib/main.dart b/dialer/lib/main.dart index 80751b2..0c8068f 100644 --- a/dialer/lib/main.dart +++ b/dialer/lib/main.dart @@ -37,6 +37,7 @@ 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"); diff --git a/dialer/lib/services/call_service.dart b/dialer/lib/services/call_service.dart index 21fef7c..6b6ed48 100644 --- a/dialer/lib/services/call_service.dart +++ b/dialer/lib/services/call_service.dart @@ -1,37 +1,66 @@ -import 'package:flutter/services.dart'; import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; import '../features/call/call_page.dart'; class CallService { static const MethodChannel _channel = MethodChannel('call_service'); static String? currentPhoneNumber; + // Add a GlobalKey for Navigator + static final GlobalKey navigatorKey = GlobalKey(); + CallService() { _channel.setMethodCallHandler((call) async { - if (call.method == "callStateChanged") { - final state = call.arguments["state"] as String; - final phoneNumber = call.arguments["phoneNumber"] as String; - if (state == "dialing" || state == "active") { - Navigator.push( - navigatorKey.currentContext!, - MaterialPageRoute( - builder: (context) => CallPage( - displayName: phoneNumber, // Replace with contact lookup if available - phoneNumber: phoneNumber, - thumbnail: null, + final context = navigatorKey.currentContext; + if (context == null) return; + + switch (call.method) { + case "callAdded": + final phoneNumber = call.arguments["callId"] as String; // tel:1234567890 + final state = call.arguments["state"] as String; + currentPhoneNumber = phoneNumber.replaceFirst('tel:', ''); // Extract number + if (state == "dialing" || state == "active") { + Navigator.push( + context, + MaterialPageRoute( + builder: (context) => CallPage( + displayName: currentPhoneNumber!, // Replace with contact lookup if available + phoneNumber: currentPhoneNumber!, + thumbnail: null, + ), ), - ), - ); - } else if (state == "disconnected") { - Navigator.pop(navigatorKey.currentContext!); - } + ); + } + break; + case "callStateChanged": + final state = call.arguments["state"] as String; + if (state == "disconnected" || state == "disconnecting") { + Navigator.pop(context); + } else if (state == "active") { + // Ensure CallPage is shown if not already + if (Navigator.canPop(context) && ModalRoute.of(context)?.settings.name != '/call') { + Navigator.push( + context, + MaterialPageRoute( + builder: (context) => CallPage( + displayName: currentPhoneNumber!, + phoneNumber: currentPhoneNumber!, + thumbnail: null, + ), + ), + ); + } + } + break; + case "callEnded": + case "callRemoved": + Navigator.pop(context); + currentPhoneNumber = null; + break; } }); } - // Add a GlobalKey for Navigator - static final GlobalKey navigatorKey = GlobalKey(); - Future makeGsmCall( BuildContext context, { required String phoneNumber, @@ -42,15 +71,17 @@ class CallService { currentPhoneNumber = phoneNumber; final result = await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber}); if (result["status"] == "calling") { - // CallPage will be shown via CallConnectionService callback - } else if (result["status"] == "pending_default_dialer") { - print("Waiting for user to set app as default dialer"); + // CallPage will be shown via MyInCallService callback + } else { ScaffoldMessenger.of(context).showSnackBar( - SnackBar(content: Text("Please set this app as your default dialer to proceed")), + SnackBar(content: Text("Failed to initiate call")), ); } } catch (e) { print("Error making call: $e"); + ScaffoldMessenger.of(context).showSnackBar( + SnackBar(content: Text("Error making call: $e")), + ); rethrow; } } @@ -59,11 +90,14 @@ class CallService { try { final result = await _channel.invokeMethod('hangUpCall'); if (result["status"] == "ended") { - Navigator.pop(context); + // Navigator.pop will be handled by MyInCallService callback } } catch (e) { print("Error hanging up call: $e"); + ScaffoldMessenger.of(context).showSnackBar( + SnackBar(content: Text("Error hanging up call: $e")), + ); rethrow; } } -} +} \ No newline at end of file From 2894dce1bc800313f1b21764b8c2ad21aae9a4d6 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Fri, 14 Mar 2025 15:35:35 +0200 Subject: [PATCH 13/21] feat: can call and receive call --- .../icing/dialer/activities/MainActivity.kt | 12 ++ .../icing/dialer/services/MyInCallService.kt | 11 +- .../lib/features/call/incoming_call_page.dart | 181 ++++++++++++++++++ .../contacts/widgets/contact_modal.dart | 4 +- dialer/lib/main.dart | 3 +- dialer/lib/services/call_service.dart | 127 ++++++++---- 6 files changed, 295 insertions(+), 43 deletions(-) create mode 100644 dialer/lib/features/call/incoming_call_page.dart 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 8354324..1181ce9 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 @@ -67,6 +67,18 @@ class MainActivity : FlutterActivity() { 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() } } 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 index c4b67c7..48b7edd 100644 --- 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 @@ -2,12 +2,14 @@ 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() { @@ -18,13 +20,16 @@ class MyInCallService : InCallService() { 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 } @@ -37,8 +42,10 @@ class MyInCallService : InCallService() { val stateStr = when (call.state) { Call.STATE_DIALING -> "dialing" Call.STATE_ACTIVE -> "active" - else -> "unknown" + 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 @@ -48,6 +55,7 @@ class MyInCallService : InCallService() { 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 @@ -55,6 +63,7 @@ class MyInCallService : InCallService() { 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/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/contacts/widgets/contact_modal.dart b/dialer/lib/features/contacts/widgets/contact_modal.dart index c9d3760..7938045 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() { diff --git a/dialer/lib/main.dart b/dialer/lib/main.dart index 0c8068f..d3513cf 100644 --- a/dialer/lib/main.dart +++ b/dialer/lib/main.dart @@ -19,7 +19,7 @@ void main() async { // Request permissions before running the app await _requestPermissions(); - CallService(); // Initialize CallService + CallService(); runApp( MultiProvider( @@ -41,7 +41,6 @@ Future _requestPermissions() async { ].request(); if (statuses.values.every((status) => status.isGranted)) { print("All required permissions granted"); - // Signal MainActivity const channel = MethodChannel('call_service'); await channel.invokeMethod('permissionsGranted'); } else { diff --git a/dialer/lib/services/call_service.dart b/dialer/lib/services/call_service.dart index 6b6ed48..d42326e 100644 --- a/dialer/lib/services/call_service.dart +++ b/dialer/lib/services/call_service.dart @@ -1,66 +1,113 @@ 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 class CallService { static const MethodChannel _channel = MethodChannel('call_service'); static String? currentPhoneNumber; + static bool _isCallPageVisible = false; - // Add a GlobalKey for Navigator static final GlobalKey navigatorKey = GlobalKey(); CallService() { _channel.setMethodCallHandler((call) async { final context = navigatorKey.currentContext; - if (context == null) return; + 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; // tel:1234567890 + final phoneNumber = call.arguments["callId"] as String; final state = call.arguments["state"] as String; - currentPhoneNumber = phoneNumber.replaceFirst('tel:', ''); // Extract number - if (state == "dialing" || state == "active") { - Navigator.push( - context, - MaterialPageRoute( - builder: (context) => CallPage( - displayName: currentPhoneNumber!, // Replace with contact lookup if available - phoneNumber: currentPhoneNumber!, - thumbnail: null, - ), - ), - ); + 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") { - Navigator.pop(context); - } else if (state == "active") { - // Ensure CallPage is shown if not already - if (Navigator.canPop(context) && ModalRoute.of(context)?.settings.name != '/call') { - Navigator.push( - context, - MaterialPageRoute( - builder: (context) => CallPage( - displayName: currentPhoneNumber!, - phoneNumber: currentPhoneNumber!, - thumbnail: null, - ), - ), - ); - } + _closeCallPage(context); + } else if (state == "active" || state == "dialing") { + _navigateToCallPage(context); + } else if (state == "ringing") { + _navigateToIncomingCallPage(context); } break; case "callEnded": case "callRemoved": - Navigator.pop(context); + 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, @@ -69,16 +116,16 @@ class CallService { }) async { try { currentPhoneNumber = phoneNumber; + print('CallService: Making GSM call to $phoneNumber'); final result = await _channel.invokeMethod('makeGsmCall', {"phoneNumber": phoneNumber}); - if (result["status"] == "calling") { - // CallPage will be shown via MyInCallService callback - } else { + 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")), ); @@ -88,12 +135,16 @@ class CallService { Future hangUpCall(BuildContext context) async { try { + print('CallService: Hanging up call'); final result = await _channel.invokeMethod('hangUpCall'); - if (result["status"] == "ended") { - // Navigator.pop will be handled by MyInCallService callback + 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")), ); From 3129e51eb45f2966d2642c6241ced0a43121e4d0 Mon Sep 17 00:00:00 2001 From: alexis Date: Fri, 7 Mar 2025 22:40:16 +0000 Subject: [PATCH 14/21] Add CallPage for initiating calls with contact details (#37) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Demo call page avec les features de base: - Haut parleur - Couper/activer micro - keypad - raccrocher - Display Icing state (toucher pour switch l'état) S'active en faisant un appui long sur le bouton d'appel depuis les détails du contact. Compatible avec l'obfuscation des contacts. Co-authored-by: AlexisDanlos <91090088+AlexisDanlos@users.noreply.github.com> Reviewed-on: https://git.gmoker.com/icing/monorepo/pulls/37 Co-authored-by: alexis Co-committed-by: alexis --- .../lib/features/contacts/widgets/contact_modal.dart | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/dialer/lib/features/contacts/widgets/contact_modal.dart b/dialer/lib/features/contacts/widgets/contact_modal.dart index 7938045..ba9c803 100644 --- a/dialer/lib/features/contacts/widgets/contact_modal.dart +++ b/dialer/lib/features/contacts/widgets/contact_modal.dart @@ -265,6 +265,18 @@ class _ContactModalState extends State { await _callService.makeGsmCall(context, phoneNumber: phoneNumber); } }, + onLongPress: () { + // Navigate to the beautiful calling page demo + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => CallPage( + displayName: widget.contact.displayName, + thumbnail: widget.contact.thumbnail, + ), + ), + ); + }, ), ListTile( leading: const Icon(Icons.message, color: Colors.blue), From da0c5d1991de353f9a40c584b35c48160558c4f4 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Tue, 4 Mar 2025 14:20:56 +0100 Subject: [PATCH 15/21] feat: call page UI --- .../main/kotlin/com/icing/dialer/activities/MainActivity.kt | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) 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 1181ce9..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 @@ -151,11 +151,7 @@ class MainActivity : FlutterActivity() { 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" ) cursor?.use { while (it.moveToNext()) { From 0d6322a714be297e7242f8f220aab5c892815a88 Mon Sep 17 00:00:00 2001 From: Florian Griffon Date: Fri, 14 Mar 2025 15:59:54 +0200 Subject: [PATCH 16/21] fix: not showing call UI on long press --- .../contacts/widgets/contact_modal.dart | 37 ++++++++----------- 1 file changed, 15 insertions(+), 22 deletions(-) diff --git a/dialer/lib/features/contacts/widgets/contact_modal.dart b/dialer/lib/features/contacts/widgets/contact_modal.dart index ba9c803..198f614 100644 --- a/dialer/lib/features/contacts/widgets/contact_modal.dart +++ b/dialer/lib/features/contacts/widgets/contact_modal.dart @@ -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,21 +267,10 @@ class _ContactModalState extends State { ), onTap: () async { if (widget.contact.phones.isNotEmpty) { - await _callService.makeGsmCall(context, phoneNumber: phoneNumber); + await _callService.makeGsmCall(context, + phoneNumber: phoneNumber); } }, - onLongPress: () { - // Navigate to the beautiful calling page demo - Navigator.push( - context, - MaterialPageRoute( - builder: (_) => CallPage( - displayName: widget.contact.displayName, - thumbnail: widget.contact.thumbnail, - ), - ), - ); - }, ), ListTile( leading: const Icon(Icons.message, color: Colors.blue), @@ -319,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), From d56dc33181c7ec1210ec17ce068d61a8dd92d332 Mon Sep 17 00:00:00 2001 From: stcb <21@stcb.cc> Date: Sun, 2 Mar 2025 22:29:02 +0200 Subject: [PATCH 17/21] Init --- protocol_prototype/main.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 protocol_prototype/main.py diff --git a/protocol_prototype/main.py b/protocol_prototype/main.py new file mode 100644 index 0000000..5596b44 --- /dev/null +++ b/protocol_prototype/main.py @@ -0,0 +1,16 @@ +# This is a sample Python script. + +# Press Shift+F10 to execute it or replace it with your code. +# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings. + + +def print_hi(name): + # Use a breakpoint in the code line below to debug your script. + print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint. + + +# Press the green button in the gutter to run the script. +if __name__ == '__main__': + print_hi('PyCharm') + +# See PyCharm help at https://www.jetbrains.com/help/pycharm/ From e8bbe447c87ea060261cc48023d989b1c2437d3e Mon Sep 17 00:00:00 2001 From: stcb <21@stcb.cc> Date: Sun, 2 Mar 2025 23:20:59 +0200 Subject: [PATCH 18/21] Drawio Handshake logic --- protocol_prototype/IcingProtocol.drawio | 262 ++++++++++++++++++++++++ 1 file changed, 262 insertions(+) create mode 100644 protocol_prototype/IcingProtocol.drawio diff --git a/protocol_prototype/IcingProtocol.drawio b/protocol_prototype/IcingProtocol.drawio new file mode 100644 index 0000000..06c3cb0 --- /dev/null +++ b/protocol_prototype/IcingProtocol.drawio @@ -0,0 +1,262 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From b139e36921f313d2af835aed0e16e67604157a8e Mon Sep 17 00:00:00 2001 From: stcb <21@stcb.cc> Date: Tue, 4 Mar 2025 00:22:20 +0200 Subject: [PATCH 19/21] Update flow --- protocol_prototype/IcingProtocol.drawio | 291 ++++++++++++++++++++---- 1 file changed, 244 insertions(+), 47 deletions(-) diff --git a/protocol_prototype/IcingProtocol.drawio b/protocol_prototype/IcingProtocol.drawio index 06c3cb0..836e00d 100644 --- a/protocol_prototype/IcingProtocol.drawio +++ b/protocol_prototype/IcingProtocol.drawio @@ -1,6 +1,6 @@ - - - + + + @@ -42,7 +42,7 @@ - + @@ -50,17 +50,17 @@ - + - + - + @@ -70,37 +70,37 @@ - + - + - + - + - + - + - + @@ -111,83 +111,83 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -195,12 +195,12 @@ - + - + @@ -209,29 +209,29 @@ - + - + - + - + - + - + - + @@ -239,24 +239,221 @@ - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 1b5bda2eb4e8c0c0198d76b757db2a44fcb372a8 Mon Sep 17 00:00:00 2001 From: stcb <21@stcb.cc> Date: Sun, 23 Mar 2025 21:32:00 +0200 Subject: [PATCH 20/21] Semi-auto, bad sizes and need adjustments --- protocol_prototype/IcingProtocol.drawio | 132 ++++----- protocol_prototype/cli.py | 113 ++++++++ protocol_prototype/crypto_utils.py | 81 ++++++ protocol_prototype/main.py | 16 -- protocol_prototype/messages.py | 126 +++++++++ protocol_prototype/protocol.py | 354 ++++++++++++++++++++++++ protocol_prototype/transmission.py | 100 +++++++ 7 files changed, 840 insertions(+), 82 deletions(-) create mode 100644 protocol_prototype/cli.py create mode 100644 protocol_prototype/crypto_utils.py delete mode 100644 protocol_prototype/main.py create mode 100644 protocol_prototype/messages.py create mode 100644 protocol_prototype/protocol.py create mode 100644 protocol_prototype/transmission.py diff --git a/protocol_prototype/IcingProtocol.drawio b/protocol_prototype/IcingProtocol.drawio index 836e00d..edefb16 100644 --- a/protocol_prototype/IcingProtocol.drawio +++ b/protocol_prototype/IcingProtocol.drawio @@ -1,6 +1,6 @@ - + - + @@ -47,7 +47,7 @@ - + @@ -143,7 +143,7 @@ - + @@ -165,7 +165,7 @@ - + @@ -260,197 +260,197 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - - + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/protocol_prototype/cli.py b/protocol_prototype/cli.py new file mode 100644 index 0000000..293566b --- /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 ") + print(" generate_ecdhe # formerly respond_handshake") + 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/main.py b/protocol_prototype/main.py deleted file mode 100644 index 5596b44..0000000 --- a/protocol_prototype/main.py +++ /dev/null @@ -1,16 +0,0 @@ -# This is a sample Python script. - -# Press Shift+F10 to execute it or replace it with your code. -# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings. - - -def print_hi(name): - # Use a breakpoint in the code line below to debug your script. - print(f'Hi, {name}') # Press Ctrl+F8 to toggle the breakpoint. - - -# Press the green button in the gutter to run the script. -if __name__ == '__main__': - print_hi('PyCharm') - -# See PyCharm help at https://www.jetbrains.com/help/pycharm/ diff --git a/protocol_prototype/messages.py b/protocol_prototype/messages.py new file mode 100644 index 0000000..9ebcb72 --- /dev/null +++ b/protocol_prototype/messages.py @@ -0,0 +1,126 @@ +import os +import struct +import time +import zlib + + +def crc32_of(data: bytes) -> int: + """ + Compute CRC-32 of 'data'. + """ + return zlib.crc32(data) & 0xffffffff + + +# ----------------------------------------------------------------------------- +# Ping +# ----------------------------------------------------------------------------- + +def build_ping_request(version: int = 0) -> bytes: + """ + Build a Ping request: + - Nonce (32 bytes) + - Version (1 byte) + - CRC-32 (4 bytes) + Total = 37 bytes + """ + nonce = os.urandom(32) + partial = nonce + struct.pack("!B", version) + crc_val = crc32_of(partial) + return partial + struct.pack("!I", crc_val) + + +def parse_ping_request(data: bytes): + """ + Parse a Ping request (37 bytes). + Return (nonce, version) or None if invalid. + """ + if len(data) != 37: + return None + nonce = data[:32] + version = data[32] + crc_in = struct.unpack("!I", data[33:37])[0] + partial = data[:33] + crc_calc = crc32_of(partial) + if crc_calc != crc_in: + return None + return (nonce, version) + + +def build_ping_response(version: int, answer_code: int) -> bytes: + """ + Build a Ping response: + - Timestamp (8 bytes) + - Version (1 byte) + - Answer code (1 byte) + - CRC-32 (4 bytes) + Total = 14 bytes + """ + timestamp = struct.pack("!d", time.time()) + partial = timestamp + struct.pack("!B", version) + struct.pack("!B", answer_code) + crc_val = crc32_of(partial) + return partial + struct.pack("!I", crc_val) + + +def parse_ping_response(data: bytes): + """ + Parse a Ping response (14 bytes). + Return (timestamp, version, answer_code) or None if invalid. + """ + if len(data) != 14: + return None + timestamp = struct.unpack("!d", data[:8])[0] + version = data[8] + answer_code = data[9] + crc_in = struct.unpack("!I", data[10:14])[0] + partial = data[:10] + crc_calc = crc32_of(partial) + if crc_calc != crc_in: + return None + return (timestamp, version, answer_code) + + +# ----------------------------------------------------------------------------- +# Handshake +# ----------------------------------------------------------------------------- + +def build_handshake_message(ephemeral_pubkey: bytes, ephemeral_signature: bytes, timestamp: float) -> bytes: + """ + Build a handshake message: + - ephemeral_pubkey (64 bytes) + - ephemeral_signature (72 bytes, DER + zero-pad) + - timestamp (8 bytes) + - CRC-32 (4 bytes) + Total = 148 bytes + """ + if len(ephemeral_pubkey) != 64: + raise ValueError("ephemeral_pubkey must be 64 bytes") + if len(ephemeral_signature) > 72: + raise ValueError("ephemeral_signature too large") + + sig_padded = ephemeral_signature.ljust(72, b'\x00') + ts_bytes = struct.pack("!d", timestamp) + partial = ephemeral_pubkey + sig_padded + ts_bytes + crc_val = crc32_of(partial) + return partial + struct.pack("!I", crc_val) + + +def parse_handshake_message(data: bytes): + """ + Parse a handshake message (148 bytes). + Return (ephemeral_pubkey, ephemeral_signature, timestamp) or None if invalid. + """ + if len(data) != 148: + return None + ephemeral_pubkey = data[:64] + sig_padded = data[64:136] + ts_bytes = data[136:144] + crc_in = struct.unpack("!I", data[144:148])[0] + + partial = data[:144] + crc_calc = crc32_of(partial) + if crc_calc != crc_in: + return None + + ephemeral_signature = sig_padded.rstrip(b'\x00') + timestamp = struct.unpack("!d", ts_bytes)[0] + return (ephemeral_pubkey, ephemeral_signature, timestamp) diff --git a/protocol_prototype/protocol.py b/protocol_prototype/protocol.py new file mode 100644 index 0000000..3e928d7 --- /dev/null +++ b/protocol_prototype/protocol.py @@ -0,0 +1,354 @@ +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 +) +import transmission + +# ANSI colors for pretty printing +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 (public key) for verifying ephemeral signatures + self.peer_identity_pubkey_obj = None + self.peer_identity_pubkey_bytes = None + + # Ephemeral keys (our side) + self.ephemeral_privkey = None + self.ephemeral_pubkey = None + + # Store the last computed shared secret (hex) from ECDH + self.shared_secret = None + + # Track open connections + self.connections = [] + + # A random listening port + self.local_port = random.randint(30000, 40000) + + # 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 + + # Start the listener + 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) == 14: + 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) == 148: + parsed = parse_handshake_message(data) + if parsed: + ephemeral_pub, ephemeral_sig, ts = 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 + }, + "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 a handshake message with ephemeral keys. + """ + 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. Call 'generate_ephemeral_keys' first.") + return + + ephemeral_signature = sign_data(self.identity_privkey, self.ephemeral_pubkey) + ts_now = time.time() + pkt = build_handshake_message(self.ephemeral_pubkey, ephemeral_signature, ts_now) + 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: {self.identity_pubkey.hex()[:16]}... (64 bytes)") + if self.peer_identity_pubkey_bytes: + print(f"Peer Identity PubKey: {self.peer_identity_pubkey_bytes.hex()[:16]}... (64 bytes)") + else: + print("Peer Identity PubKey: [None]") + + print("\nEphemeral Keys:") + if self.ephemeral_pubkey: + print(f" ephemeral_pubkey={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") + 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 From f5930eef82adf7454ac19f993035bdf7c8417f68 Mon Sep 17 00:00:00 2001 From: stcb <21@stcb.cc> Date: Mon, 24 Mar 2025 13:04:56 +0200 Subject: [PATCH 21/21] Need fix signatures --- protocol_prototype/cli.py | 4 +- protocol_prototype/messages.py | 250 +++++++++++++++++++++++---------- protocol_prototype/protocol.py | 88 ++++++++---- 3 files changed, 242 insertions(+), 100 deletions(-) diff --git a/protocol_prototype/cli.py b/protocol_prototype/cli.py index 293566b..600376b 100644 --- a/protocol_prototype/cli.py +++ b/protocol_prototype/cli.py @@ -23,8 +23,8 @@ def main(): print(" generate_ephemeral_keys") print(" send_ping") print(" send_handshake") - print(" respond_ping ") - print(" generate_ecdhe # formerly respond_handshake") + print(" respond_ping <0|1>") + print(" generate_ecdhe ") print(" auto_responder ") print(" show_state") print(" exit\n") diff --git a/protocol_prototype/messages.py b/protocol_prototype/messages.py index 9ebcb72..7194e73 100644 --- a/protocol_prototype/messages.py +++ b/protocol_prototype/messages.py @@ -2,7 +2,7 @@ import os import struct import time import zlib - +import hashlib def crc32_of(data: bytes) -> int: """ @@ -11,116 +11,222 @@ def crc32_of(data: bytes) -> int: return zlib.crc32(data) & 0xffffffff -# ----------------------------------------------------------------------------- -# Ping -# ----------------------------------------------------------------------------- +# ============================================================================= +# 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 = 0) -> bytes: +def build_ping_request(version: int) -> bytes: """ - Build a Ping request: - - Nonce (32 bytes) - - Version (1 byte) - - CRC-32 (4 bytes) - Total = 37 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. """ - nonce = os.urandom(32) - partial = nonce + struct.pack("!B", version) - crc_val = crc32_of(partial) - return partial + struct.pack("!I", crc_val) + 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). - Return (nonce, version) or None if invalid. + Parse a Ping request (37 bytes = 295 bits). + Returns (nonce, version) or None if invalid. """ if len(data) != 37: return None - nonce = data[:32] - version = data[32] - crc_in = struct.unpack("!I", data[33:37])[0] - partial = data[:33] - crc_calc = crc32_of(partial) + + # 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 - return (nonce, version) + + # 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) -def build_ping_response(version: int, answer_code: int) -> bytes: +# ============================================================================= +# 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: - - Timestamp (8 bytes) - - Version (1 byte) - - Answer code (1 byte) - - CRC-32 (4 bytes) - Total = 14 bytes + - 32-bit timestamp (lowest 32 bits of current time in ms) + - 7-bit version + 1-bit answer + - 32-bit CRC + => 72 bits = 9 bytes """ - timestamp = struct.pack("!d", time.time()) - partial = timestamp + struct.pack("!B", version) + struct.pack("!B", answer_code) - crc_val = crc32_of(partial) - return partial + struct.pack("!I", crc_val) + 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 (14 bytes). - Return (timestamp, version, answer_code) or None if invalid. + Parse a Ping response (72 bits = 9 bytes). + Return (timestamp_ms, version, answer) or None if invalid. """ - if len(data) != 14: + if len(data) != 9: return None - timestamp = struct.unpack("!d", data[:8])[0] - version = data[8] - answer_code = data[9] - crc_in = struct.unpack("!I", data[10:14])[0] - partial = data[:10] - crc_calc = crc32_of(partial) + + 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 - return (timestamp, version, answer_code) + + # 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) -# ----------------------------------------------------------------------------- -# Handshake -# ----------------------------------------------------------------------------- +# ============================================================================= +# 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(ephemeral_pubkey: bytes, ephemeral_signature: bytes, timestamp: float) -> bytes: +def build_handshake_message(timestamp: int, + ephemeral_pubkey: bytes, + ephemeral_signature: bytes, + pfs_hash: bytes) -> bytes: """ - Build a handshake message: - - ephemeral_pubkey (64 bytes) - - ephemeral_signature (72 bytes, DER + zero-pad) - - timestamp (8 bytes) - - CRC-32 (4 bytes) - Total = 148 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") - if len(ephemeral_signature) > 72: - raise ValueError("ephemeral_signature too large") + 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.") - sig_padded = ephemeral_signature.ljust(72, b'\x00') - ts_bytes = struct.pack("!d", timestamp) - partial = ephemeral_pubkey + sig_padded + ts_bytes - crc_val = crc32_of(partial) - return partial + struct.pack("!I", crc_val) + 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 a handshake message (148 bytes). - Return (ephemeral_pubkey, ephemeral_signature, timestamp) or None if invalid. + Parse handshake message (168 bytes). + Return (timestamp, ephemeral_pub, ephemeral_sig, pfs_hash) or None if invalid. """ - if len(data) != 148: + if len(data) != 168: return None - ephemeral_pubkey = data[:64] - sig_padded = data[64:136] - ts_bytes = data[136:144] - crc_in = struct.unpack("!I", data[144:148])[0] - - partial = data[:144] + 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 - ephemeral_signature = sig_padded.rstrip(b'\x00') - timestamp = struct.unpack("!d", ts_bytes)[0] - return (ephemeral_pubkey, ephemeral_signature, timestamp) + # 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 index 3e928d7..2e777d3 100644 --- a/protocol_prototype/protocol.py +++ b/protocol_prototype/protocol.py @@ -14,11 +14,12 @@ from crypto_utils import ( from messages import ( build_ping_request, parse_ping_request, build_ping_response, parse_ping_response, - build_handshake_message, parse_handshake_message + build_handshake_message, parse_handshake_message, + compute_pfs_hash ) import transmission -# ANSI colors for pretty printing +# ANSI colors RED = "\033[91m" GREEN = "\033[92m" YELLOW = "\033[93m" @@ -31,22 +32,21 @@ class IcingProtocol: # Identity keys self.identity_privkey, self.identity_pubkey = generate_identity_keys() - # Peer identity (public key) for verifying ephemeral signatures + # Peer identity self.peer_identity_pubkey_obj = None self.peer_identity_pubkey_bytes = None - # Ephemeral keys (our side) + # Ephemeral keys self.ephemeral_privkey = None self.ephemeral_pubkey = None - # Store the last computed shared secret (hex) from ECDH + # Last computed shared secret (hex) self.shared_secret = None - # Track open connections - self.connections = [] - - # A random listening port - self.local_port = random.randint(30000, 40000) + # 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 } @@ -63,7 +63,11 @@ class IcingProtocol: # Auto-responder toggle self.auto_responder = False - # Start the listener + # 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, @@ -86,7 +90,7 @@ class IcingProtocol: 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 + 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 @@ -112,7 +116,7 @@ class IcingProtocol: return # Attempt to parse Ping response - if len(data) == 14: + if len(data) == 9: parsed = parse_ping_response(data) if parsed: ts, version, answer_code = parsed @@ -128,10 +132,10 @@ class IcingProtocol: return # Attempt to parse handshake - if len(data) == 148: + if len(data) == 168: parsed = parse_handshake_message(data) if parsed: - ephemeral_pub, ephemeral_sig, ts = parsed + ts, ephemeral_pub, ephemeral_sig, pfs_hash = parsed self.state["handshake_received"] = True index = len(self.inbound_messages) msg = { @@ -140,7 +144,8 @@ class IcingProtocol: "parsed": { "ephemeral_pub": ephemeral_pub, "ephemeral_sig": ephemeral_sig, - "timestamp": ts + "timestamp": ts, + "pfs hash": pfs_hash }, "connection": conn } @@ -228,18 +233,48 @@ class IcingProtocol: def send_handshake(self): """ - Build and send a handshake message with ephemeral keys. + 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. Call 'generate_ephemeral_keys' first.") + 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 - ephemeral_signature = sign_data(self.identity_privkey, self.ephemeral_pubkey) - ts_now = time.time() - pkt = build_handshake_message(self.ephemeral_pubkey, ephemeral_signature, ts_now) + # 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 @@ -316,17 +351,18 @@ class IcingProtocol: def show_state(self): print(f"\n{YELLOW}=== Global State ==={RESET}") print(f"Listening Port: {self.local_port}") - print(f"Identity PubKey: {self.identity_pubkey.hex()[:16]}... (64 bytes)") + print(f"Identity PubKey: 512 bits => {self.identity_pubkey.hex()[:16]}...") + if self.peer_identity_pubkey_bytes: - print(f"Peer Identity PubKey: {self.peer_identity_pubkey_bytes.hex()[:16]}... (64 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={self.ephemeral_pubkey.hex()[:16]}...") + print(f" ephemeral_pubkey: 512 bits => {self.ephemeral_pubkey.hex()[:16]}...") else: - print(" ephemeral_pubkey=[None]") + print(" ephemeral_pubkey: [None]") print(f"\nShared Secret: {self.shared_secret if self.shared_secret else '[None]'}") @@ -342,7 +378,7 @@ class IcingProtocol: print("\nInbound Message Queue:") for i, m in enumerate(self.inbound_messages): - print(f" [{i}] type={m['type']} len={len(m['raw'])} bytes") + print(f" [{i}] type={m['type']} len={len(m['raw'])} bytes => {len(m['raw']) * 8} bits") print() def stop(self):