在HarmonyOS应用开发中，我们常常需要处理看似独立实则紧密相关的技术难题。今天，我将通过一个智能日程管理应用的实战案例，分享两个关键问题的解决方案：日历权限的精细化管理和Web组件长截图的实现。这两个问题分别对应着系统权限交互和用户体验优化的核心挑战。

一、应用场景：智能日程管理器的双重需求

想象一下，你正在开发一款智能日程管理应用。用户可以通过AI助手创建智能提醒事项，系统会自动分析会议内容、提取关键信息并生成日程卡片。但当用户想要将这份精美的日程分享给同事时，却遇到了两个棘手问题：

1. 权限问题：首次授权后，用户在系统设置中禁用日历权限，再回到应用重新授权，却无法创建日历账户

2. 分享问题：日程详情页面内容较长，传统截图无法完整展示，需要实现自动长截图功能

这两个问题看似无关，实则都关系到应用的核心体验。让我们逐一拆解。

二、日历权限管理：那些容易被忽略的细节

2.1 问题现象：神秘的权限失效

在我们的日程管理应用中，用户创建提醒事项时需要日历读写权限。开发团队按照官方文档实现了权限申请逻辑，但测试时发现了两个诡异的问题：

场景一：二次授权失效

1. 用户首次打开应用，弹出日历读写授权弹窗 → 点击"允许" → 成功创建提醒事项

2. 用户进入系统设置，手动禁用应用的日历权限

3. 返回应用，再次尝试创建提醒 → 系统不再弹出授权弹窗

4. 应用内二次拉起权限设置页面，用户选择允许权限

5. 结果：仍然无法创建日历账户，Calendar对象为undefined

场景二：上下文传递错误

调用createCalendar接口时直接报错，错误信息指向上下文传递问题。

2.2 问题代码还原

让我们看看问题代码是什么样的：

// 错误示例1：权限时机不当
class ProblematicCalendarManager {
  private calendarMgr: any;
  
  constructor() {
    // 问题：过早初始化日程管理器
    this.calendarMgr = calendarManager.getCalendarManager(this.getContext());
  }
  
  async createReminder() {
    // 申请权限
    const granted = await this.requestCalendarPermission();
    
    if (granted) {
      // 尝试创建日历账户
      const calendar = await this.calendarMgr.getCalendar();
      // 问题：calendar可能是undefined
      if (!calendar) {
        throw new Error('无法获取日历账户');
      }
      // ... 创建提醒逻辑
    }
  }
}

// 错误示例2：上下文传递错误
class AnotherProblem {
  async createCalendar() {
    // 问题：getContext()未指定明确上下文
    let calendarMng = calendarManager.getCalendarManager(getContext());
    // 这里会报错
    await calendarMng.createCalendar(/* 参数 */);
  }
}

2.3 问题根源分析

通过深入分析，我们发现问题的核心在于：

对于场景一：

1. 当用户在系统设置中手动禁用权限后，应用内的权限状态发生了变化

2. 但应用代码中初始化的calendarMgr对象是在构造函数中创建的，此时权限可能还未被正确授予

3. 后续即使重新授权，使用的仍然是之前初始化的、有问题的calendarMgr对象

4. 结果就是：权限看似有了，但日历管理器对象内部状态不正确

对于场景二：

1. getContext()方法需要明确的上下文信息

2. 直接调用getContext()可能返回错误的上下文，特别是在某些生命周期回调中

3. 华为文档明确指出getContext(this)接口已废弃，需要新的获取方式

2.4 解决方案：正确的权限管理姿势

基于华为官方文档的指导，我们重构了权限管理逻辑：

import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
import calendarManager from '@ohos.calendarManager';
import common from '@ohos.app.ability.common';

class SmartCalendarManager {
  private context: common.Context;
  private calendarMgr: any = null;
  
  constructor(context: common.Context) {
    this.context = context;
  }
  
  // 正确的上下文获取方式
  private getValidContext(): common.Context {
    // 使用传入的context，确保上下文正确
    return this.context;
  }
  
