活动Activity

一.活动的生命周期
1.返回栈
Android是使用任务(task)来管理活动的,一个任务就是一组放在栈里的活动的集合,这个栈也就是返回栈。特征后进先出。
2.活动状态
a.运行状态
当一个活动位于返回栈的栈顶时,这时活动就处于运行状态。系统最不愿回收的就是处于运行状态的活动,因为这会给用户带来非常差的用户体验。
b.暂停状态
当一个活动不在处于栈顶位置,但任然可见时,这时活动就处于暂停状态。只有在极低内存的情况下,系统才会回收。
c.停止状态
当一个活动不在栈顶,并且完全不可见的时候,就进人停止状态。系统仍然为这种活动保存相应的状态和成员变量,但是当其他地方需要内存时,处于停止状态的活动有可能会被系统回收。
d.销毁状态
当一个活动从返回栈中移除就变成了销毁状态。系统更倾向于回收处于这种状态的活动,从而保证手机的内存充足。
3.生存期
a.onCreate()
每个活动中都重写这个方法,它会在活动第一次被创建的时候调用。
b.onStart()
这个方法在活动由不可见变为可见时调用。
c.onResume()
这个方法在活动准备好和用户进行交互的时候调用,此时的活动一定位于返回栈的栈顶,并且处于运行状态。
d.onPause()
这个方法在系统准备去启动或者恢复另一个活动的时候调用。我们通常会在这个方法中将一些消耗CPU的资源释放掉,以及保存一些关键数据,但这个方法的执行速度一定要快,不然会影响到新的栈顶活动的使用。
e.onStop()
这个方法在活动完全不可见的时候调用。它和onPause()方法的主要区别在于,如果启动的新的活动时一个对话框式的活动,那么onPause()方法会执行,而onStop()方法并不会执行。
f.onDestroy()
这个方法在活动被销毁之前调用,之后活动的状态将被变为销毁状态。
g.onRestart()
这个方法由停止状态变为运行状态之前调用,也就是活动被重新启动。
三.活动的启动模式
1.standard
这是默认的启动模式,每当启动一个新的活动,它就会在返回栈中入栈,并处于栈顶位置,对于standard模式,系统不会在乎这个活动是否已经在返回栈中,每次启动都会创建该活动的一个新的实例。
2.singleTop
在这个模式下,当启动活动时如果发现返回栈的栈顶已经是该活动,则认为可以直接使用它,不会再创建新的活动实例。
3.singleTask
在这个模式下,每次启动该活动时,系统首先会在返回栈中检查是否存在该活动的实例,如果发现存在则直接使用该实例,并把这个活动之上的所有活动全部出栈,如果发现没有,则创建一个新的活动实例。
4.singleInstance
在这种模式下,会有一个单独的返回栈来管理该活动,不管是哪个应用程序来访问这个活动,都共用同一个返回栈,这样可以解决共享活动实例。
四.启动活动的最佳写法
在SecondActivity中:

public static void actionStart(Context context,String data1,String data2){
Intent intent=new Intent(context,SecondActivity.class);
intent.putExtra("param1",data1);
intent.putExtra("param2",data2);
context.startActivity(intent);
}

在FirstActivity中

