Bluetooth: Classic: HFP_HF: Support users to query current call list

Add the function `bt_hfp_hf_query_list_of_current_calls()` to support
users to query current call list.

Add the callback `bt_hfp_hf_cb::query_call` to notify the received
current calls.

Signed-off-by: Lyle Zhu <[email protected]>

Author: lylezhu2012

include/zephyr/bluetooth/classic/hfp_hf.h

@@ -32,6 +32,77 @@ struct bt_hfp_hf;
 
 struct bt_hfp_hf_call;
 
+/** @brief The status of the call
+ *
+ *  Enumeration defining the various states a call can be in during
+ *  HFP communication between HF and AG.
+ */
+enum __packed bt_hfp_hf_call_status {
+	/** Call is active and ongoing */
+	BT_HFP_HF_CALL_STATUS_ACTIVE = 0,
+	/** Call is on hold */
+	BT_HFP_HF_CALL_STATUS_HELD = 1,
+	/** Outgoing call is being dialed */
+	BT_HFP_HF_CALL_STATUS_DIALING = 2,
+	/** Outgoing call is being alerted (ringing on remote end) */
+	BT_HFP_HF_CALL_STATUS_ALERTING = 3,
+	/** Incoming call has arrived */
+	BT_HFP_HF_CALL_STATUS_INCOMING = 4,
+	/** Incoming call is waiting (call waiting scenario) */
+	BT_HFP_HF_CALL_STATUS_WAITING = 5,
+	/** Call held by Response and Hold feature */
+	BT_HFP_HF_CALL_STATUS_INCOMING_HELD = 6
+};
+
+/** @brief The direction of the call
+ *
+ *  Enumeration defining whether the call was initiated by the HF
+ *  (outgoing) or by the remote party (incoming).
+ */
+enum __packed bt_hfp_hf_call_dir {
+	/** It is an outgoing call initiated by HF */
+	BT_HFP_HF_CALL_DIR_OUTGOING = 0,
+	/** It is an incoming call from remote party */
+	BT_HFP_HF_CALL_DIR_INCOMING = 1,
+};
+
+/** @brief The mode of the call
+ *
+ *  Enumeration defining the type of call being established,
+ *  whether voice, data, or fax transmission.
+ */
+enum __packed bt_hfp_hf_call_mode {
+	/** Voice call */
+	BT_HFP_HF_CALL_MODE_VOICE = 0,
+	/** Data call */
+	BT_HFP_HF_CALL_MODE_DATA = 1,
+	/** Fax transmission */
+	BT_HFP_HF_CALL_MODE_FAX = 2,
+};
+
+/** @brief The information of current call
+ *
+ *  Structure containing comprehensive information about a current call,
+ *  including its index, direction, status, mode, multiparty status,
+ *  phone number, and number type.
+ */
+struct bt_hfp_hf_current_call {
+	/** Call index identifier */
+	uint8_t index;
+	/** Call direction (incoming/outgoing) */
+	enum bt_hfp_hf_call_dir dir;
+	/** Current status of the call */
+	enum bt_hfp_hf_call_status status;
+	/** Call mode (voice/data/fax) */
+	enum bt_hfp_hf_call_mode mode;
+	/** True if call is part of a multiparty conference */
+	bool multiparty;
+	/** Phone number string, NULL if not available */
+	const char *number;
+	/** Phone number type format identifier */
+	uint8_t type;
+};
+
 /** @brief HFP profile application callback */
 struct bt_hfp_hf_cb {
 	/** HF connected callback to application
@@ -416,6 +487,20 @@ struct bt_hfp_hf_cb {
 	 */
 	void (*subscriber_number)(struct bt_hfp_hf *hf, const char *number, uint8_t type,
 				  uint8_t service);
+
+	/** Query list of current calls callback
+	 *
+	 *  If this callback is provided it will be called whenever the
+	 *  result code `+CLCC: <idx>,<dir>,<status>,<mode>,<mprty>[,<number>,<type>]`
+	 *  is received from AG.
+	 *  If the request is failed or no active calls, the callback will not be called.
+	 *  If the @ref bt_hfp_hf_current_call::number is NULL, the
+	 *  @ref bt_hfp_hf_current_call::type shall be ignored.
+	 *
+	 *  @param hf HFP HF object.
+	 *  @param call Current call information.
+	 */
+	void (*query_call)(struct bt_hfp_hf *hf, struct bt_hfp_hf_current_call *call);
 };
 
 /** @brief Register HFP HF profile
@@ -952,6 +1037,18 @@ int bt_hfp_hf_enhanced_safety(struct bt_hfp_hf *hf, bool enable);
  */
 int bt_hfp_hf_battery(struct bt_hfp_hf *hf, uint8_t level);
 