  // 延迟初始化日历管理器
  private async initCalendarManager(): Promise<boolean> {
    try {
      // 只有在确认有权限后才初始化
      const hasPermission = await this.checkCalendarPermission();
      
      if (!hasPermission) {
        console.warn('无日历权限，无法初始化管理器');
        return false;
      }
      
      // 使用正确的上下文初始化
      this.calendarMgr = calendarManager.getCalendarManager(this.getValidContext());
      
      if (!this.calendarMgr) {
        console.error('日历管理器初始化失败');
        return false;
      }
      
      return true;
    } catch (error) {
      console.error('初始化日历管理器异常:', error);
      return false;
    }
  }
  
  // 检查日历权限
  private async checkCalendarPermission(): Promise<boolean> {
    try {
      const atManager = abilityAccessCtrl.createAtManager();
      
      // 检查日历读写权限
      const grantStatus = await atManager.checkAccessToken({
        tokenId: 0, // 0表示当前应用
        permissions: ['ohos.permission.READ_CALENDAR', 'ohos.permission.WRITE_CALENDAR']
      });
      
      return grantStatus.authResults.every(result => result.grantStatus === 0);
    } catch (error) {
      console.error('检查权限失败:', error);
      return false;
    }
  }
  
  // 申请日历权限
  private async requestCalendarPermission(): Promise<boolean> {
    try {
      const atManager = abilityAccessCtrl.createAtManager();
      
      // 请求权限
      const requestResult = await atManager.requestPermissionsFromUser(
        this.context,
        ['ohos.permission.READ_CALENDAR', 'ohos.permission.WRITE_CALENDAR']
      );
      
      // 检查授权结果
      const granted = requestResult.authResults.every(
        result => result.grantStatus === 0
      );
      
      if (granted) {
        console.log('日历权限授权成功');
        // 权限获取成功后，重新初始化管理器
        await this.initCalendarManager();
      } else {
        console.warn('日历权限授权被拒绝');
      }
      
      return granted;
    } catch (error) {
      console.error('申请权限失败:', error);
      return false;
    }
  }
  
  // 创建提醒事项（完整流程）
  async createSmartReminder(reminderData: ReminderData): Promise<boolean> {
    try {
      // 步骤1：检查权限
      let hasPermission = await this.checkCalendarPermission();
      
      // 步骤2：如果没有权限，申请权限
      if (!hasPermission) {
        hasPermission = await this.requestCalendarPermission();
        
        if (!hasPermission) {
          // 引导用户去设置页面手动开启
          this.guideToSettings();
          return false;
        }
      }
      
      // 步骤3：确保日历管理器已初始化
      if (!this.calendarMgr) {
        const initSuccess = await this.initCalendarManager();
        if (!initSuccess) {
          throw new Error('日历管理器初始化失败');
        }
      }
      
      // 步骤4：获取日历账户
      const calendar = await this.calendarMgr.getCalendar();
      if (!calendar) {
        // 尝试创建默认日历
        await this.createDefaultCalendar();
        // 重新获取
        const newCalendar = await this.calendarMgr.getCalendar();
        if (!newCalendar) {
          throw new Error('无法获取或创建日历账户');
        }
      }
      
      // 步骤5：创建提醒事项
      const reminderId = await this.calendarMgr.createReminder({
        calendarId: calendar.id,
        title: reminderData.title,
        description: reminderData.description,
        startTime: reminderData.startTime,
        endTime: reminderData.endTime,
        // ... 其他参数
      });
      
      console.log('提醒事项创建成功，ID:', reminderId);
      return true;
      
    } catch (error) {
      console.error('创建提醒事项失败:', error);
      
      // 错误处理：根据错误类型提供不同的用户提示
      if (error.code === 201) { // 权限错误
        this.showPermissionError();
      } else if (error.code === 202) { // 日历不存在
        this.showCalendarError();
      } else {
        this.showGenericError();
      }
      
      return false;
    }
  }
  