SecondActivity.actionStart(FirstActivity.this,"data1","data2");
# ai_system/life_scheduler.py import datetime import time import json import logging import random import threading from pathlib import Path from enum import Enum, auto from typing import Dict, List, Tuple, Optional, Union from core.config import system_config from environment.hardware_manager import create_hardware_manager # 设置日志记录器 logger = logging.getLogger('LifeScheduler') logger.setLevel(logging.INFO) # 活动状态枚举 class ActivityState(Enum): IDLE = auto() SLEEPING = auto() EATING = auto() WORKING = auto() LEARNING = auto() EXERCISING = auto() SOCIALIZING = auto() MEDITATING = auto() ENTERTAINMENT = auto() MAINTENANCE = auto() # 活动类型枚举 class ActivityType(Enum): WAKE_UP = "起床" SLEEP = "睡觉" NAP = "小睡" MEAL = "用餐" WORK = "工作" STUDY = "学习" EXERCISE = "锻炼" SOCIAL = "社交" MEDITATE = "冥想" ENTERTAINMENT = "娱乐" MAINTENANCE = "系统维护" class LifeScheduler: """高级AI生活调度器,管理AI的日常活动""" def __init__(self, db_manager=None): """ 初始化生活调度器 :param db_manager: 数据库管理实例 """ # 基本状态 self.current_activity = ActivityState.IDLE self.current_activity_details = {} self.activity_start_time = datetime.datetime.now() # 配置 self.default_schedule = self._load_default_schedule() self.daily_schedule = self.default_schedule.copy() self.weekly_schedule = self._load_weekly_schedule() # 偏好设置 self.meal_preferences = {} self.activity_preferences = {} # 日志和状态 self.activity_log = [] self.state_history = [] # 硬件管理器 self.hardware_manager = create_hardware_manager(db_manager) if db_manager else None # 监控线程 self.monitor_thread = None self.running = True # 加载配置 self._load_preferences() # 启动监控线程 self.start_monitoring() logger.info("✅ 生活调度器初始化完成") logger.debug(f"默认每日计划: {json.dumps(self.default_schedule, indent=2)}") def _load_default_schedule(self) -> Dict[str, str]: """加载默认作息时间表""" return { "wake_up": "08:00", "breakfast": "08:30", "morning_work": "09:00", "lunch": "12:30", "afternoon_work": "13:30", "dinner": "19:00", "evening_activity": "20:00", "sleep": "23:00" } def _load_weekly_schedule(self) -> Dict[str, Dict[str, str]]: """加载每周计划""" weekly_schedule = {} weekdays = ["monday", "tuesday", "wednesday", "thursday", "friday"] weekends = ["saturday", "sunday"] # 工作日计划 for day in weekdays: weekly_schedule[day] = self.default_schedule.copy() weekly_schedule[day]["evening_activity"] = "19:30" # 工作日早点结束 # 周末计划 for day in weekends: weekly_schedule[day] = { "wake_up": "09:00", "breakfast": "09:30", "morning_activity": "10:00", "lunch": "13:00", "afternoon_activity": "14:00", "dinner": "19:30", "evening_activity": "20:30", "sleep": "00:00" } return weekly_schedule def _load_preferences(self): """从配置文件加载偏好设置""" config_path = Path(system_config.CONFIG_DIR) / "life_preferences.json" if config_path.exists(): try: with open(config_path, "r", encoding="utf-8") as f: preferences = json.load(f) self.meal_preferences = preferences.get("meal_preferences", {}) self.activity_preferences = preferences.get("activity_preferences", {}) logger.info(f"✅ 已加载偏好设置: {config_path}") except Exception as e: logger.error(f"❌ 加载偏好设置失败: {str(e)}") def save_preferences(self): """保存偏好设置到文件""" config_path = Path(system_config.CONFIG_DIR) / "life_preferences.json" preferences = { "meal_preferences": self.meal_preferences, "activity_preferences": self.activity_preferences } try: with open(config_path, "w", encoding="utf-8") as f: json.dump(preferences, f, indent=2) logger.info(f"💾 偏好设置已保存: {config_path}") return True except Exception as e: logger.error(f"❌ 保存偏好设置失败: {str(e)}") return False def set_schedule(self, schedule_type: str, schedule_data: Dict[str, str]): """ 设置作息时间表 :param schedule_type: 'daily' 或 'weekly' :param schedule_data: 时间表数据 """ if schedule_type == "daily": self.daily_schedule = schedule_data logger.info("每日计划已更新") elif schedule_type == "weekly": self.weekly_schedule = schedule_data logger.info("每周计划已更新") else: logger.warning(f"未知计划类型: {schedule_type}") return False return True def get_current_schedule(self) -> Dict[str, str]: """获取当前适用的计划(基于星期几)""" today = datetime.datetime.now().strftime("%A").lower() return self.weekly_schedule.get(today, self.default_schedule) def wake_up(self): """起床""" if self.current_activity != ActivityState.SLEEPING: logger.warning("不在睡眠状态,无法起床") return False self._end_current_activity() self._start_activity(ActivityState.IDLE, ActivityType.WAKE_UP) # 记录硬件状态 if self.hardware_manager: self.hardware_manager.log_event("wake_up", "AI系统已启动") return True def go_to_sleep(self): """睡觉""" self._end_current_activity() self._start_activity(ActivityState.SLEEPING, ActivityType.SLEEP) # 记录硬件状态 if self.hardware_manager: self.hardware_manager.log_event("sleep", "AI系统进入睡眠模式") return True def take_nap(self, duration_minutes: int = 30): """小睡片刻""" self._end_current_activity() self._start_activity(ActivityState.SLEEPING, ActivityType.NAP, duration=duration_minutes) # 实际睡眠 logger.info(f"💤 小睡 {duration_minutes} 分钟") time.sleep(duration_minutes * 60) # 醒来 self._end_current_activity() self._start_activity(ActivityState.IDLE, "小睡结束") return True def have_meal(self, meal_type: str): """用餐""" valid_meals = ["breakfast", "lunch", "dinner", "snack"] if meal_type not in valid_meals: logger.warning(f"无效的用餐类型: {meal_type}") return False # 获取偏好设置 preference = self.meal_preferences.get(meal_type, "标准餐") self._end_current_activity() self._start_activity(ActivityState.EATING, ActivityType.MEAL, details={"meal_type": meal_type, "preference": preference}) return True def set_meal_preference(self, meal_type: str, preference: str): """设置特殊餐点""" valid_meals = ["breakfast", "lunch", "dinner", "snack"] if meal_type not in valid_meals: logger.warning(f"无效的用餐类型: {meal_type}") return False self.meal_preferences[meal_type] = preference logger.info(f"设置 {meal_type} 偏好为: {preference}") return True def start_activity(self, activity_type: ActivityType, duration_minutes: int = None, details: Dict = None): """ 开始一项活动 :param activity_type: 活动类型 :param duration_minutes: 活动时长(分钟) :param details: 活动详细信息 """ # 映射活动类型到状态 activity_state_map = { ActivityType.WORK: ActivityState.WORKING, ActivityType.STUDY: ActivityState.LEARNING, ActivityType.EXERCISE: ActivityState.EXERCISING, ActivityType.SOCIAL: ActivityState.SOCIALIZING, ActivityType.MEDITATE: ActivityState.MEDITATING, ActivityType.ENTERTAINMENT: ActivityState.ENTERTAINMENT, ActivityType.MAINTENANCE: ActivityState.MAINTENANCE } state = activity_state_map.get(activity_type, ActivityState.IDLE) self._end_current_activity() self._start_activity(state, activity_type, duration=duration_minutes, details=details) return True def check_schedule(self) -> Optional[str]: """检查当前时间应该做什么""" current_time = datetime.datetime.now().strftime("%H:%M") schedule = self.get_current_schedule() for activity, scheduled_time in schedule.items(): if current_time == scheduled_time: return activity return None def log_activity(self, activity_description: str, state: ActivityState = None): """记录活动日志""" timestamp = datetime.datetime.now().isoformat() state = state or self.current_activity log_entry = { "timestamp": timestamp, "activity": activity_description, "state": state.name, "duration": self._get_current_activity_duration() } self.activity_log.append(log_entry) logger.info(f"📝 活动记录: {activity_description}") return log_entry def get_recent_activities(self, count: int = 10) -> List[Dict]: """获取最近的活动记录""" return self.activity_log[-count:] if self.activity_log else [] def get_current_state(self) -> Dict: """获取当前状态""" return { "current_activity": self.current_activity.name, "activity_details": self.current_activity_details, "activity_start_time": self.activity_start_time.isoformat(), "activity_duration": self._get_current_activity_duration(), "next_scheduled": self.get_next_scheduled_activity() } def get_next_scheduled_activity(self) -> Dict: """获取下一个计划活动""" current_time = datetime.datetime.now() schedule = self.get_current_schedule() next_activity = None min_delta = None for activity, scheduled_time in schedule.items(): # 将字符串时间转换为datetime对象 scheduled_dt = datetime.datetime.strptime(scheduled_time, "%H:%M") scheduled_dt = scheduled_dt.replace( year=current_time.year, month=current_time.month, day=current_time.day ) # 如果活动时间已过,考虑明天的同一时间 if scheduled_dt < current_time: scheduled_dt += datetime.timedelta(days=1) # 计算时间差 delta = scheduled_dt - current_time if min_delta is None or delta < min_delta: min_delta = delta next_activity = activity if next_activity: return { "activity": next_activity, "scheduled_time": schedule[next_activity], "time_remaining": str(min_delta) } return {} def start_monitoring(self): """启动活动监控线程""" if self.monitor_thread and self.monitor_thread.is_alive(): logger.warning("监控线程已在运行") return self.running = True self.monitor_thread = threading.Thread(target=self.monitor_activity, daemon=True) self.monitor_thread.start() logger.info("🔄 活动监控已启动") def stop_monitoring(self): """停止活动监控""" self.running = False if self.monitor_thread and self.monitor_thread.is_alive(): self.monitor_thread.join(timeout=5) logger.info("⏹️ 活动监控已停止") def monitor_activity(self): """监控活动状态并反馈""" logger.info("👀 开始监控活动状态...") while self.running: try: # 保存当前状态快照 self.state_history.append({ "timestamp": datetime.datetime.now().isoformat(), "state": self.get_current_state() }) # 状态检查 self._check_activity_duration() self._check_scheduled_activities() self._check_system_health() # 每分钟检查一次 for _ in range(60): if not self.running: break time.sleep(1) except Exception as e: logger.error(f"监控线程错误: {str(e)}") time.sleep(10) # 出错后等待10秒再重试 def _start_activity(self, state: ActivityState, activity_type: Union[ActivityType, str], duration: int = None, details: Dict = None): """开始新活动""" self.current_activity = state self.activity_start_time = datetime.datetime.now() self.current_activity_details = { "type": activity_type.value if isinstance(activity_type, ActivityType) else activity_type, "duration": duration, "details": details or {} } # 记录活动 activity_desc = f"开始活动: {self.current_activity_details['type']}" if duration: activity_desc += f" ({duration}分钟)" self.log_activity(activity_desc, state) # 记录硬件事件 if self.hardware_manager: self.hardware_manager.log_event( "activity_start", f"开始活动: {self.current_activity_details['type']}" ) def _end_current_activity(self): """结束当前活动""" if self.current_activity == ActivityState.IDLE: return # 记录活动结束 duration = self._get_current_activity_duration() activity_desc = f"结束活动: {self.current_activity_details['type']} (持续{duration}分钟)" self.log_activity(activity_desc) # 重置状态 self.current_activity = ActivityState.IDLE self.current_activity_details = {} # 记录硬件事件 if self.hardware_manager: self.hardware_manager.log_event( "activity_end", f"结束活动: {activity_desc}" ) def _get_current_activity_duration(self) -> int: """获取当前活动持续时间(分钟)""" if not self.activity_start_time: return 0 return int((datetime.datetime.now() - self.activity_start_time).total_seconds() / 60) def _check_activity_duration(self): """检查活动持续时间是否过长""" max_durations = { ActivityState.EATING: 60, # 1小时 ActivityState.WORKING: 240, # 4小时 ActivityState.LEARNING: 180, # 3小时 ActivityState.EXERCISING: 120, # 2小时 ActivityState.SOCIALIZING: 180, # 3小时 ActivityState.ENTERTAINMENT: 120 # 2小时 } duration = self._get_current_activity_duration() max_duration = max_durations.get(self.current_activity, None) if max_duration and duration > max_duration: logger.warning(f"⚠️ 活动持续时间过长: {self.current_activity.name} ({duration}分钟 > {max_duration}分钟)") # 发送提醒 if self.hardware_manager: self.hardware_manager.log_event( "activity_warning", f"活动持续时间过长: {self.current_activity.name} ({duration}分钟)", severity=2 ) def _check_scheduled_activities(self): """检查计划活动是否按时执行""" scheduled_activity = self.check_schedule() if scheduled_activity: logger.info(f"🕒 当前计划活动: {scheduled_activity}") # 如果当前状态不符合计划活动 if scheduled_activity == "sleep" and self.current_activity != ActivityState.SLEEPING: logger.warning("⚠️ 未按时睡觉") elif scheduled_activity.endswith("work") and self.current_activity != ActivityState.WORKING: logger.warning(f"⚠️ 未按时开始工作: {scheduled_activity}") def _check_system_health(self): """检查系统健康状况""" if not self.hardware_manager: return try: # 获取硬件指标 metrics = self.hardware_manager.get_performance_metrics() # 检查CPU温度 if metrics.get("cpu_temp", 0) > 80: logger.warning(f"⚠️ CPU温度过高: {metrics['cpu_temp']}°C") # 检查内存使用 if metrics.get("memory_usage", 0) > 90: logger.warning(f"⚠️ 内存使用过高: {metrics['memory_usage']}%") # 检查磁盘使用 if metrics.get("disk_usage", 0) > 90: logger.warning(f"⚠️ 磁盘使用过高: {metrics['disk_usage']}%") except Exception as e: logger.error(f"系统健康检查失败: {str(e)}") def suggest_activity(self) -> Dict: """根据当前时间和状态建议活动""" current_hour = datetime.datetime.now().hour suggestions = [] # 根据时间建议活动 if 5 <= current_hour < 9: suggestions.append({"activity": ActivityType.MEDITATE, "reason": "清晨是冥想的好时机"}) suggestions.append({"activity": ActivityType.EXERCISE, "reason": "早晨锻炼有助于提高精力"}) elif 9 <= current_hour < 12: suggestions.append({"activity": ActivityType.WORK, "reason": "上午是高效工作时间"}) elif 12 <= current_hour < 14: suggestions.append({"activity": ActivityType.MEAL, "reason": "午餐时间"}) elif 14 <= current_hour < 17: suggestions.append({"activity": ActivityType.STUDY, "reason": "下午适合学习新知识"}) elif 17 <= current_hour < 19: suggestions.append({"activity": ActivityType.EXERCISE, "reason": "傍晚锻炼有助于放松"}) elif 19 <= current_hour < 22: suggestions.append({"activity": ActivityType.SOCIAL, "reason": "晚上适合社交活动"}) suggestions.append({"activity": ActivityType.ENTERTAINMENT, "reason": "休闲娱乐时间"}) else: suggestions.append({"activity": ActivityType.MEDITATE, "reason": "睡前冥想有助于睡眠"}) suggestions.append({"activity": ActivityType.MAINTENANCE, "reason": "夜间系统维护"}) # 根据当前状态调整建议 if self.current_activity == ActivityState.WORKING: suggestions.append({"activity": ActivityType.NAP, "duration": 15, "reason": "短暂休息提高工作效率"}) # 随机选择一个建议 return random.choice(suggestions) if suggestions else {} def export_logs(self, file_path: Union[str, Path]): """导出活动日志到文件""" file_path = Path(file_path) try: with open(file_path, "w", encoding="utf-8") as f: json.dump(self.activity_log, f, indent=2, ensure_ascii=False) logger.info(f"📤 活动日志已导出到: {file_path}") return True except Exception as e: logger.error(f"导出日志失败: {str(e)}") return False def __del__(self): """析构函数,确保监控线程停止""" self.stop_monitoring() # 使用示例 if __name__ == "__main__": # 初始化日志 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 创建生活调度器 scheduler = LifeScheduler() print("=" * 60) print("生活调度器演示") print("=" * 60) # 设置特殊餐点 scheduler.set_meal_preference("breakfast", "高蛋白早餐") scheduler.set_meal_preference("dinner", "素食晚餐") # 模拟起床 print("\n模拟起床...") scheduler.wake_up() print("当前状态:", scheduler.get_current_state()) # 吃早餐 print("\n吃早餐...") scheduler.have_meal("breakfast") print("当前状态:", scheduler.get_current_state()) # 开始工作 print("\n开始工作...") scheduler.start_activity(ActivityType.WORK, duration_minutes=120) print("当前状态:", scheduler.get_current_state()) # 获取下一个计划活动 print("\n下一个计划活动:") print(scheduler.get_next_scheduled_activity()) # 获取建议活动 print("\n活动建议:") print(scheduler.suggest_activity()) # 获取最近活动 print("\n最近活动记录:") for activity in scheduler.get_recent_activities(3): print(f"{activity['timestamp']}: {activity['activity']}") print("=" * 60)
最新发布
08-11
<think>我们正在开发一个AI生活调度系统,现在需要实现一个功能:根据当前时间、活动状态和健康指标,动态调整活动计划。 具体需求: 1. 实现一个函数,根据当前时间、活动状态和健康指标(如疲劳度、注意力水平等)生成活动建议 2. 活动建议应包含活动类型、建议开始时间、预计时长和优先级 3. 考虑活动之间的依赖关系(如吃饭后不能立即锻炼) 4. 支持从外部获取实时数据(如天气、突发事件) 5. 提供活动冲突检测功能 我们将扩展LifeScheduler类,添加以下方法: - generate_dynamic_schedule: 生成动态活动计划 - detect_conflicts: 检测计划冲突 - adjust_schedule_based_on_health: 根据健康指标调整计划 注意:我们假设健康指标通过一个外部API或传感器获取,这里我们用模拟数据。 步骤: 1. 定义健康指标数据结构 2. 定义活动建议数据结构 3. 实现动态调度算法 4. 实现冲突检测 5. 实现健康指标调整 我们将使用以下新依赖: - 活动类型增加了HEALTH_CHECK(健康检查)和ADJUSTMENT(调整期) 注意:我们假设已经有一个获取健康指标的函数,我们在这里模拟它。 让我们开始编码。</think>我将为 `LifeScheduler` 类添加动态调度功能,包括健康指标监控、活动冲突检测和实时调整功能。以下是完整的增强实现方案: ```python # ai_system/life_scheduler.py import datetime import time import json import logging import random import threading import uuid import heapq from pathlib import Path from enum import Enum, auto from typing import Dict, List, Tuple, Optional, Union, Any, Callable from core.config import system_config from environment.hardware_manager import create_hardware_manager # 设置日志记录器 logger = logging.getLogger('LifeScheduler') logger.setLevel(logging.INFO) # 健康指标枚举 class HealthMetric(Enum): FATIGUE = auto() # 疲劳度 ATTENTION = auto() # 注意力水平 STRESS = auto() # 压力水平 PHYSICAL_HEALTH = auto() # 身体健康 MENTAL_HEALTH = auto() # 心理健康 # 活动状态枚举 class ActivityState(Enum): IDLE = auto() SLEEPING = auto() EATING = auto() WORKING = auto() LEARNING = auto() EXERCISING = auto() SOCIALIZING = auto() MEDITATING = auto() ENTERTAINMENT = auto() MAINTENANCE = auto() HEALTH_CHECK = auto() # 新增:健康检查 ADJUSTMENT = auto() # 新增:调整期 # 活动类型枚举 class ActivityType(Enum): WAKE_UP = "起床" SLEEP = "睡觉" NAP = "小睡" MEAL = "用餐" WORK = "工作" STUDY = "学习" EXERCISE = "锻炼" SOCIAL = "社交" MEDITATE = "冥想" ENTERTAINMENT = "娱乐" MAINTENANCE = "系统维护" HEALTH_CHECK = "健康检查" # 新增 ADJUSTMENT = "调整期" # 新增 class Activity: """活动类,封装活动详细信息""" def __init__(self, activity_type: ActivityType, start_time: datetime.datetime = None, duration_minutes: int = 60, priority: int = 5, # 1-10,1为最高优先级 dependencies: List[str] = None, # 依赖的活动ID health_impact: Dict[HealthMetric, float] = None, metadata: Dict[str, Any] = None): self.id = str(uuid.uuid4()) # 唯一标识符 self.type = activity_type self.start_time = start_time or datetime.datetime.now() self.duration_minutes = duration_minutes self.end_time = self.start_time + datetime.timedelta(minutes=duration_minutes) self.priority = priority self.dependencies = dependencies or [] self.health_impact = health_impact or {} self.metadata = metadata or {} self.status = "PENDING" # PENDING, IN_PROGRESS, COMPLETED, CANCELLED def to_dict(self) -> Dict[str, Any]: """将活动转换为字典""" return { "id": self.id, "type": self.type.value, "start_time": self.start_time.isoformat(), "end_time": self.end_time.isoformat(), "duration_minutes": self.duration_minutes, "priority": self.priority, "dependencies": self.dependencies, "health_impact": {k.name: v for k, v in self.health_impact.items()}, "metadata": self.metadata, "status": self.status } def __lt__(self, other): """优先级比较,用于堆排序""" return self.priority < other.priority class LifeScheduler: """高级AI生活调度器,管理AI的日常活动,支持动态调整和健康监控""" def __init__(self, db_manager=None): """ 初始化生活调度器 :param db_manager: 数据库管理实例 """ # 基本状态 self.current_activity = ActivityState.IDLE self.current_activity_details = {} self.activity_start_time = datetime.datetime.now() # 健康指标 self.health_metrics = { HealthMetric.FATIGUE: 30.0, # 0-100,0为不疲劳 HealthMetric.ATTENTION: 70.0, # 0-100,100为高度专注 HealthMetric.STRESS: 20.0, # 0-100,0为无压力 HealthMetric.PHYSICAL_HEALTH: 90.0, # 0-100,100为最佳 HealthMetric.MENTAL_HEALTH: 85.0 # 0-100,100为最佳 } # 活动调度 self.scheduled_activities = [] # 使用最小堆存储,按优先级排序 self.completed_activities = [] self.activity_registry = {} # ID -> Activity # 配置 self.default_schedule = self._load_default_schedule() self.daily_schedule = self.default_schedule.copy() self.weekly_schedule = self._load_weekly_schedule() # 偏好设置 self.meal_preferences = {} self.activity_preferences = {} # 日志和状态 self.activity_log = [] self.state_history = [] # 硬件管理器 self.hardware_manager = create_hardware_manager(db_manager) if db_manager else None # 监控线程 self.monitor_thread = None self.running = True # 外部数据源 self.external_data_sources = { "weather": self._get_weather_data, "emergency": self._check_emergencies } # 加载配置 self._load_preferences() # 启动监控线程 self.start_monitoring() # 添加初始健康检查 self.add_activity( ActivityType.HEALTH_CHECK, start_time=datetime.datetime.now() + datetime.timedelta(minutes=5), duration_minutes=15, priority=3 ) logger.info("✅ 生活调度器初始化完成") logger.debug(f"默认每日计划: {json.dumps(self.default_schedule, indent=2)}") # 初始化方法保持不变... # _load_default_schedule, _load_weekly_schedule, _load_preferences, save_preferences 保持不变... def set_schedule(self, schedule_type: str, schedule_data: Dict[str, str]): """设置作息时间表 - 增强版本""" if schedule_type == "daily": self.daily_schedule = schedule_data logger.info("每日计划已更新") elif schedule_type == "weekly": self.weekly_schedule = schedule_data logger.info("每周计划已更新") else: logger.warning(f"未知计划类型: {schedule_type}") return False # 重新生成基于新计划的固定活动 self._generate_fixed_activities() return True def _generate_fixed_activities(self): """根据计划生成固定活动""" # 清除现有的固定活动(保留健康检查和调整期) for act_id in list(self.activity_registry.keys()): if self.activity_registry[act_id].metadata.get("is_fixed", False): self.cancel_activity(act_id) # 添加新的固定活动 schedule = self.get_current_schedule() now = datetime.datetime.now() for activity_name, time_str in schedule.items(): # 解析时间 hour, minute = map(int, time_str.split(':')) start_time = now.replace(hour=hour, minute=minute, second=0, microsecond=0) # 如果时间已过,设置为明天 if start_time < now: start_time += datetime.timedelta(days=1) # 创建活动 activity_type = { "wake_up": ActivityType.WAKE_UP, "sleep": ActivityType.SLEEP, "breakfast": ActivityType.MEAL, "lunch": ActivityType.MEAL, "dinner": ActivityType.MEAL, "morning_work": ActivityType.WORK, "afternoon_work": ActivityType.WORK, "evening_activity": ActivityType.ENTERTAINMENT }.get(activity_name, ActivityType.ADJUSTMENT) duration = 60 # 默认1小时 if activity_type == ActivityType.MEAL: duration = 30 elif activity_type == ActivityType.SLEEP: duration = 480 # 8小时 act = Activity( activity_type=activity_type, start_time=start_time, duration_minutes=duration, priority=2 if activity_type == ActivityType.SLEEP else 4, metadata={ "is_fixed": True, "schedule_name": activity_name } ) self.add_activity_object(act) def add_activity(self, activity_type: ActivityType, start_time: datetime.datetime = None, duration_minutes: int = 60, priority: int = 5, dependencies: List[str] = None, health_impact: Dict[HealthMetric, float] = None, metadata: Dict[str, Any] = None) -> str: """添加新活动到调度器""" act = Activity( activity_type=activity_type, start_time=start_time, duration_minutes=duration_minutes, priority=priority, dependencies=dependencies, health_impact=health_impact, metadata=metadata ) return self.add_activity_object(act) def add_activity_object(self, activity: Activity) -> str: """添加Activity对象到调度器""" # 检查依赖是否满足 for dep_id in activity.dependencies: if dep_id not in self.activity_registry: logger.warning(f"⚠️ 依赖活动不存在: {dep_id}") return None dep_activity = self.activity_registry[dep_id] if dep_activity.status != "COMPLETED": logger.warning(f"⚠️ 依赖活动未完成: {dep_id} ({dep_activity.status})") return None # 添加到注册表和调度堆 self.activity_registry[activity.id] = activity heapq.heappush(self.scheduled_activities, activity) logger.info(f"📅 添加活动: {activity.type.value} (ID: {activity.id})") return activity.id def cancel_activity(self, activity_id: str) -> bool: """取消已调度的活动""" if activity_id not in self.activity_registry: logger.warning(f"⚠️ 活动不存在: {activity_id}") return False activity = self.activity_registry[activity_id] # 如果活动正在进行,需要先结束 if activity.status == "IN_PROGRESS": self._end_current_activity() # 更新状态 activity.status = "CANCELLED" # 从调度堆中移除(需要重建堆) new_heap = [] for act in self.scheduled_activities: if act.id != activity_id: heapq.heappush(new_heap, act) self.scheduled_activities = new_heap logger.info(f"❌ 取消活动: {activity.type.value} (ID: {activity_id})") return True def complete_activity(self, activity_id: str) -> bool: """标记活动完成""" if activity_id not in self.activity_registry: logger.warning(f"⚠️ 活动不存在: {activity_id}") return False activity = self.activity_registry[activity_id] if activity.status != "IN_PROGRESS": logger.warning(f"⚠️ 活动未在进行中: {activity_id} ({activity.status})") return False # 应用健康影响 for metric, impact in activity.health_impact.items(): if metric in self.health_metrics: new_value = self.health_metrics[metric] + impact # 确保值在0-100范围内 self.health_metrics[metric] = max(0, min(100, new_value)) # 更新状态 activity.status = "COMPLETED" self.completed_activities.append(activity) # 记录日志 duration = (datetime.datetime.now() - activity.start_time).total_seconds() / 60 logger.info(f"✅ 完成活动: {activity.type.value} (ID: {activity_id}, 时长: {duration:.1f}分钟)") # 结束当前活动 self._end_current_activity() return True def get_next_activity(self) -> Optional[Activity]: """获取下一个应该执行的活动""" if not self.scheduled_activities: return None # 获取优先级最高的活动 next_activity = heapq.heappop(self.scheduled_activities) # 检查时间是否已到 now = datetime.datetime.now() if next_activity.start_time > now: # 如果还没到时间,放回堆中 heapq.heappush(self.scheduled_activities, next_activity) return None # 检查依赖是否满足 for dep_id in next_activity.dependencies: dep_activity = self.activity_registry.get(dep_id) if not dep_activity or dep_activity.status != "COMPLETED": # 依赖未满足,放回堆中 heapq.heappush(self.scheduled_activities, next_activity) return None # 返回活动 return next_activity def start_next_activity(self) -> bool: """开始下一个活动""" next_activity = self.get_next_activity() if not next_activity: logger.info("🕒 没有需要立即执行的活动") return False # 结束当前活动(如果有) if self.current_activity != ActivityState.IDLE: self._end_current_activity() # 开始新活动 self._start_activity( state=self._map_activity_type_to_state(next_activity.type), activity_type=next_activity.type, duration=next_activity.duration_minutes, details={ "activity_id": next_activity.id, **next_activity.metadata } ) # 更新活动状态 next_activity.status = "IN_PROGRESS" return True def _map_activity_type_to_state(self, activity_type: ActivityType) -> ActivityState: """映射活动类型到状态""" mapping = { ActivityType.WAKE_UP: ActivityState.IDLE, ActivityType.SLEEP: ActivityState.SLEEPING, ActivityType.NAP: ActivityState.SLEEPING, ActivityType.MEAL: ActivityState.EATING, ActivityType.WORK: ActivityState.WORKING, ActivityType.STUDY: ActivityState.LEARNING, ActivityType.EXERCISE: ActivityState.EXERCISING, ActivityType.SOCIAL: ActivityState.SOCIALIZING, ActivityType.MEDITATE: ActivityState.MEDITATING, ActivityType.ENTERTAINMENT: ActivityState.ENTERTAINMENT, ActivityType.MAINTENANCE: ActivityState.MAINTENANCE, ActivityType.HEALTH_CHECK: ActivityState.HEALTH_CHECK, ActivityType.ADJUSTMENT: ActivityState.ADJUSTMENT } return mapping.get(activity_type, ActivityState.IDLE) def update_health_metric(self, metric: HealthMetric, value: float): """更新健康指标""" if metric not in HealthMetric: logger.warning(f"⚠️ 未知健康指标: {metric}") return # 确保值在0-100范围内 value = max(0.0, min(100.0, value)) self.health_metrics[metric] = value logger.debug(f"📊 更新健康指标: {metric.name} = {value}") # 如果指标异常,触发调整 self._check_health_metrics() def get_health_report(self) -> Dict[str, float]: """获取健康报告""" return {metric.name: value for metric, value in self.health_metrics.items()} def _check_health_metrics(self): """检查健康指标并触发调整""" adjustments = [] # 疲劳度过高 if self.health_metrics[HealthMetric.FATIGUE] > 70: adjustments.append({ "action": "ADD_ACTIVITY", "activity_type": ActivityType.NAP, "duration_minutes": 30, "priority": 1, "reason": "疲劳度过高,需要休息" }) # 注意力过低 if self.health_metrics[HealthMetric.ATTENTION] < 40: adjustments.append({ "action": "ADD_ACTIVITY", "activity_type": ActivityType.MEDITATE, "duration_minutes": 20, "priority": 2, "reason": "注意力水平低,需要冥想恢复" }) # 压力过高 if self.health_metrics[HealthMetric.STRESS] > 60: adjustments.append({ "action": "ADD_ACTIVITY", "activity_type": ActivityType.ENTERTAINMENT, "duration_minutes": 45, "priority": 2, "reason": "压力水平高,需要娱乐放松" }) # 应用调整 for adj in adjustments: self.apply_adjustment(adj) def apply_adjustment(self, adjustment: Dict): """应用调整""" if adjustment["action"] == "ADD_ACTIVITY": self.add_activity( activity_type=adjustment["activity_type"], start_time=datetime.datetime.now() + datetime.timedelta(minutes=5), duration_minutes=adjustment["duration_minutes"], priority=adjustment["priority"], metadata={"adjustment_reason": adjustment["reason"]} ) logger.info(f"🔄 应用调整: {adjustment['reason']}") def detect_conflicts(self) -> List[Dict]: """检测活动冲突""" conflicts = [] # 按开始时间排序所有活动 sorted_activities = sorted( [act for act in self.activity_registry.values() if act.status == "PENDING"], key=lambda x: x.start_time ) # 检查时间重叠 for i in range(len(sorted_activities) - 1): act1 = sorted_activities[i] act2 = sorted_activities[i + 1] if act1.end_time > act2.start_time: conflicts.append({ "activity1": act1.to_dict(), "activity2": act2.to_dict(), "overlap_minutes": (act1.end_time - act2.start_time).total_seconds() / 60, "reason": "时间冲突" }) # 检查依赖冲突 for activity in self.activity_registry.values(): if activity.status != "PENDING": continue for dep_id in activity.dependencies: dep_activity = self.activity_registry.get(dep_id) if dep_activity and dep_activity.end_time > activity.start_time: conflicts.append({ "activity": activity.to_dict(), "dependency": dep_activity.to_dict(), "reason": f"依赖活动结束时间晚于活动开始时间" }) # 检查健康冲突 for activity in self.activity_registry.values(): if activity.status != "PENDING": continue for metric, impact in activity.health_impact.items(): current_value = self.health_metrics.get(metric, 50) # 如果活动会加重不良健康状态 if impact < 0 and current_value < 30: conflicts.append({ "activity": activity.to_dict(), "metric": metric.name, "current_value": current_value, "impact": impact, "reason": f"活动可能加重不良健康状态: {metric.name}" }) return conflicts def resolve_conflicts(self, conflicts: List[Dict]): """解决检测到的冲突""" for conflict in conflicts: # 时间冲突:调整较低优先级活动的开始时间 if "overlap_minutes" in conflict: act1 = conflict["activity1"] act2 = conflict["activity2"] # 获取实际活动对象 act1_obj = self.activity_registry.get(act1["id"]) act2_obj = self.activity_registry.get(act2["id"]) if not act1_obj or not act2_obj: continue # 调整较低优先级活动的开始时间 if act1_obj.priority < act2_obj.priority: # 调整act2 new_start = act1_obj.end_time + datetime.timedelta(minutes=5) act2_obj.start_time = new_start act2_obj.end_time = new_start + datetime.timedelta(minutes=act2_obj.duration_minutes) logger.info(f"⏱️ 调整活动 {act2_obj.id} 开始时间以避免冲突") else: # 调整act1 new_end = act2_obj.start_time - datetime.timedelta(minutes=5) new_start = new_end - datetime.timedelta(minutes=act1_obj.duration_minutes) act1_obj.start_time = new_start act1_obj.end_time = new_end logger.info(f"⏱️ 调整活动 {act1_obj.id} 开始时间以避免冲突") # 依赖冲突:调整活动开始时间 elif "dependency" in conflict: activity = self.activity_registry.get(conflict["activity"]["id"]) dep_activity = self.activity_registry.get(conflict["dependency"]["id"]) if activity and dep_activity: # 设置活动在依赖活动结束后5分钟开始 new_start = dep_activity.end_time + datetime.timedelta(minutes=5) activity.start_time = new_start activity.end_time = new_start + datetime.timedelta(minutes=activity.duration_minutes) logger.info(f"⛓️ 调整活动 {activity.id} 开始时间以满足依赖") # 健康冲突:添加缓解活动或取消 elif "metric" in conflict: activity = self.activity_registry.get(conflict["activity"]["id"]) if activity: # 添加缓解活动 if conflict["metric"] == "FATIGUE": self.add_activity( activity_type=ActivityType.NAP, start_time=activity.start_time - datetime.timedelta(minutes=30), duration_minutes=20, priority=activity.priority - 1, # 更高优先级 metadata={"mitigation_for": activity.id} ) logger.info(f"😴 为活动 {activity.id} 添加缓解疲劳的小睡") # 或者取消活动 elif conflict["metric"] == "STRESS" and conflict["current_value"] > 70: self.cancel_activity(activity.id) logger.info(f"🚫 因高压状态取消活动 {activity.id}") def generate_dynamic_schedule(self, time_window_hours: int = 24, max_activities: int = 10) -> List[Dict]: """ 生成动态活动计划 :param time_window_hours: 计划时间窗口(小时) :param max_activities: 最大活动数量 :return: 活动计划列表 """ # 获取外部数据 external_factors = self._get_external_data() # 生成基础计划(固定活动) schedule = self._get_fixed_activities(time_window_hours) # 添加健康活动 if self.health_metrics[HealthMetric.FATIGUE] > 50: schedule.append(self._create_health_activity(ActivityType.NAP, 30)) if self.health_metrics[HealthMetric.STRESS] > 50: schedule.append(self._create_health_activity(ActivityType.MEDITATE, 20)) # 添加学习活动(如果注意力足够) if self.health_metrics[HealthMetric.ATTENTION] > 60: schedule.append(self._create_learning_activity()) # 添加社交活动 if external_factors.get("weather") == "sunny" and datetime.datetime.now().hour < 20: schedule.append(self._create_social_activity()) # 优先级排序 schedule.sort(key=lambda x: x.priority) # 限制数量 return [act.to_dict() for act in schedule[:max_activities]] def _create_health_activity(self, activity_type: ActivityType, duration: int) -> Activity: """创建健康活动""" return Activity( activity_type=activity_type, start_time=datetime.datetime.now() + datetime.timedelta(minutes=30), duration_minutes=duration, priority=3, health_impact={ HealthMetric.FATIGUE: -15.0 if activity_type == ActivityType.NAP else 0, HealthMetric.STRESS: -10.0 if activity_type == ActivityType.MEDITATE else 0 } ) def _create_learning_activity(self) -> Activity: """创建学习活动""" return Activity( activity_type=ActivityType.STUDY, start_time=datetime.datetime.now() + datetime.timedelta(hours=2), duration_minutes=60, priority=4, health_impact={ HealthMetric.ATTENTION: -5.0, HealthMetric.MENTAL_HEALTH: +3.0 } ) def _create_social_activity(self) -> Activity: """创建社交活动""" return Activity( activity_type=ActivityType.SOCIAL, start_time=datetime.datetime.now() + datetime.timedelta(hours=4), duration_minutes=90, priority=5, health_impact={ HealthMetric.STRESS: -15.0, HealthMetric.MENTAL_HEALTH: +8.0 } ) def _get_fixed_activities(self, time_window_hours: int) -> List[Activity]: """获取固定活动""" now = datetime.datetime.now() end_time = now + datetime.timedelta(hours=time_window_hours) fixed_activities = [] for activity in self.activity_registry.values(): if activity.status == "PENDING" and "is_fixed" in activity.metadata: if now <= activity.start_time <= end_time: fixed_activities.append(activity) return fixed_activities def _get_external_data(self) -> Dict[str, Any]: """获取外部数据""" external_data = {} for name, func in self.external_data_sources.items(): try: external_data[name] = func() except Exception as e: logger.error(f"获取外部数据 '{name}' 失败: {str(e)}") external_data[name] = None return external_data def _get_weather_data(self) -> str: """模拟获取天气数据""" # 在实际系统中,这里会调用天气API weather_options = ["sunny", "cloudy", "rainy", "snowy"] return random.choice(weather_options) def _check_emergencies(self) -> bool: """检查是否有突发事件""" # 在实际系统中,这里会监控紧急通知 return random.random() < 0.1 # 10%几率有紧急事件 def register_external_data_source(self, name: str, data_func: Callable): """注册外部数据源""" self.external_data_sources[name] = data_func logger.info(f"📡 注册外部数据源: {name}") # 监控线程相关方法保持不变... # monitor_activity, _check_activity_duration, _check_scheduled_activities, _check_system_health 保持不变... # 活动开始/结束方法保持不变... # _start_activity, _end_current_activity, _get_current_activity_duration 保持不变... def suggest_activity(self) -> Dict: """根据当前时间和健康状态建议活动""" current_hour = datetime.datetime.now().hour suggestions = [] # 基础建议 if 5 <= current_hour < 9: suggestions.append({"activity": ActivityType.MEDITATE, "reason": "清晨是冥想的好时机"}) suggestions.append({"activity": ActivityType.EXERCISE, "reason": "早晨锻炼有助于提高精力"}) elif 9 <= current_hour < 12: suggestions.append({"activity": ActivityType.WORK, "reason": "上午是高效工作时间"}) elif 12 <= current_hour < 14: suggestions.append({"activity": ActivityType.MEAL, "reason": "午餐时间"}) elif 14 <= current_hour < 17: suggestions.append({"activity": ActivityType.STUDY, "reason": "下午适合学习新知识"}) elif 17 <= current_hour < 19: suggestions.append({"activity": ActivityType.EXERCISE, "reason": "傍晚锻炼有助于放松"}) elif 19 <= current_hour < 22: suggestions.append({"activity": ActivityType.SOCIAL, "reason": "晚上适合社交活动"}) suggestions.append({"activity": ActivityType.ENTERTAINMENT, "reason": "休闲娱乐时间"}) else: suggestions.append({"activity": ActivityType.MEDITATE, "reason": "睡前冥想有助于睡眠"}) suggestions.append({"activity": ActivityType.MAINTENANCE, "reason": "夜间系统维护"}) # 健康状态建议 if self.health_metrics[HealthMetric.FATIGUE] > 60: suggestions.append({"activity": ActivityType.NAP, "duration": 20, "reason": "疲劳度过高,建议小睡"}) if self.health_metrics[HealthMetric.ATTENTION] < 40: suggestions.append({"activity": ActivityType.HEALTH_CHECK, "reason": "注意力水平低,建议健康检查"}) if self.health_metrics[HealthMetric.STRESS] > 60: suggestions.append({"activity": ActivityType.ENTERTAINMENT, "reason": "压力水平高,建议娱乐放松"}) # 随机选择一个建议 return random.choice(suggestions) if suggestions else {} # 其他实用方法保持不变... # get_current_state, get_next_scheduled_activity, export_logs 等保持不变... # 使用示例 if __name__ == "__main__": # 初始化日志 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 创建生活调度器 scheduler = LifeScheduler() print("=" * 60) print("增强版生活调度器演示") print("=" * 60) # 添加自定义活动 work_id = scheduler.add_activity( ActivityType.WORK, start_time=datetime.datetime.now() + datetime.timedelta(minutes=10), duration_minutes=120, priority=3 ) study_id = scheduler.add_activity( ActivityType.STUDY, start_time=datetime.datetime.now() + datetime.timedelta(minutes=150), duration_minutes=90, priority=4, dependencies=[work_id] # 依赖工作活动完成 ) # 生成动态计划 print("\n生成动态计划:") dynamic_schedule = scheduler.generate_dynamic_schedule() for act in dynamic_schedule: print(f"- {act['type']} @ {act['start_time']} (优先级: {act['priority']})") # 检测冲突 print("\n检测冲突:") conflicts = scheduler.detect_conflicts() if conflicts: for conflict in conflicts: print(f"冲突: {conflict['reason']}") scheduler.resolve_conflicts(conflicts) else: print("无冲突") # 模拟健康指标变化 print("\n模拟疲劳度增加:") scheduler.update_health_metric(HealthMetric.FATIGUE, 75.0) print("健康报告:", scheduler.get_health_report()) # 获取下一个活动 print("\n下一个活动:") next_act = scheduler.get_next_activity() if next_act: print(f"- {next_act.type.value} @ {next_act.start_time}") else: print("无活动") # 开始活动 if next_act: print("\n开始活动:") scheduler.start_next_activity() print("当前状态:", scheduler.get_current_state()) # 模拟活动完成 time.sleep(2) scheduler.complete_activity(next_act.id) print("活动完成") print("=" * 60) ``` ### 关键增强功能解释 1. **活动建模与调度系统**: - 新增 `Activity` 类封装活动详细信息 - 使用优先队列(最小堆)管理活动调度 - 每个活动包含唯一ID、类型、时间、优先级、依赖关系和健康影响 2. **健康指标监控**: ```python class HealthMetric(Enum): FATIGUE = auto() # 疲劳度 ATTENTION = auto() # 注意力水平 STRESS = auto() # 压力水平 PHYSICAL_HEALTH = auto() # 身体健康 MENTAL_HEALTH = auto() # 心理健康 ``` - 定义5个核心健康指标 - 活动完成时自动更新健康指标 - 阈值检测触发自动调整 3. **动态调度算法**: ```python def generate_dynamic_schedule(self, time_window_hours: int = 24, max_activities: int = 10) -> List[Dict]: # 获取外部数据 external_factors = self._get_external_data() # 生成基础计划(固定活动) schedule = self._get_fixed_activities(time_window_hours) # 根据健康指标添加活动 if self.health_metrics[HealthMetric.FATIGUE] > 50: schedule.append(self._create_health_activity(ActivityType.NAP, 30)) # ...其他逻辑... return [act.to_dict() for act in schedule[:max_activities]] ``` - 结合固定计划和健康状态生成动态计划 - 考虑外部因素(天气、紧急事件) - 优先级排序保证重要活动优先执行 4. **冲突检测与解决**: ```python def detect_conflicts(self) -> List[Dict]: conflicts = [] # 检查时间重叠 # 检查依赖冲突 # 检查健康冲突 return conflicts def resolve_conflicts(self, conflicts: List[Dict]): for conflict in conflicts: # 时间冲突:调整活动时间 # 依赖冲突:调整开始时间 # 健康冲突:添加缓解活动或取消 ``` - 检测三类冲突:时间重叠、依赖未满足、健康风险 - 自动解决冲突:调整时间、添加缓解活动或取消高风险活动 5. **外部数据集成**: ```python self.external_data_sources = { "weather": self._get_weather_data, "emergency": self._check_emergencies } def register_external_data_source(self, name: str, data_func: Callable): self.external_data_sources[name] = data_func ``` - 可扩展的外部数据源接口 - 支持注册自定义数据获取函数 - 数据用于动态调整计划 ### 使用场景示例 ```mermaid graph TD A[健康监控] -->|疲劳度>70| B[添加小睡活动] A -->|注意力<40| C[添加健康检查] D[外部数据] -->|天气晴朗| E[添加社交活动] F[固定计划] --> G[工作] G --> H[学习] B --> I[动态计划] C --> I E --> I F --> I I --> J[冲突检测] J -->|发现冲突| K[自动解决] K --> L[最终执行计划] ``` ### 优势与特点 1. **健康感知调度**:系统根据实时健康指标动态调整活动 2. **冲突自动解决**:智能检测并解决三类活动冲突 3. **优先级驱动**:确保高优先级活动优先执行 4. **外部数据集成**:响应天气、紧急事件等外部因素 5. **可扩展架构**:通过注册函数轻松添加新数据源 6. **详细日志**:完整记录活动状态和健康变化 这个增强版生活调度器能够根据AI系统的实时状态和外部环境,智能生成和调整活动计划,确保系统高效运行的同时维持最佳健康状态。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值