xref: /aosp_15_r20/external/ot-br-posix/src/android/otdaemon_telemetry.cpp (revision 4a64e381480ef79f0532b2421e44e6ee336b8e0d)

/*
 *    Copyright (c) 2023, The OpenThread Authors.
 *    All rights reserved.
 *
 *    Redistribution and use in source and binary forms, with or without
 *    modification, are permitted provided that the following conditions are met:
 *    1. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *    2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *    3. Neither the name of the copyright holder nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *    POSSIBILITY OF SUCH DAMAGE.
 */
#include "android/otdaemon_telemetry.hpp"

#include <openthread/border_agent.h>
#include <openthread/nat64.h>
#include <openthread/openthread-system.h>
#include <openthread/thread.h>
#include <openthread/thread_ftd.h>
#include <openthread/trel.h>
#include <openthread/platform/radio.h>

#if OTBR_ENABLE_DNSSD_DISCOVERY_PROXY
#include <openthread/dnssd_server.h>
#endif
#if OTBR_ENABLE_SRP_ADVERTISING_PROXY
#include <openthread/srp_server.h>
#endif

#include "statslog_threadnetwork.h"
#include "common/code_utils.hpp"
#include "mdns/mdns.hpp"
#include "proto/threadnetwork_atoms.pb.h"