  // 创建默认日历
  private async createDefaultCalendar(): Promise<void> {
    try {
      const calendarInfo = {
        name: '智能日程',
        color: '#FF6B6B',
        timeZone: 'Asia/Shanghai',
        accessLevel: calendarManager.CalendarAccessLevel.ACCESS_LEVEL_OWNER
      };
      
      await this.calendarMgr.createCalendar(calendarInfo);
      console.log('默认日历创建成功');
    } catch (error) {
      console.error('创建默认日历失败:', error);
      throw error;
    }
  }
}

2.5 权限管理的最佳实践

1. 延迟初始化：在确认权限后再初始化敏感对象

2. 权限状态监听：监听权限变化，及时更新对象状态

3. 错误恢复：权限变化时重新初始化相关组件

4. 用户引导：权限被拒绝时，提供清晰的操作指引

三、Web组件长截图：让分享更完整

解决了权限问题，我们的日程应用还需要解决另一个用户体验问题：如何将完整的日程详情分享给他人？

3.1 需求分析：为什么需要长截图？

在我们的智能日程应用中，AI生成的日程详情通常包含：

• 会议主题和描述

• 参与人员列表

• 时间地点信息

• 议程安排

• 相关文档链接

• 智能建议

这些内容往往超出一屏显示范围。传统截图方式需要用户手动截取多张图片，然后拼接，体验极差。我们需要实现自动长截图功能。

3.2 技术挑战

实现Web组件长截图面临几个关键挑战：

1. 只能截取可见区域：默认情况下，componentSnapshot.get()只能获取当前屏幕显示的内容

2. 滚动时序控制：滚动和截图都是异步操作，需要精确控制时序

3. 内容加载状态：Web内容可能动态加载，需要确保内容完全渲染

4. 系统权限限制：保存到相册需要特殊权限处理

3.3 核心实现方案

基于华为文档和最佳实践，我们实现了完整的Web组件长截图方案：

import componentSnapshot from '@ohos.multimedia.image';
import webview from '@ohos.web.webview';
import picker from '@ohos.file.picker';
import photoAccessHelper from '@ohos.file.photoAccessHelper';

class WebViewScreenshotManager {
  private webViewController: webview.WebviewController | null = null;
  private isCapturing: boolean = false;
  private screenshotParts: image.PixelMap[] = [];
  
  // 初始化WebView控制器
  async initWebViewController(webView: WebView): Promise<boolean> {
    try {
      this.webViewController = webView.getController();
      
      if (!this.webViewController) {
        console.error('无法获取WebView控制器');
        return false;
      }
      
      // 关键步骤：启用全网页绘制
      if (typeof this.webViewController.enableWholeWebPageDrawing === 'function') {
        await this.webViewController.enableWholeWebPageDrawing(true);
        console.log('全网页绘制已启用');
      }
      
      return true;
    } catch (error) {
      console.error('初始化WebView控制器失败:', error);
      return false;
    }
  }
  
  // 执行长截图
  async captureLongScreenshot(): Promise<image.PixelMap | null> {
    if (this.isCapturing) {
      console.warn('截图操作正在进行中');
      return null;
    }
    
    this.isCapturing = true;
    this.screenshotParts = [];
    
    try {
      // 显示加载提示
      this.showLoading('正在生成截图...');
      
      // 步骤1：等待页面完全加载
      const isLoaded = await this.waitForPageLoad();
      if (!isLoaded) {
        throw new Error('页面加载超时');
      }
      
      // 步骤2：滚动到顶部
      await this.scrollToTop();
      
      // 步骤3：获取页面尺寸信息
      const pageInfo = await this.getPageInfo();
      
      // 步骤4：分段截图
      await this.captureInSections(pageInfo);
      
      // 步骤5：拼接所有部分
      const finalImage = await this.mergeScreenshots();
      
      // 隐藏加载提示
      this.hideLoading();
      
      return finalImage;
      
    } catch (error) {
      console.error('长截图失败:', error);
      this.hideLoading();
      this.showError('截图失败，请重试');
      return null;
    } finally {
      this.isCapturing = false;
    }
  }
  