+/** @brief Handsfree HF query list of current calls
+ *
+ *  It allows HF to query list of current calls by sending `AT+CLCC` command.
+ *  If @kconfig{CONFIG_BT_HFP_HF_ECS} is not enabled,
+ *  the error `-ENOTSUP` will be returned if the function called.
+ *
+ *  @param hf HFP HF object.
+ *
+ *  @return 0 in case of success or negative value in case of error.
+ */
+int bt_hfp_hf_query_list_of_current_calls(struct bt_hfp_hf *hf);
+
 #ifdef __cplusplus
 }
 #endif

subsys/bluetooth/host/classic/hfp_hf.c

@@ -509,6 +509,7 @@ static int clcc_finish(struct at_client *hf_at, enum at_result result,
 		clear_call_without_clcc(hf);
 	}
 
+	atomic_clear_bit(hf->flags, BT_HFP_HF_FLAG_USR_CLCC_CMD);
 	atomic_clear_bit(hf->flags, BT_HFP_HF_FLAG_CLCC_PENDING);
 
 	return 0;
@@ -529,32 +530,36 @@ static void clear_call_clcc_state(struct bt_hfp_hf *hf)
 	}
 }
 
-static void hf_query_current_calls(struct bt_hfp_hf *hf)
+static int hf_query_current_calls(struct bt_hfp_hf *hf)
 {
 	int err;
 
 	LOG_DBG("");
 
 	if (!hf) {
 		LOG_ERR("No HF connection found");
-		return;
+		return -EINVAL;
 	}
 
 	if (!atomic_test_bit(hf->flags, BT_HFP_HF_FLAG_CONNECTED)) {
-		return;
+		return -ENOTCONN;
 	}
 
 	if (!(hf->ag_features & BT_HFP_AG_FEATURE_ECS)) {
-		return;
+		return -ENOTSUP;
 	}
 
 	if (!(hf->hf_features & BT_HFP_HF_FEATURE_ECS)) {
-		return;
+		return -ENOTSUP;
 	}
 
 	if (atomic_test_and_set_bit(hf->flags, BT_HFP_HF_FLAG_CLCC_PENDING)) {
 		k_work_reschedule(&hf->deferred_work, K_MSEC(HF_ENHANCED_CALL_STATUS_TIMEOUT));
-		return;
+		return 0;
+	}
+
+	if (atomic_test_and_clear_bit(hf->flags, BT_HFP_HF_FLAG_USR_CLCC_PND)) {
+		atomic_set_bit(hf->flags, BT_HFP_HF_FLAG_USR_CLCC_CMD);
 	}
 
 	clear_call_clcc_state(hf);
@@ -563,6 +568,8 @@ static void hf_query_current_calls(struct bt_hfp_hf *hf)
 	if (err < 0) {
 		LOG_ERR("Fail to query current calls on %p", hf);
 	}
+
+	return err;
 }
 
 static void hf_call_state_update(struct bt_hfp_hf_call *call, int state)
@@ -812,20 +819,6 @@ static int clcc_handle(struct at_client *hf_at)
 		return err;
 	}
 