namespace otbr {
namespace Android {
using android::os::statsd::threadnetwork::ThreadnetworkDeviceInfoReported;
using android::os::statsd::threadnetwork::ThreadnetworkTelemetryDataReported;
using android::os::statsd::threadnetwork::ThreadnetworkTopoEntryRepeated;
using TelemetryData = android::os::statsd::threadnetwork::ThreadnetworkTelemetryDataReported;

static uint32_t TelemetryNodeTypeFromRoleAndLinkMode(const otDeviceRole &aRole, const otLinkModeConfig &aLinkModeCfg)
{
    uint32_t nodeType;

    switch (aRole)
    {
    case OT_DEVICE_ROLE_DISABLED:
        nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_DISABLED;
        break;
    case OT_DEVICE_ROLE_DETACHED:
        nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_DETACHED;
        break;
    case OT_DEVICE_ROLE_ROUTER:
        nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_ROUTER;
        break;
    case OT_DEVICE_ROLE_LEADER:
        nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_LEADER;
        break;
    case OT_DEVICE_ROLE_CHILD:
        if (!aLinkModeCfg.mRxOnWhenIdle)
        {
            nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_SLEEPY_END;
        }
        else if (!aLinkModeCfg.mDeviceType)
        {
            // If it's not an FTD, return as minimal end device.
            nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_MINIMAL_END;
        }
        else
        {
            nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_END;
        }
        break;
    default:
        nodeType = ThreadnetworkTelemetryDataReported::NODE_TYPE_UNSPECIFIED;
    }

    return nodeType;
}

#if OTBR_ENABLE_SRP_ADVERTISING_PROXY
ThreadnetworkTelemetryDataReported::SrpServerState SrpServerStateFromOtSrpServerState(otSrpServerState aSrpServerState)
{
    ThreadnetworkTelemetryDataReported::SrpServerState srpServerState;

    switch (aSrpServerState)
    {
    case OT_SRP_SERVER_STATE_DISABLED:
        srpServerState = ThreadnetworkTelemetryDataReported::SRP_SERVER_STATE_DISABLED;
        break;
    case OT_SRP_SERVER_STATE_RUNNING:
        srpServerState = ThreadnetworkTelemetryDataReported::SRP_SERVER_STATE_RUNNING;
        break;
    case OT_SRP_SERVER_STATE_STOPPED:
        srpServerState = ThreadnetworkTelemetryDataReported::SRP_SERVER_STATE_STOPPED;
        break;
    default:
        srpServerState = ThreadnetworkTelemetryDataReported::SRP_SERVER_STATE_UNSPECIFIED;
    }
    return srpServerState;
}

ThreadnetworkTelemetryDataReported::SrpServerAddressMode SrpServerAddressModeFromOtSrpServerAddressMode(
    otSrpServerAddressMode aSrpServerAddressMode)
{
    ThreadnetworkTelemetryDataReported::SrpServerAddressMode srpServerAddressMode;

    switch (aSrpServerAddressMode)
    {
    case OT_SRP_SERVER_ADDRESS_MODE_ANYCAST:
        srpServerAddressMode = ThreadnetworkTelemetryDataReported::SRP_SERVER_ADDRESS_MODE_STATE_ANYCAST;
        break;
    case OT_SRP_SERVER_ADDRESS_MODE_UNICAST:
        srpServerAddressMode = ThreadnetworkTelemetryDataReported::SRP_SERVER_ADDRESS_MODE_UNICAST;
        break;
    default:
        srpServerAddressMode = ThreadnetworkTelemetryDataReported::SRP_SERVER_ADDRESS_MODE_UNSPECIFIED;
    }
    return srpServerAddressMode;
}
#endif // OTBR_ENABLE_SRP_ADVERTISING_PROXY

void CopyMdnsResponseCounters(const MdnsResponseCounters                               &from,
                              ThreadnetworkTelemetryDataReported::MdnsResponseCounters *to)
{
    to->set_success_count(from.mSuccess);
    to->set_not_found_count(from.mNotFound);
    to->set_invalid_args_count(from.mInvalidArgs);
    to->set_duplicated_count(from.mDuplicated);
    to->set_not_implemented_count(from.mNotImplemented);
    to->set_unknown_error_count(from.mUnknownError);
    to->set_aborted_count(from.mAborted);
    to->set_invalid_state_count(from.mInvalidState);
}

TelemetryData::Nat64State Nat64StateFromOtNat64State(otNat64State aNat64State)
{
    TelemetryData::Nat64State nat64State;

    switch (aNat64State)
    {
    case OT_NAT64_STATE_DISABLED:
        nat64State = TelemetryData::NAT64_STATE_DISABLED;
        break;
    case OT_NAT64_STATE_NOT_RUNNING:
        nat64State = TelemetryData::NAT64_STATE_NOT_RUNNING;
        break;
    case OT_NAT64_STATE_IDLE:
        nat64State = TelemetryData::NAT64_STATE_IDLE;
        break;
    case OT_NAT64_STATE_ACTIVE:
        nat64State = TelemetryData::NAT64_STATE_ACTIVE;
        break;
    default:
        nat64State = TelemetryData::NAT64_STATE_UNSPECIFIED;
    }

    return nat64State;
}

void RetrieveNat64State(otInstance *aInstance, TelemetryData::WpanBorderRouter *aWpanBorderRouter)
{
    auto nat64State = aWpanBorderRouter->mutable_nat64_state();

    nat64State->set_prefix_manager_state(Nat64StateFromOtNat64State(otNat64GetPrefixManagerState(aInstance)));
    nat64State->set_translator_state(Nat64StateFromOtNat64State(otNat64GetTranslatorState(aInstance)));
}

void RetrieveNat64Counters(otInstance *aInstance, TelemetryData::BorderRoutingCounters *aBorderRoutingCounters)
{
    {
        auto nat64IcmpCounters = aBorderRoutingCounters->mutable_nat64_protocol_counters()->mutable_icmp();
        auto nat64UdpCounters  = aBorderRoutingCounters->mutable_nat64_protocol_counters()->mutable_udp();
        auto nat64TcpCounters  = aBorderRoutingCounters->mutable_nat64_protocol_counters()->mutable_tcp();
        otNat64ProtocolCounters otCounters;

        otNat64GetCounters(aInstance, &otCounters);
        nat64IcmpCounters->set_ipv4_to_ipv6_packets(otCounters.mIcmp.m4To6Packets);
        nat64IcmpCounters->set_ipv4_to_ipv6_bytes(otCounters.mIcmp.m4To6Bytes);
        nat64IcmpCounters->set_ipv6_to_ipv4_packets(otCounters.mIcmp.m6To4Packets);
        nat64IcmpCounters->set_ipv6_to_ipv4_bytes(otCounters.mIcmp.m6To4Bytes);
        nat64UdpCounters->set_ipv4_to_ipv6_packets(otCounters.mUdp.m4To6Packets);
        nat64UdpCounters->set_ipv4_to_ipv6_bytes(otCounters.mUdp.m4To6Bytes);
        nat64UdpCounters->set_ipv6_to_ipv4_packets(otCounters.mUdp.m6To4Packets);
        nat64UdpCounters->set_ipv6_to_ipv4_bytes(otCounters.mUdp.m6To4Bytes);
        nat64TcpCounters->set_ipv4_to_ipv6_packets(otCounters.mTcp.m4To6Packets);
        nat64TcpCounters->set_ipv4_to_ipv6_bytes(otCounters.mTcp.m4To6Bytes);
        nat64TcpCounters->set_ipv6_to_ipv4_packets(otCounters.mTcp.m6To4Packets);
        nat64TcpCounters->set_ipv6_to_ipv4_bytes(otCounters.mTcp.m6To4Bytes);
    }

    {
        auto                 errorCounters = aBorderRoutingCounters->mutable_nat64_error_counters();
        otNat64ErrorCounters otCounters;
        otNat64GetErrorCounters(aInstance, &otCounters);

        errorCounters->mutable_unknown()->set_ipv4_to_ipv6_packets(otCounters.mCount4To6[OT_NAT64_DROP_REASON_UNKNOWN]);
        errorCounters->mutable_unknown()->set_ipv6_to_ipv4_packets(otCounters.mCount6To4[OT_NAT64_DROP_REASON_UNKNOWN]);
        errorCounters->mutable_illegal_packet()->set_ipv4_to_ipv6_packets(
            otCounters.mCount4To6[OT_NAT64_DROP_REASON_ILLEGAL_PACKET]);
        errorCounters->mutable_illegal_packet()->set_ipv6_to_ipv4_packets(
            otCounters.mCount6To4[OT_NAT64_DROP_REASON_ILLEGAL_PACKET]);
        errorCounters->mutable_unsupported_protocol()->set_ipv4_to_ipv6_packets(
            otCounters.mCount4To6[OT_NAT64_DROP_REASON_UNSUPPORTED_PROTO]);
        errorCounters->mutable_unsupported_protocol()->set_ipv6_to_ipv4_packets(
            otCounters.mCount6To4[OT_NAT64_DROP_REASON_UNSUPPORTED_PROTO]);
        errorCounters->mutable_no_mapping()->set_ipv4_to_ipv6_packets(
            otCounters.mCount4To6[OT_NAT64_DROP_REASON_NO_MAPPING]);
        errorCounters->mutable_no_mapping()->set_ipv6_to_ipv4_packets(
            otCounters.mCount6To4[OT_NAT64_DROP_REASON_NO_MAPPING]);
    }
}

void RetrieveBorderAgentInfo(otInstance *aInstance, TelemetryData::BorderAgentInfo *aBorderAgentInfo)
{
    auto baCounters            = aBorderAgentInfo->mutable_border_agent_counters();
    auto otBorderAgentCounters = *otBorderAgentGetCounters(aInstance);

    baCounters->set_epskc_activations(otBorderAgentCounters.mEpskcActivations);
    baCounters->set_epskc_deactivation_clears(otBorderAgentCounters.mEpskcDeactivationClears);
    baCounters->set_epskc_deactivation_timeouts(otBorderAgentCounters.mEpskcDeactivationTimeouts);
    baCounters->set_epskc_deactivation_max_attempts(otBorderAgentCounters.mEpskcDeactivationMaxAttempts);
    baCounters->set_epskc_deactivation_disconnects(otBorderAgentCounters.mEpskcDeactivationDisconnects);
    baCounters->set_epskc_invalid_ba_state_errors(otBorderAgentCounters.mEpskcInvalidBaStateErrors);
    baCounters->set_epskc_invalid_args_errors(otBorderAgentCounters.mEpskcInvalidArgsErrors);
    baCounters->set_epskc_start_secure_session_errors(otBorderAgentCounters.mEpskcStartSecureSessionErrors);
    baCounters->set_epskc_secure_session_successes(otBorderAgentCounters.mEpskcSecureSessionSuccesses);
    baCounters->set_epskc_secure_session_failures(otBorderAgentCounters.mEpskcSecureSessionFailures);
    baCounters->set_epskc_commissioner_petitions(otBorderAgentCounters.mEpskcCommissionerPetitions);

    baCounters->set_pskc_secure_session_successes(otBorderAgentCounters.mPskcSecureSessionSuccesses);
    baCounters->set_pskc_secure_session_failures(otBorderAgentCounters.mPskcSecureSessionFailures);
    baCounters->set_pskc_commissioner_petitions(otBorderAgentCounters.mPskcCommissionerPetitions);

    baCounters->set_mgmt_active_get_reqs(otBorderAgentCounters.mMgmtActiveGets);
    baCounters->set_mgmt_pending_get_reqs(otBorderAgentCounters.mMgmtPendingGets);
}

void RetrieveTrelInfo(otInstance *aInstance, TelemetryData::TrelInfo *aTrelInfo)
{
    auto otTrelCounters = otTrelGetCounters(aInstance);
    auto trelCounters   = aTrelInfo->mutable_counters();

    aTrelInfo->set_is_trel_enabled(otTrelIsEnabled(aInstance));
    aTrelInfo->set_num_trel_peers(otTrelGetNumberOfPeers(aInstance));

    trelCounters->set_trel_tx_packets(otTrelCounters->mTxPackets);
    trelCounters->set_trel_tx_bytes(otTrelCounters->mTxBytes);
    trelCounters->set_trel_tx_packets_failed(otTrelCounters->mTxFailure);
    trelCounters->set_trel_rx_packets(otTrelCounters->mRxPackets);
    trelCounters->set_trel_rx_bytes(otTrelCounters->mRxBytes);
}

otError RetrieveTelemetryAtom(otInstance                         *otInstance,
                              Mdns::Publisher                    *aPublisher,
                              ThreadnetworkTelemetryDataReported &telemetryDataReported,
                              ThreadnetworkTopoEntryRepeated     &topoEntryRepeated,
                              ThreadnetworkDeviceInfoReported    &deviceInfoReported)
{
    otError                     error = OT_ERROR_NONE;
    std::vector<otNeighborInfo> neighborTable;

    // Begin of ThreadnetworkDeviceInfoReported section.
    deviceInfoReported.set_thread_version(otThreadGetVersion());
    deviceInfoReported.set_ot_rcp_version(otGetRadioVersionString(otInstance));
    // TODO: populate ot_host_version, thread_daemon_version.
    // End of ThreadnetworkDeviceInfoReported section.

    // Begin of WpanStats section.
    auto wpanStats = telemetryDataReported.mutable_wpan_stats();

    {
        otDeviceRole     role  = otThreadGetDeviceRole(otInstance);
        otLinkModeConfig otCfg = otThreadGetLinkMode(otInstance);

        wpanStats->set_node_type(TelemetryNodeTypeFromRoleAndLinkMode(role, otCfg));
    }

    // Disable telemetry retrieval when Thread stack is disabled. DeviceInfo section above is
    // always uploaded to understand the device count.
    if (wpanStats->node_type() == ThreadnetworkTelemetryDataReported::NODE_TYPE_DISABLED)
    {
        otbrLogDebug("Skip telemetry retrieval since Thread stack is disabled.");
        // Return error that only partial telemetries are populated.
        // TODO: refine the error code name to mean: partial data are populated.
        return OT_ERROR_FAILED;
    }

    wpanStats->set_channel(otLinkGetChannel(otInstance));

    {
        uint16_t ccaFailureRate = otLinkGetCcaFailureRate(otInstance);

        wpanStats->set_mac_cca_fail_rate(static_cast<float>(ccaFailureRate) / 0xffff);
    }

    {
        int8_t radioTxPower;

        if (otPlatRadioGetTransmitPower(otInstance, &radioTxPower) == OT_ERROR_NONE)
        {
            wpanStats->set_radio_tx_power(radioTxPower);
        }
        else
        {
            error = OT_ERROR_FAILED;
        }
    }

    {
        const otMacCounters *linkCounters = otLinkGetCounters(otInstance);

        wpanStats->set_phy_rx(linkCounters->mRxTotal);
        wpanStats->set_phy_tx(linkCounters->mTxTotal);
        wpanStats->set_mac_unicast_rx(linkCounters->mRxUnicast);
        wpanStats->set_mac_unicast_tx(linkCounters->mTxUnicast);
        wpanStats->set_mac_broadcast_rx(linkCounters->mRxBroadcast);
        wpanStats->set_mac_broadcast_tx(linkCounters->mTxBroadcast);
        wpanStats->set_mac_tx_ack_req(linkCounters->mTxAckRequested);
        wpanStats->set_mac_tx_no_ack_req(linkCounters->mTxNoAckRequested);
        wpanStats->set_mac_tx_acked(linkCounters->mTxAcked);
        wpanStats->set_mac_tx_data(linkCounters->mTxData);
        wpanStats->set_mac_tx_data_poll(linkCounters->mTxDataPoll);
        wpanStats->set_mac_tx_beacon(linkCounters->mTxBeacon);
        wpanStats->set_mac_tx_beacon_req(linkCounters->mTxBeaconRequest);
        wpanStats->set_mac_tx_other_pkt(linkCounters->mTxOther);
        wpanStats->set_mac_tx_retry(linkCounters->mTxRetry);
        wpanStats->set_mac_rx_data(linkCounters->mRxData);
        wpanStats->set_mac_rx_data_poll(linkCounters->mRxDataPoll);
        wpanStats->set_mac_rx_beacon(linkCounters->mRxBeacon);
        wpanStats->set_mac_rx_beacon_req(linkCounters->mRxBeaconRequest);
        wpanStats->set_mac_rx_other_pkt(linkCounters->mRxOther);
        wpanStats->set_mac_rx_filter_whitelist(linkCounters->mRxAddressFiltered);
        wpanStats->set_mac_rx_filter_dest_addr(linkCounters->mRxDestAddrFiltered);
        wpanStats->set_mac_tx_fail_cca(linkCounters->mTxErrCca);
        wpanStats->set_mac_rx_fail_decrypt(linkCounters->mRxErrSec);
        wpanStats->set_mac_rx_fail_no_frame(linkCounters->mRxErrNoFrame);
        wpanStats->set_mac_rx_fail_unknown_neighbor(linkCounters->mRxErrUnknownNeighbor);
        wpanStats->set_mac_rx_fail_invalid_src_addr(linkCounters->mRxErrInvalidSrcAddr);
        wpanStats->set_mac_rx_fail_fcs(linkCounters->mRxErrFcs);
        wpanStats->set_mac_rx_fail_other(linkCounters->mRxErrOther);
    }

    {
        const otIpCounters *ipCounters = otThreadGetIp6Counters(otInstance);

        wpanStats->set_ip_tx_success(ipCounters->mTxSuccess);
        wpanStats->set_ip_rx_success(ipCounters->mRxSuccess);
        wpanStats->set_ip_tx_failure(ipCounters->mTxFailure);
        wpanStats->set_ip_rx_failure(ipCounters->mRxFailure);
    }
    // End of WpanStats section.

    {
        // Begin of WpanTopoFull section.
        auto     wpanTopoFull = telemetryDataReported.mutable_wpan_topo_full();
        uint16_t rloc16       = otThreadGetRloc16(otInstance);

        wpanTopoFull->set_rloc16(rloc16);

        {
            otRouterInfo info;

            if (otThreadGetRouterInfo(otInstance, rloc16, &info) == OT_ERROR_NONE)
            {
                wpanTopoFull->set_router_id(info.mRouterId);
            }
            else
            {
                error = OT_ERROR_FAILED;
            }
        }

        {
            otNeighborInfoIterator iter = OT_NEIGHBOR_INFO_ITERATOR_INIT;
            otNeighborInfo         neighborInfo;

            while (otThreadGetNextNeighborInfo(otInstance, &iter, &neighborInfo) == OT_ERROR_NONE)
            {
                neighborTable.push_back(neighborInfo);
            }
        }
        wpanTopoFull->set_neighbor_table_size(neighborTable.size());

        uint16_t                 childIndex = 0;
        otChildInfo              childInfo;
        std::vector<otChildInfo> childTable;

        while (otThreadGetChildInfoByIndex(otInstance, childIndex, &childInfo) == OT_ERROR_NONE)
        {
            childTable.push_back(childInfo);
            childIndex++;
        }
        wpanTopoFull->set_child_table_size(childTable.size());

        {
            struct otLeaderData leaderData;

            if (otThreadGetLeaderData(otInstance, &leaderData) == OT_ERROR_NONE)
            {
                wpanTopoFull->set_leader_router_id(leaderData.mLeaderRouterId);
                wpanTopoFull->set_leader_weight(leaderData.mWeighting);
                // Do not log network_data_version.
            }
            else
            {
                error = OT_ERROR_FAILED;
            }
        }

        uint8_t weight = otThreadGetLocalLeaderWeight(otInstance);

        wpanTopoFull->set_leader_local_weight(weight);

        int8_t rssi = otPlatRadioGetRssi(otInstance);

        wpanTopoFull->set_instant_rssi(rssi);

        const otExtendedPanId *extPanId = otThreadGetExtendedPanId(otInstance);
        uint64_t               extPanIdVal;

        extPanIdVal = ConvertOpenThreadUint64(extPanId->m8);
        wpanTopoFull->set_has_extended_pan_id(extPanIdVal != 0);
        // Note: Used leader_router_id instead of leader_rloc16.
        // Note: Network level info (e.g., extended_pan_id, partition_id, is_active_br) is not logged.
        // TODO: populate is_active_srp_server, sum_on_link_prefix_changes, preferred_router_id
        // if needed.
        // End of WpanTopoFull section.

        // Begin of TopoEntry section.
        std::map<uint16_t, const otChildInfo *> childMap;

        for (const otChildInfo &childInfo : childTable)
        {
            auto pair = childMap.insert({childInfo.mRloc16, &childInfo});
            if (!pair.second)
            {
                // This shouldn't happen, so log an error. It doesn't matter which
                // duplicate is kept.
                otbrLogErr("Children with duplicate RLOC16 found: 0x%04x", static_cast<int>(childInfo.mRloc16));
            }
        }

        for (const otNeighborInfo &neighborInfo : neighborTable)
        {
            auto topoEntry = topoEntryRepeated.mutable_topo_entry_repeated()->add_topo_entries();

            // 0~15: uint16_t rloc_16
            // 16~31: uint16_t version Thread version of the neighbor
            uint32_t comboTelemetry1 = 0;
            comboTelemetry1 |= (((uint32_t)neighborInfo.mRloc16) & 0x0000FFFF);
            comboTelemetry1 |= ((((uint32_t)neighborInfo.mVersion) & 0x0000FFFF) << 16);
            topoEntry->set_combo_telemetry1(comboTelemetry1);

            topoEntry->set_age_sec(neighborInfo.mAge);

            // 0~7: uint8_t link_quality_in
            // 8~15: int8_t average_rssi
            // 16~23: int8_t last_rssi
            // 24~31: uint8_t network_data_version
            uint32_t comboTelemetry2 = 0;
            comboTelemetry2 |= (((uint32_t)neighborInfo.mLinkQualityIn) & 0x000000FF);
            comboTelemetry2 |= ((((uint32_t)neighborInfo.mAverageRssi) & 0x000000FF) << 8);
            comboTelemetry2 |= ((((uint32_t)neighborInfo.mLastRssi) & 0x000000FF) << 16);
            // network_data_version is populated in the next section.
            topoEntry->set_combo_telemetry2(comboTelemetry2);

            // Each bit on the flag represents a bool flag
            // 0: rx_on_when_idle
            // 1: full_function
            // 2: secure_data_request
            // 3: full_network_data
            // 4: is_child
            uint32_t topoEntryFlags = 0;
            topoEntryFlags |= (neighborInfo.mRxOnWhenIdle ? 1 : 0);
            topoEntryFlags |= ((neighborInfo.mFullThreadDevice ? 1 : 0) << 1);
            topoEntryFlags |= ((/* secure_data_request */ true ? 1 : 0) << 2);
            topoEntryFlags |= ((neighborInfo.mFullNetworkData ? 1 : 0) << 3);
            topoEntry->set_topo_entry_flags(topoEntryFlags);

            topoEntry->set_link_frame_counter(neighborInfo.mLinkFrameCounter);
            topoEntry->set_mle_frame_counter(neighborInfo.mMleFrameCounter);

            // 0~15: uint16_t mac_frame_error_rate. Frame error rate (0xffff->100%). Requires error tracking feature.
            // 16~31: uint16_t ip_message_error_rate. (IPv6) msg error rate (0xffff->100%). Requires error tracking
            // feature.
            uint32_t comboTelemetry3 = 0;
            comboTelemetry3 |= ((uint32_t)(neighborInfo.mFrameErrorRate) & 0x0000FFFF);
            comboTelemetry3 |= ((((uint32_t)neighborInfo.mMessageErrorRate) & 0x0000FFFF) << 16);
            topoEntry->set_combo_telemetry3(comboTelemetry3);

            if (!neighborInfo.mIsChild)
            {
                continue;
            }

            auto it = childMap.find(neighborInfo.mRloc16);
            if (it == childMap.end())
            {
                otbrLogErr("Neighbor 0x%04x not found in child table", static_cast<int>(neighborInfo.mRloc16));
                continue;
            }
            const otChildInfo *childInfo = it->second;

            comboTelemetry2 |= ((((uint32_t)childInfo->mNetworkDataVersion) & 0x000000FF) << 24);
            topoEntry->set_combo_telemetry2(comboTelemetry2);

            topoEntryFlags |= ((/* is_child */ true ? 1 : 0) << 4);
            topoEntry->set_topo_entry_flags(topoEntryFlags);

            topoEntry->set_timeout_sec(childInfo->mTimeout);
        }
        // End of TopoEntry section.
    }

    {
        // Begin of WpanBorderRouter section.
        auto wpanBorderRouter = telemetryDataReported.mutable_wpan_border_router();

        // Begin of BorderRoutingCounters section.
        {
            auto                           borderRoutingCouters = wpanBorderRouter->mutable_border_routing_counters();
            const otBorderRoutingCounters *otBorderRoutingCounters = otIp6GetBorderRoutingCounters(otInstance);

            borderRoutingCouters->mutable_inbound_unicast()->set_packet_count(
                otBorderRoutingCounters->mInboundUnicast.mPackets);
            borderRoutingCouters->mutable_inbound_unicast()->set_byte_count(
                otBorderRoutingCounters->mInboundUnicast.mBytes);
            borderRoutingCouters->mutable_inbound_multicast()->set_packet_count(
                otBorderRoutingCounters->mInboundMulticast.mPackets);
            borderRoutingCouters->mutable_inbound_multicast()->set_byte_count(
                otBorderRoutingCounters->mInboundMulticast.mBytes);
            borderRoutingCouters->mutable_outbound_unicast()->set_packet_count(
                otBorderRoutingCounters->mOutboundUnicast.mPackets);
            borderRoutingCouters->mutable_outbound_unicast()->set_byte_count(
                otBorderRoutingCounters->mOutboundUnicast.mBytes);
            borderRoutingCouters->mutable_outbound_multicast()->set_packet_count(
                otBorderRoutingCounters->mOutboundMulticast.mPackets);
            borderRoutingCouters->mutable_outbound_multicast()->set_byte_count(
                otBorderRoutingCounters->mOutboundMulticast.mBytes);
            borderRoutingCouters->set_ra_rx(otBorderRoutingCounters->mRaRx);
            borderRoutingCouters->set_ra_tx_success(otBorderRoutingCounters->mRaTxSuccess);
            borderRoutingCouters->set_ra_tx_failure(otBorderRoutingCounters->mRaTxFailure);
            borderRoutingCouters->set_rs_rx(otBorderRoutingCounters->mRsRx);
            borderRoutingCouters->set_rs_tx_success(otBorderRoutingCounters->mRsTxSuccess);
            borderRoutingCouters->set_rs_tx_failure(otBorderRoutingCounters->mRsTxFailure);

            RetrieveNat64Counters(otInstance, borderRoutingCouters);
        }

        // End of BorderRoutingCounters section.

#if OTBR_ENABLE_SRP_ADVERTISING_PROXY
        // Begin of SrpServerInfo section.
        {
            auto                               srpServer = wpanBorderRouter->mutable_srp_server();
            otSrpServerLeaseInfo               leaseInfo;
            const otSrpServerHost             *host             = nullptr;
            const otSrpServerResponseCounters *responseCounters = otSrpServerGetResponseCounters(otInstance);

            srpServer->set_state(SrpServerStateFromOtSrpServerState(otSrpServerGetState(otInstance)));
            srpServer->set_port(otSrpServerGetPort(otInstance));
            srpServer->set_address_mode(
                SrpServerAddressModeFromOtSrpServerAddressMode(otSrpServerGetAddressMode(otInstance)));

            auto srpServerHosts            = srpServer->mutable_hosts();
            auto srpServerServices         = srpServer->mutable_services();
            auto srpServerResponseCounters = srpServer->mutable_response_counters();

            while ((host = otSrpServerGetNextHost(otInstance, host)))
            {
                const otSrpServerService *service = nullptr;

                if (otSrpServerHostIsDeleted(host))
                {
                    srpServerHosts->set_deleted_count(srpServerHosts->deleted_count() + 1);
                }
                else
                {
                    srpServerHosts->set_fresh_count(srpServerHosts->fresh_count() + 1);
                    otSrpServerHostGetLeaseInfo(host, &leaseInfo);
                    srpServerHosts->set_lease_time_total_ms(srpServerHosts->lease_time_total_ms() + leaseInfo.mLease);
                    srpServerHosts->set_key_lease_time_total_ms(srpServerHosts->key_lease_time_total_ms() +
                                                                leaseInfo.mKeyLease);
                    srpServerHosts->set_remaining_lease_time_total_ms(srpServerHosts->remaining_lease_time_total_ms() +
                                                                      leaseInfo.mRemainingLease);
                    srpServerHosts->set_remaining_key_lease_time_total_ms(
                        srpServerHosts->remaining_key_lease_time_total_ms() + leaseInfo.mRemainingKeyLease);
                }

                while ((service = otSrpServerHostGetNextService(host, service)))
                {
                    if (otSrpServerServiceIsDeleted(service))
                    {
                        srpServerServices->set_deleted_count(srpServerServices->deleted_count() + 1);
                    }
                    else
                    {
                        srpServerServices->set_fresh_count(srpServerServices->fresh_count() + 1);
                        otSrpServerServiceGetLeaseInfo(service, &leaseInfo);
                        srpServerServices->set_lease_time_total_ms(srpServerServices->lease_time_total_ms() +
                                                                   leaseInfo.mLease);
                        srpServerServices->set_key_lease_time_total_ms(srpServerServices->key_lease_time_total_ms() +
                                                                       leaseInfo.mKeyLease);
                        srpServerServices->set_remaining_lease_time_total_ms(
                            srpServerServices->remaining_lease_time_total_ms() + leaseInfo.mRemainingLease);
                        srpServerServices->set_remaining_key_lease_time_total_ms(
                            srpServerServices->remaining_key_lease_time_total_ms() + leaseInfo.mRemainingKeyLease);
                    }
                }
            }

            srpServerResponseCounters->set_success_count(responseCounters->mSuccess);
            srpServerResponseCounters->set_server_failure_count(responseCounters->mServerFailure);
            srpServerResponseCounters->set_format_error_count(responseCounters->mFormatError);
            srpServerResponseCounters->set_name_exists_count(responseCounters->mNameExists);
            srpServerResponseCounters->set_refused_count(responseCounters->mRefused);
            srpServerResponseCounters->set_other_count(responseCounters->mOther);
        }
        // End of SrpServerInfo section.
#endif // OTBR_ENABLE_SRP_ADVERTISING_PROXY

#if OTBR_ENABLE_DNSSD_DISCOVERY_PROXY
        // Begin of DnsServerInfo section.
        {
            auto            dnsServer                 = wpanBorderRouter->mutable_dns_server();
            auto            dnsServerResponseCounters = dnsServer->mutable_response_counters();
            otDnssdCounters otDnssdCounters           = *otDnssdGetCounters(otInstance);

            dnsServerResponseCounters->set_success_count(otDnssdCounters.mSuccessResponse);
            dnsServerResponseCounters->set_server_failure_count(otDnssdCounters.mServerFailureResponse);
            dnsServerResponseCounters->set_format_error_count(otDnssdCounters.mFormatErrorResponse);
            dnsServerResponseCounters->set_name_error_count(otDnssdCounters.mNameErrorResponse);
            dnsServerResponseCounters->set_not_implemented_count(otDnssdCounters.mNotImplementedResponse);
            dnsServerResponseCounters->set_other_count(otDnssdCounters.mOtherResponse);
            // The counters of queries, responses, failures handled by upstream DNS server.
            dnsServerResponseCounters->set_upstream_dns_queries(otDnssdCounters.mUpstreamDnsCounters.mQueries);
            dnsServerResponseCounters->set_upstream_dns_responses(otDnssdCounters.mUpstreamDnsCounters.mResponses);
            dnsServerResponseCounters->set_upstream_dns_failures(otDnssdCounters.mUpstreamDnsCounters.mFailures);

            dnsServer->set_resolved_by_local_srp_count(otDnssdCounters.mResolvedBySrp);

            dnsServer->set_upstream_dns_query_state(
                otDnssdUpstreamQueryIsEnabled(otInstance)
                    ? ThreadnetworkTelemetryDataReported::UPSTREAMDNS_QUERY_STATE_ENABLED
                    : ThreadnetworkTelemetryDataReported::UPSTREAMDNS_QUERY_STATE_DISABLED);
        }
        // End of DnsServerInfo section.
#endif // OTBR_ENABLE_DNSSD_DISCOVERY_PROXY

        // Start of MdnsInfo section.
        if (aPublisher != nullptr)
        {
            auto                     mdns     = wpanBorderRouter->mutable_mdns();
            const MdnsTelemetryInfo &mdnsInfo = aPublisher->GetMdnsTelemetryInfo();

            CopyMdnsResponseCounters(mdnsInfo.mHostRegistrations, mdns->mutable_host_registration_responses());
            CopyMdnsResponseCounters(mdnsInfo.mServiceRegistrations, mdns->mutable_service_registration_responses());
            CopyMdnsResponseCounters(mdnsInfo.mHostResolutions, mdns->mutable_host_resolution_responses());
            CopyMdnsResponseCounters(mdnsInfo.mServiceResolutions, mdns->mutable_service_resolution_responses());

            mdns->set_host_registration_ema_latency_ms(mdnsInfo.mHostRegistrationEmaLatency);
            mdns->set_service_registration_ema_latency_ms(mdnsInfo.mServiceRegistrationEmaLatency);
            mdns->set_host_resolution_ema_latency_ms(mdnsInfo.mHostResolutionEmaLatency);
            mdns->set_service_resolution_ema_latency_ms(mdnsInfo.mServiceResolutionEmaLatency);
        }
        // End of MdnsInfo section.

        // End of WpanBorderRouter section.

        // Start of WpanRcp section.
        {
            auto                        wpanRcp                = telemetryDataReported.mutable_wpan_rcp();
            const otRadioSpinelMetrics *otRadioSpinelMetrics   = otSysGetRadioSpinelMetrics();
            auto                        rcpStabilityStatistics = wpanRcp->mutable_rcp_stability_statistics();

            if (otRadioSpinelMetrics != nullptr)
            {
                rcpStabilityStatistics->set_rcp_timeout_count(otRadioSpinelMetrics->mRcpTimeoutCount);
                rcpStabilityStatistics->set_rcp_reset_count(otRadioSpinelMetrics->mRcpUnexpectedResetCount);
                rcpStabilityStatistics->set_rcp_restoration_count(otRadioSpinelMetrics->mRcpRestorationCount);
                rcpStabilityStatistics->set_spinel_parse_error_count(otRadioSpinelMetrics->mSpinelParseErrorCount);
            }

            // TODO: provide rcp_firmware_update_count info.
            rcpStabilityStatistics->set_thread_stack_uptime(otInstanceGetUptime(otInstance));

            const otRcpInterfaceMetrics *otRcpInterfaceMetrics = otSysGetRcpInterfaceMetrics();

            if (otRcpInterfaceMetrics != nullptr)
            {
                auto rcpInterfaceStatistics = wpanRcp->mutable_rcp_interface_statistics();

                rcpInterfaceStatistics->set_rcp_interface_type(otRcpInterfaceMetrics->mRcpInterfaceType);
                rcpInterfaceStatistics->set_transferred_frames_count(otRcpInterfaceMetrics->mTransferredFrameCount);
                rcpInterfaceStatistics->set_transferred_valid_frames_count(
                    otRcpInterfaceMetrics->mTransferredValidFrameCount);
                rcpInterfaceStatistics->set_transferred_garbage_frames_count(
                    otRcpInterfaceMetrics->mTransferredGarbageFrameCount);
                rcpInterfaceStatistics->set_rx_frames_count(otRcpInterfaceMetrics->mRxFrameCount);
                rcpInterfaceStatistics->set_rx_bytes_count(otRcpInterfaceMetrics->mRxFrameByteCount);
                rcpInterfaceStatistics->set_tx_frames_count(otRcpInterfaceMetrics->mTxFrameCount);
                rcpInterfaceStatistics->set_tx_bytes_count(otRcpInterfaceMetrics->mTxFrameByteCount);
            }
        }
        // End of WpanRcp section.

        // Start of CoexMetrics section.
        {
            auto               coexMetrics = telemetryDataReported.mutable_coex_metrics();
            otRadioCoexMetrics otRadioCoexMetrics;

            if (otPlatRadioGetCoexMetrics(otInstance, &otRadioCoexMetrics) == OT_ERROR_NONE)
            {
                coexMetrics->set_count_tx_request(otRadioCoexMetrics.mNumTxRequest);
                coexMetrics->set_count_tx_grant_immediate(otRadioCoexMetrics.mNumTxGrantImmediate);
                coexMetrics->set_count_tx_grant_wait(otRadioCoexMetrics.mNumTxGrantWait);
                coexMetrics->set_count_tx_grant_wait_activated(otRadioCoexMetrics.mNumTxGrantWaitActivated);
                coexMetrics->set_count_tx_grant_wait_timeout(otRadioCoexMetrics.mNumTxGrantWaitTimeout);
                coexMetrics->set_count_tx_grant_deactivated_during_request(
                    otRadioCoexMetrics.mNumTxGrantDeactivatedDuringRequest);
                coexMetrics->set_tx_average_request_to_grant_time_us(otRadioCoexMetrics.mAvgTxRequestToGrantTime);
                coexMetrics->set_count_rx_request(otRadioCoexMetrics.mNumRxRequest);
                coexMetrics->set_count_rx_grant_immediate(otRadioCoexMetrics.mNumRxGrantImmediate);
                coexMetrics->set_count_rx_grant_wait(otRadioCoexMetrics.mNumRxGrantWait);
                coexMetrics->set_count_rx_grant_wait_activated(otRadioCoexMetrics.mNumRxGrantWaitActivated);
                coexMetrics->set_count_rx_grant_wait_timeout(otRadioCoexMetrics.mNumRxGrantWaitTimeout);
                coexMetrics->set_count_rx_grant_deactivated_during_request(
                    otRadioCoexMetrics.mNumRxGrantDeactivatedDuringRequest);
                coexMetrics->set_count_rx_grant_none(otRadioCoexMetrics.mNumRxGrantNone);
                coexMetrics->set_rx_average_request_to_grant_time_us(otRadioCoexMetrics.mAvgRxRequestToGrantTime);
            }
            else
            {
                error = OT_ERROR_FAILED;
            }
        }
        // End of CoexMetrics section.

        RetrieveNat64State(otInstance, wpanBorderRouter);
        RetrieveBorderAgentInfo(otInstance, wpanBorderRouter->mutable_border_agent_info());
        RetrieveTrelInfo(otInstance, wpanBorderRouter->mutable_trel_info());
    }

    return error;
}

int PushAtom(const ThreadnetworkTelemetryDataReported &telemetryDataReported)
{
    const std::string        &wpanStats        = telemetryDataReported.wpan_stats().SerializeAsString();
    const std::string        &wpanTopoFull     = telemetryDataReported.wpan_topo_full().SerializeAsString();
    const std::string        &wpanBorderRouter = telemetryDataReported.wpan_border_router().SerializeAsString();
    const std::string        &wpanRcp          = telemetryDataReported.wpan_rcp().SerializeAsString();
    const std::string        &coexMetrics      = telemetryDataReported.coex_metrics().SerializeAsString();
    threadnetwork::BytesField wpanStatsBytesField{wpanStats.c_str(), wpanStats.size()};
    threadnetwork::BytesField wpanTopoFullBytesField{wpanTopoFull.c_str(), wpanTopoFull.size()};
    threadnetwork::BytesField wpanBorderRouterBytesField{wpanBorderRouter.c_str(), wpanBorderRouter.size()};
    threadnetwork::BytesField wpanRcpBytesField{wpanRcp.c_str(), wpanRcp.size()};
    threadnetwork::BytesField coexMetricsBytesField{coexMetrics.c_str(), coexMetrics.size()};
    return threadnetwork::stats_write(threadnetwork::THREADNETWORK_TELEMETRY_DATA_REPORTED, wpanStatsBytesField,
                                      wpanTopoFullBytesField, wpanBorderRouterBytesField, wpanRcpBytesField,
                                      coexMetricsBytesField);
}

int PushAtom(const ThreadnetworkTopoEntryRepeated &topoEntryRepeated)
{
    const std::string        &topoEntryField = topoEntryRepeated.topo_entry_repeated().SerializeAsString();
    threadnetwork::BytesField topoEntryFieldBytesField{topoEntryField.c_str(), topoEntryField.size()};
    return threadnetwork::stats_write(threadnetwork::THREADNETWORK_TOPO_ENTRY_REPEATED, topoEntryFieldBytesField);
}

int PushAtom(const ThreadnetworkDeviceInfoReported &deviceInfoReported)
{
    const std::string &otHostVersion       = deviceInfoReported.ot_host_version();
    const std::string &otRcpVersion        = deviceInfoReported.ot_rcp_version();
    const int32_t     &threadVersion       = deviceInfoReported.thread_version();
    const std::string &threadDaemonVersion = deviceInfoReported.thread_daemon_version();
    return threadnetwork::stats_write(threadnetwork::THREADNETWORK_DEVICE_INFO_REPORTED, otHostVersion.c_str(),
                                      otRcpVersion.c_str(), threadVersion, threadDaemonVersion.c_str());
}

void RetrieveAndPushAtoms(otInstance *otInstance)
{
    ThreadnetworkTelemetryDataReported telemetryDataReported;
    ThreadnetworkTopoEntryRepeated     topoEntryRepeated;
    ThreadnetworkDeviceInfoReported    deviceInfoReported;

    otbrLogInfo("Try to push threadnetwork ATOMs.");
    if (RetrieveTelemetryAtom(otInstance, nullptr, telemetryDataReported, topoEntryRepeated, deviceInfoReported) !=
        OTBR_ERROR_NONE)
    {
        otbrLogWarning("Some telemetries are not populated");
    }
    if (PushAtom(telemetryDataReported) <= 0)
    {
        otbrLogWarning("Failed to push ThreadnetworkTelemetryDataReported");
    }
    if (PushAtom(topoEntryRepeated) <= 0)
    {
        otbrLogWarning("Failed to push ThreadnetworkTopoEntryRepeated");
    }
    if (PushAtom(deviceInfoReported) <= 0)
    {
        otbrLogWarning("Failed to push ThreadnetworkDeviceInfoReported");
    }
    otbrLogInfo("Pushed threadnetwork ATOMs.");
}
} // namespace Android
} // namespace otbr