  // 获取页面信息
  private async getPageInfo(): Promise<PageInfo> {
    if (!this.webViewController) {
      throw new Error('WebView控制器未初始化');
    }
    
    // 执行JavaScript获取页面尺寸
    const script = `
      (function() {
        return {
          totalHeight: Math.max(
            document.body.scrollHeight,
            document.body.offsetHeight,
            document.documentElement.clientHeight,
            document.documentElement.scrollHeight,
            document.documentElement.offsetHeight
          ),
          viewportHeight: window.innerHeight,
          scrollTop: window.pageYOffset || document.documentElement.scrollTop
        };
      })();
    `;
    
    const result = await this.webViewController.executeScript(script);
    return {
      totalHeight: result.totalHeight || 0,
      viewportHeight: result.viewportHeight || 0,
      scrollTop: result.scrollTop || 0
    };
  }
  
  // 分段截图
  private async captureInSections(pageInfo: PageInfo): Promise<void> {
    const { totalHeight, viewportHeight } = pageInfo;
    let currentScroll = 0;
    let lastImageBottom = 0;
    let sectionCount = 0;
    
    while (currentScroll < totalHeight && sectionCount < 100) { // 防止无限循环
      sectionCount++;
      
      // 滚动到指定位置
      await this.scrollToPosition(currentScroll);
      
      // 等待滚动动画完成
      await this.sleep(300);
      
      // 等待页面稳定（针对动态内容）
      await this.waitForPageStable();
      
      // 截取当前视口
      const currentImage = await this.captureViewport();
      if (!currentImage) {
        throw new Error(`第${sectionCount}段截图失败`);
      }
      
      // 计算重叠部分（避免拼接缝隙）
      const overlap = this.calculateOptimalOverlap(lastImageBottom, viewportHeight);
      
      // 裁剪图像，只保留新增部分
      const croppedImage = await this.cropImage(currentImage, overlap);
      
      // 保存有效部分
      this.screenshotParts.push(croppedImage);
      lastImageBottom = viewportHeight - overlap;
      
      // 更新滚动位置
      currentScroll += (viewportHeight - overlap);
      
      // 更新进度
      const progress = Math.min(100, Math.round((currentScroll / totalHeight) * 100));
      this.updateProgress(progress);
      
      // 如果已经滚动到底部，提前结束
      if (currentScroll >= totalHeight) {
        break;
      }
    }
    
    console.log(`截图完成，共${sectionCount}段`);
  }
  
  // 计算最佳重叠区域
  private calculateOptimalOverlap(lastBottom: number, viewportHeight: number): number {
    // 基础重叠为视口高度的15%
    let overlap = Math.floor(viewportHeight * 0.15);
    
    // 确保最小重叠（避免拼接问题）
    overlap = Math.max(overlap, 50); // 至少50像素
    
    // 确保不超过视口高度
    overlap = Math.min(overlap, viewportHeight - 10);
    
    return overlap;
  }
  
  // 截取当前视口
  private async captureViewport(): Promise<image.PixelMap | null> {
    if (!this.webViewController) {
      return null;
    }
    
    try {
      const snapshot = await componentSnapshot.get(this.webViewController);
      return snapshot;
    } catch (error) {
      console.error('截图失败:', error);
      return null;
    }
  }
  
  // 裁剪图像
  private async cropImage(
    originalImage: image.PixelMap, 
    overlap: number
  ): Promise<image.PixelMap> {
    // 获取图像尺寸
    const imageInfo = originalImage.getImageInfo();
    
    // 计算裁剪区域（去掉顶部的重叠部分）
    const cropRegion = {
      x: 0,
      y: overlap,
      width: imageInfo.size.width,
      height: imageInfo.size.height - overlap
    };
    
    // 执行裁剪
    const cropped = await originalImage.crop(cropRegion);
    return cropped;
  }
  
