battery_collector.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
#include "../plugins/collector_plugin.h"
 
namespace kcenon {
namespace monitoring {
 
enum class battery_status {
    unknown,      
    charging,     
    discharging,  
    not_charging, 
    full          
};
 
inline std::string battery_status_to_string(battery_status status) {
    switch (status) {
        case battery_status::charging:
            return "charging";
        case battery_status::discharging:
            return "discharging";
        case battery_status::not_charging:
            return "not_charging";
        case battery_status::full:
            return "full";
        default:
            return "unknown";
    }
}
 
struct battery_info {
    std::string id;          
    std::string name;        
    std::string path;        
    std::string manufacturer;
    std::string model;       
    std::string serial;      
    std::string technology;  
};
 
struct battery_reading {
    battery_info info;  
 
    // Basic metrics
    double level_percent{0.0};         
    battery_status status{battery_status::unknown}; 
    bool is_charging{false};           
    bool ac_connected{false};          
 
    // Time estimates
    int64_t time_to_empty_seconds{-1}; 
    int64_t time_to_full_seconds{-1};  
 
    // Capacity metrics
    double design_capacity_wh{0.0};    
    double full_charge_capacity_wh{0.0}; 
    double current_capacity_wh{0.0};   
    double health_percent{0.0};        
 
    // Electrical metrics
    double voltage_volts{0.0};         
    double current_amps{0.0};          
    double power_watts{0.0};           
 
    // Thermal
    double temperature_celsius{0.0};   
    bool temperature_available{false}; 
 
    // Cycle count
    int64_t cycle_count{-1};           
 
    // Availability flags
    bool battery_present{false};       
    bool metrics_available{false};     
 
    std::chrono::system_clock::time_point timestamp;  
};
 
// Forward declaration
namespace platform {
class metrics_provider;
}  // namespace platform
 
class battery_info_collector {
   public:
    battery_info_collector();
    ~battery_info_collector();
 
    // Non-copyable, non-moveable due to internal state
    battery_info_collector(const battery_info_collector&) = delete;
    battery_info_collector& operator=(const battery_info_collector&) = delete;
    battery_info_collector(battery_info_collector&&) = delete;
    battery_info_collector& operator=(battery_info_collector&&) = delete;
 
    bool is_battery_available() const;
 
    std::vector<battery_info> enumerate_batteries();
 
    std::vector<battery_reading> read_all_batteries();
 
   private:
    std::unique_ptr<platform::metrics_provider> provider_;
};
 
class battery_collector : public collector_plugin {
   public:
    battery_collector();
    ~battery_collector() override = default;
 
    // Non-copyable, non-moveable due to internal state
    battery_collector(const battery_collector&) = delete;
    battery_collector& operator=(const battery_collector&) = delete;
    battery_collector(battery_collector&&) = delete;
    battery_collector& operator=(battery_collector&&) = delete;
 
    // collector_plugin implementation
    auto name() const -> std::string_view override { return "battery"; }
    auto collect() -> std::vector<metric> override;
    auto interval() const -> std::chrono::milliseconds override { return std::chrono::seconds(30); }
    auto is_available() const -> bool override;
    auto get_metric_types() const -> std::vector<std::string> override;
 
    auto get_metadata() const -> plugin_metadata override {
        return plugin_metadata{
            .name = name(),
            .description = "Battery status metrics (charge, health, temperature)",
            .category = plugin_category::hardware,
            .version = "1.0.0",
            .dependencies = {},
            .requires_platform_support = true
        };
    }
 
    auto initialize(const config_map& config) -> bool override;
    void shutdown() override {}
    auto get_statistics() const -> stats_map override;
 
    std::vector<battery_reading> get_last_readings() const;
 
    bool is_battery_available() const;
 
   private:
    std::unique_ptr<battery_info_collector> collector_;
 
    // Configuration
    bool collect_health_{true};
    bool collect_thermal_{true};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> batteries_found_{0};
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
    std::vector<battery_reading> last_readings_;
 
    // Helper methods
    metric create_battery_metric(const std::string& name, double value,
                                 const battery_reading& reading,
                                 const std::string& unit = "") const;
    void add_battery_metrics(std::vector<metric>& metrics,
                             const battery_reading& reading);
};
 
}  // namespace monitoring
}  // namespace kcenon