-	if (new_call) {
-		set_call_incoming_flag(call, dir == BT_HFP_CLCC_DIR_INCOMING);
-	}
-
-	if (atomic_test_bit(call->flags, BT_HFP_HF_CALL_INCOMING) ||
-	    atomic_test_bit(call->flags, BT_HFP_HF_CALL_INCOMING_3WAY)) {
-		incoming = true;
-	}
-
-	if (incoming != (dir == BT_HFP_CLCC_DIR_INCOMING)) {
-		LOG_ERR("Call dir of HF is not aligned with AG");
-		return 0;
-	}
-
 	err = at_get_number(hf_at, &status);
 	if (err < 0) {
 		LOG_ERR("Error getting status");
@@ -846,19 +839,48 @@ static int clcc_handle(struct at_client *hf_at)
 
 	number = at_get_string(hf_at);
 
-	if (number) {
+	if (number != NULL) {
 		(void)at_get_number(hf_at, &type);
 	}
 
+	if (atomic_test_bit(hf->flags, BT_HFP_HF_FLAG_USR_CLCC_CMD) &&
+	    (bt_hf->query_call != NULL)) {
+		struct bt_hfp_hf_current_call current_call;
+
+		current_call.index = (uint8_t)index;
+		current_call.dir = (enum bt_hfp_hf_call_dir)dir;
+		current_call.status = (enum bt_hfp_hf_call_status)status;
+		current_call.mode = (enum bt_hfp_hf_call_mode)mode;
+		current_call.multiparty = mpty > 0 ? true : false;
+		current_call.number = number;
+		current_call.type = (uint8_t)type;
+
+		bt_hf->query_call(hf, &current_call);
+	}
+
+	LOG_DBG("CLCC idx %d dir %d status %d mode %d mpty %d number %s type %d",
+		index, dir, status, mode, mpty, number, type);
+
+	if (new_call) {
+		set_call_incoming_flag(call, dir == BT_HFP_CLCC_DIR_INCOMING);
+	}
+
+	if (atomic_test_bit(call->flags, BT_HFP_HF_CALL_INCOMING) ||
+	    atomic_test_bit(call->flags, BT_HFP_HF_CALL_INCOMING_3WAY)) {
+		incoming = true;
+	}
+
+	if (incoming != (dir == BT_HFP_CLCC_DIR_INCOMING)) {
+		LOG_ERR("Call dir of HF is not aligned with AG");
+		return 0;
+	}
+
 	if (new_call) {
 		new_call_state_update(call, incoming, status);
 	} else {
 		call_state_update(call, status);
 	}
 
-	LOG_DBG("CLCC idx %d dir %d status %d mode %d mpty %d number %s type %d",
-		index, dir, status, mode, mpty, number, type);
-
 	return 0;
 }
 #endif /* CONFIG_BT_HFP_HF_ECS */
@@ -1054,8 +1076,12 @@ static void bt_hf_deferred_work(struct k_work *work)
 {
 	struct k_work_delayable *dwork = k_work_delayable_from_work(work);
 	struct bt_hfp_hf *hf = CONTAINER_OF(dwork, struct bt_hfp_hf, deferred_work);
+	int err;
 
-	hf_query_current_calls(hf);
+	err = hf_query_current_calls(hf);
+	if (err != 0) {
+		LOG_ERR("Failed to query current calls: %d", err);
+	}
 }
 
 static void set_all_calls_held_state(struct bt_hfp_hf *hf, bool held)
@@ -4273,3 +4299,28 @@ int bt_hfp_hf_disconnect(struct bt_hfp_hf *hf)
 
 	return bt_rfcomm_dlc_disconnect(&hf->rfcomm_dlc);
 }
+
+int bt_hfp_hf_query_list_of_current_calls(struct bt_hfp_hf *hf)
+{
+	int err;
+
+	if ((hf == NULL) || (bt_hf == NULL) || (bt_hf->query_call == NULL)) {
+		return -EINVAL;
+	}
+
+	if (!IS_ENABLED(CONFIG_BT_HFP_HF_ECS)) {
+		return -ENOTSUP;
+	}
+
+	if (atomic_test_and_set_bit(hf->flags, BT_HFP_HF_FLAG_USR_CLCC_PND)) {
+		return -EBUSY;
+	}
+
+	err = hf_query_current_calls(hf);
+	if (err != 0) {
+		atomic_clear_bit(hf->flags, BT_HFP_HF_FLAG_USR_CLCC_PND);
+		LOG_ERR("Failed to query current calls, err %d", err);
+	}
+
+	return err;
+}

subsys/bluetooth/host/classic/hfp_hf_internal.h

@@ -145,6 +145,8 @@ enum {
 	BT_HFP_HF_FLAG_BINP,          /* +BINP result code is received */
 	BT_HFP_HF_FLAG_INITIATING,    /* HF is in initiating state */
 	BT_HFP_HF_FLAG_QUERY_CALLS,   /* Require to query list of current calls */
+	BT_HFP_HF_FLAG_USR_CLCC_CMD,  /* User-initiated AT+CLCC command */
+	BT_HFP_HF_FLAG_USR_CLCC_PND,  /* User-initiated AT+CLCC command is pending */
 	/* Total number of flags - must be at the end of the enum */
 	BT_HFP_HF_NUM_FLAGS,
 };