  // 合并所有截图
  private async mergeScreenshots(): Promise<image.PixelMap> {
    if (this.screenshotParts.length === 0) {
      throw new Error('没有可合并的截图');
    }
    
    if (this.screenshotParts.length === 1) {
      // 只有一张图，直接返回
      return this.screenshotParts[0];
    }
    
    // 计算总高度
    let totalHeight = 0;
    const firstImage = this.screenshotParts[0];
    const imageInfo = firstImage.getImageInfo();
    const width = imageInfo.size.width;
    
    for (const part of this.screenshotParts) {
      const info = part.getImageInfo();
      totalHeight += info.size.height;
    }
    
    // 创建目标图像
    const creationOption: image.InitializationOptions = {
      size: {
        height: totalHeight,
        width: width
      },
      pixelFormat: image.PixelFormat.RGBA_8888,
      alphaType: image.AlphaType.PREMUL,
      editable: true
    };
    
    const finalImage = await image.createPixelMap(creationOption);
    
    // 绘制所有部分
    let currentY = 0;
    for (const part of this.screenshotParts) {
      const partInfo = part.getImageInfo();
      
      // 创建绘制选项
      const drawingOption: image.DrawOptions = {
        x: 0,
        y: currentY,
        width: partInfo.size.width,
        height: partInfo.size.height
      };
      
      // 绘制到最终图像
      await finalImage.drawImage(part, drawingOption);
      
      currentY += partInfo.size.height;
    }
    
    return finalImage;
  }
  
  // 保存到相册
  async saveToAlbum(pixelMap: image.PixelMap): Promise<string | null> {
    try {
      // 创建照片访问助手
      const phAccessHelper = photoAccessHelper.getPhotoAccessHelper(this.context);
      
      // 生成文件名
      const timestamp = new Date().getTime();
      const fileName = `日程截图_${timestamp}.jpg`;
      
      // 创建保存选项
      const createOptions: photoAccessHelper.PhotoCreateOptions = {
        title: fileName
      };
      
      // 保存图片
      const uri = await phAccessHelper.createAsset(createOptions);
      await phAccessHelper.writeAsset(uri, pixelMap);
      
      console.log('图片保存成功:', uri);
      return uri;
      
    } catch (error) {
      console.error('保存图片失败:', error);
      return null;
    }
  }
  
  // 工具方法：等待页面加载
  private waitForPageLoad(timeout: number = 10000): Promise<boolean> {
    return new Promise((resolve) => {
      if (!this.webViewController) {
        resolve(false);
        return;
      }
      
      let isResolved = false;
      const timer = setTimeout(() => {
        if (!isResolved) {
          isResolved = true;
          resolve(false);
        }
      }, timeout);
      
      this.webViewController.onPageEnd(() => {
        clearTimeout(timer);
        if (!isResolved) {
          isResolved = true;
          resolve(true);
        }
      });
    });
  }
  
  // 工具方法：等待页面稳定
  private waitForPageStable(timeout: number = 2000): Promise<void> {
    return new Promise((resolve) => {
      setTimeout(resolve, 300); // 基础等待时间
    });
  }
  
  // 工具方法：滚动到指定位置
  private scrollToPosition(position: number): Promise<void> {
    if (!this.webViewController) {
      return Promise.reject(new Error('WebView控制器未初始化'));
    }
    
    const script = `window.scrollTo(0, ${position});`;
    return this.webViewController.executeScript(script);
  }
  
  // 工具方法：滚动到顶部
  private scrollToTop(): Promise<void> {
    return this.scrollToPosition(0);
  }
  
  // 工具方法：延迟
  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

3.4 用户界面集成

为了让用户方便地使用长截图功能，我们设计了完整的用户界面：

// 截图控制组件
@Entry
@Component
struct ScreenshotControl {
  @State isCapturing: boolean = false;
  @State progress: number = 0;
  @State showPreview: boolean = false;
  @State previewImage: image.PixelMap | null = null;
  
  private screenshotManager: WebViewScreenshotManager = new WebViewScreenshotManager();
  private webViewRef: WebView | null = null;
  
  build() {
    Column() {
      // WebView组件
      Web({
        src: 'https://example.com/schedule-detail',
        controller: this.webViewRef
      })
      .onPageEnd(() => {
        console.log('页面加载完成');
      })
      .width('100%')
      .height('80%')
      
      // 控制区域
      Row() {
        // 分享按钮
        Button('分享日程')
          .onClick(() => {
            this.startScreenshot();
          })
          .enabled(!this.isCapturing)
          .width('40%')
        
        // 保存按钮（使用SaveButton）
        SaveButton()
          .onClick(async () => {
            if (this.previewImage) {
              const uri = await this.screenshotManager.saveToAlbum(this.previewImage);
              if (uri) {
                prompt.showToast({ message: '保存成功', duration: 2000 });
              } else {
                prompt.showToast({ message: '保存失败', duration: 2000 });
              }
            }
          })
          .enabled(!!this.previewImage)
          .width('40%')
      }
      .justifyContent(FlexAlign.SpaceAround)
      .width('100%')
      .padding(20)
      
      // 进度提示
      if (this.isCapturing) {
        Progress({ value: this.progress, total: 100 })
          .width('80%')
        Text(`截图进度: ${this.progress}%`)
          .fontSize(14)
          .fontColor(Color.Gray)
      }
      
      // 预览弹窗
      if (this.showPreview && this.previewImage) {
        PreviewDialog({
          image: this.previewImage,
          onClose: () => {
            this.showPreview = false;
          }
        })
      }
    }
  }
  
  // 开始截图
  private async startScreenshot() {
    if (!this.webViewRef) {
      prompt.showToast({ message: 'WebView未初始化', duration: 2000 });
      return;
    }
    
    // 初始化截图管理器
    const initSuccess = await this.screenshotManager.initWebViewController(this.webViewRef);
    if (!initSuccess) {
      prompt.showToast({ message: '初始化失败', duration: 2000 });
      return;
    }
    
    this.isCapturing = true;
    this.progress = 0;
    
    // 设置进度回调
    this.screenshotManager.setProgressCallback((progress: number) => {
      this.progress = progress;
    });
    
    // 执行截图
    const result = await this.screenshotManager.captureLongScreenshot();
    
    this.isCapturing = false;
    
    if (result) {
      this.previewImage = result;
      this.showPreview = true;
      prompt.showToast({ message: '截图生成成功', duration: 2000 });
    } else {
      prompt.showToast({ message: '截图生成失败', duration: 2000 });
    }
  }
}

四、整合实践：权限与截图的完美结合

现在，让我们将日历权限管理和Web组件长截图功能整合到完整的日程管理应用中：

// 完整的日程管理页面
@Entry
@Component
struct SmartSchedulePage {
  // 状态管理
  @State scheduleData: ScheduleData | null = null;
  @State hasCalendarPermission: boolean = false;
  @State isCreatingReminder: boolean = false;
  @State isSharing: boolean = false;
  
  // 管理器实例
  private calendarManager: SmartCalendarManager;
  private screenshotManager: WebViewScreenshotManager;
  
  aboutToAppear() {
    // 初始化管理器
    this.calendarManager = new SmartCalendarManager(getContext(this));
    
    // 检查初始权限状态
    this.checkInitialPermission();
  }
  
  build() {
    Column() {
      // 头部：日程信息
      ScheduleHeader({ data: this.scheduleData })
      
      // 内容区域：WebView显示日程详情
      WebViewContent({
        data: this.scheduleData,
        ref: (ref) => { this.webViewRef = ref; }
      })
      
      // 底部操作栏
      OperationBar({
        hasPermission: this.hasCalendarPermission,
        isCreating: this.isCreatingReminder,
        isSharing: this.isSharing,
        onAddToCalendar: () => this.addToCalendar(),
        onShare: () => this.shareSchedule(),
        onRequestPermission: () => this.requestPermission()
      })
      
      // 权限引导弹窗
      if (!this.hasCalendarPermission) {
        PermissionGuideDialog({
          onConfirm: () => this.requestPermission()
        })
      }
    }
  }
  
  // 检查初始权限
  private async checkInitialPermission() {
    const hasPermission = await this.calendarManager.checkCalendarPermission();
    this.hasCalendarPermission = hasPermission;
  }
  
  // 申请权限
  private async requestPermission() {
    const granted = await this.calendarManager.requestCalendarPermission();
    this.hasCalendarPermission = granted;
    
    if (granted) {
      prompt.showToast({ message: '权限获取成功', duration: 2000 });
    } else {
      // 引导用户去设置页面
      this.guideToAppSettings();
    }
  }
  
  // 添加到日历
  private async addToCalendar() {
    if (!this.hasCalendarPermission) {
      prompt.showToast({ message: '请先授权日历权限', duration: 2000 });
      return;
    }
    
    if (!this.scheduleData) {
      prompt.showToast({ message: '日程数据为空', duration: 2000 });
      return;
    }
    
    this.isCreatingReminder = true;
    
    try {
      const success = await this.calendarManager.createSmartReminder({
        title: this.scheduleData.title,
        description: this.scheduleData.description,
        startTime: this.scheduleData.startTime,
        endTime: this.scheduleData.endTime,
        location: this.scheduleData.location,
        attendees: this.scheduleData.attendees
      });
      
      if (success) {
        prompt.showToast({ message: '已添加到日历', duration: 2000 });
      }
    } catch (error) {
      console.error('创建提醒失败:', error);
      prompt.showToast({ message: '添加失败，请重试', duration: 2000 });
    } finally {
      this.isCreatingReminder = false;
    }
  }
  
  // 分享日程
  private async shareSchedule() {
    this.isSharing = true;
    
    try {
      // 初始化截图管理器
      if (this.webViewRef) {
        const initSuccess = await this.screenshotManager.initWebViewController(this.webViewRef);
        if (!initSuccess) {
          throw new Error('截图初始化失败');
        }
        
        // 生成长截图
        const screenshot = await this.screenshotManager.captureLongScreenshot();
        if (!screenshot) {
          throw new Error('截图生成失败');
        }
        
        // 显示预览
        this.showScreenshotPreview(screenshot);
      }
    } catch (error) {
      console.error('分享失败:', error);
      prompt.showToast({ message: '分享失败，请重试', duration: 2000 });
    } finally {
      this.isSharing = false;
    }
  }
}

五、经验总结与最佳实践

通过这个完整的智能日程管理应用案例，我们总结了以下HarmonyOS开发的最佳实践：

5.1 权限管理要点

1. 时机很重要：在确认权限后再初始化敏感对象

2. 状态要同步：权限变化时要及时更新相关组件状态

3. 错误要处理：提供清晰的错误提示和恢复路径

4. 用户要引导：权限被拒绝时，引导用户去设置页面

5.2 长截图实现要点

1. 启用全网页绘制：调用enableWholeWebPageDrawing(true)是关键

2. 控制滚动时序：滚动后要等待足够时间让页面稳定

3. 智能重叠计算：合理计算重叠区域，避免拼接缝隙

4. 内存要优化：及时释放不再需要的图像资源

5.3 性能优化建议

1. 懒加载策略：非必要组件延迟初始化

2. 资源复用：复用WebView和图像处理对象

3. 进度反馈：长时间操作要提供进度提示

4. 错误降级：复杂功能失败时提供降级方案

5.4 用户体验设计

1. 操作反馈：每个用户操作都要有即时反馈

2. 状态提示：明确告知用户当前状态

3. 恢复路径：操作失败时提供明确的恢复方法

4. 性能感知：让用户感知到应用的响应速度

六、结语

在HarmonyOS应用开发中，权限管理和复杂功能实现往往是决定应用质量的关键因素。通过本文的日历权限管理和Web组件长截图两个实战案例，我们看到了：

1. 细节决定成败：一个看似简单的权限问题，背后是复杂的系统交互逻辑

2. 用户体验至上：从用户角度出发，解决真实的使用痛点

3. 技术深度结合：将不同技术点有机结合，创造完整的产品体验

无论是权限管理的精细控制，还是长截图的技术实现，都需要开发者深入理解系统原理，关注用户体验，不断优化改进。希望本文的实践经验能为您的HarmonyOS开发之路提供有价值的参考。

记住，优秀的技术实现不仅要解决功能问题，更要创造愉悦的用户体验。在HarmonyOS的生态中，让我们用技术创造更多可能。