HarmonyOS APP开发：智能相册分类与检索系统

核心要点：基于HarmonyOS AI能力实现照片自动分类、智能标签、语义检索的完整相册系统

一、背景与动机

你有没有这样的经历——手机里存了几千张照片，想找一张上周在海边拍的合影，翻了半天也翻不到。更惨的是，有时候你记得照片里有一只猫，但完全不记得什么时候拍的，在相册里大海捞针一样地滑动，眼睛都快看花了。

传统相册按时间排序，这没错，但人的记忆不是按时间索引的。我们更习惯用"什么东西"“什么场景”"谁在照片里"来回忆。这就是智能相册要解决的核心问题——让照片按照语义而非单纯的时间线来组织。

HarmonyOS提供了强大的端侧AI能力，包括图像分类、物体检测、人脸识别等，而且这些能力都可以在设备本地运行，不需要把你的私密照片上传到云端。隐私安全+智能分类，这才是移动端AI该有的样子。

本文将手把手带你构建一个完整的智能相册系统，从图片扫描、AI分类、标签管理到语义检索，全部基于HarmonyOS原生能力实现。

二、核心原理

2.1 系统架构

智能相册系统的核心是一个"扫描→分析→索引→检索"的流水线。当用户首次打开应用时，系统会扫描设备上的所有图片，对每张图片进行AI分析，提取分类标签和特征向量，然后建立索引。之后用户就可以通过标签或自然语言来检索照片了。

2.2 图像分类原理

HarmonyOS的图像分类基于轻量级CNN模型，支持数百个预定义类别。其工作流程是：

1. 图像预处理：将图片缩放到模型输入尺寸（通常224×224），归一化像素值
2. 特征提取：通过卷积层提取图像的多层特征表示
3. 分类推理：全连接层输出各类别的概率分布
4. 后处理：取Top-K类别作为标签，过滤低置信度结果

关键点在于，HarmonyOS的NPU（神经网络处理单元）可以加速推理过程，让分类速度达到毫秒级。

2.3 倒排索引与语义检索

为了让检索足够快，我们采用倒排索引结构。每个标签对应一个图片ID列表，检索时只需合并多个标签的结果集即可。对于更复杂的语义检索，我们使用特征向量的余弦相似度来排序。

三、代码实战

3.1 媒体库扫描与图片加载

首先，我们需要从系统媒体库中扫描所有图片文件：

// PhotoScanner.ets - 媒体库图片扫描器
import { photoAccessHelper } from '@kit.MediaLibraryKit';
import { dataSharePredicates } from '@kit.ArkData';

export class PhotoScanner {
  // 扫描设备上所有图片
  async scanAllPhotos(): Promise<photoAccessHelper.PhotoAsset[]> {
    try {
      const context = getContext(this);
      const helper = photoAccessHelper.getPhotoAccessHelper(context);
      
      // 构建查询谓词：只查询图片类型
      const predicates = new dataSharePredicates.DataSharePredicates();
      predicates.equalTo('media_type', photoAccessHelper.PhotoType.IMAGE);
      predicates.orderByDesc('date_added'); // 按添加时间倒序
      
      const fetchOptions: photoAccessHelper.FetchOptions = {
        fetchColumns: [
          'uri', 'display_name', 'date_added', 'size',
          'width', 'height', 'duration', 'date_taken'
        ],
        predicates: predicates
      };
      
      const fetchResult = await helper.getAssets(fetchOptions);
      const photoList: photoAccessHelper.PhotoAsset[] = [];
      
      if (fetchResult !== undefined) {
        const count = fetchResult.getCount();
        console.info(`[PhotoScanner] 扫描到 ${count} 张图片`);
        
        // 分批加载，避免内存溢出
        const batchSize = 50;
        for (let i = 0; i < count; i += batchSize) {
          const end = Math.min(i + batchSize, count);
          const batch = await fetchResult.getAllObject();
          // 实际项目中应使用 getAssetAt(i) 逐个获取
          photoList.push(...batch.slice(i, end));
        }
      }
      
      return photoList;
    } catch (error) {
      console.error(`[PhotoScanner] 扫描失败: ${JSON.stringify(error)}`);
      return [];
    }
  }
  
  // 获取图片的缩略图PixelMap
  async getThumbnail(
    asset: photoAccessHelper.PhotoAsset,
    size: number = 200
  ): Promise<image.PixelMap | null> {
    try {
      const thumbnailSize: photoAccessHelper.RequestSize = {
        width: size,
        height: size
      };
      const pixelMap = await asset.getThumbnail(thumbnailSize);
      return pixelMap;
    } catch (error) {
      console.error(`[PhotoScanner] 获取缩略图失败: ${JSON.stringify(error)}`);
      return null;
    }
  }
}

3.2 AI图像分类引擎

接下来是核心的AI分类模块，使用HarmonyOS的图像分类能力：

// AIClassifier.ets - AI图像分类引擎
import { imageClassification } from '@kit.AIServiceKit';
import { image } from '@kit.ImageKit';

// 分类结果数据结构
export interface ClassifyResult {
  uri: string;           // 图片URI
  labels: LabelInfo[];   // 分类标签列表
  timestamp: number;     // 分析时间
  featureVector?: number[]; // 特征向量（用于相似度检索）
}

export interface LabelInfo {
  name: string;    // 标签名称
  confidence: number; // 置信度 0-1
  category: string;   // 大类（人物/场景/物体/食物...）
}

export class AIClassifier {
  private classifier: imageClassification.ImageClassification | null = null;
  private isInitialized: boolean = false;
  
  // 初始化分类引擎
  async init(): Promise<boolean> {
    try {
      // 检查设备是否支持图像分类
      const isSupported = imageClassification.isAvailable();
      if (!isSupported) {
        console.error('[AIClassifier] 设备不支持图像分类能力');
        return false;
      }
      
      // 创建分类器实例
      const config: imageClassification.ImageClassificationInfo = {
        // 使用端侧模型，保护隐私
        modelType: imageClassification.ModelType.LOCAL
      };
      
      this.classifier = await imageClassification.createImageClassification(config);
      this.isInitialized = true;
      console.info('[AIClassifier] 分类引擎初始化成功');
      return true;
    } catch (error) {
      console.error(`[AIClassifier] 初始化失败: ${JSON.stringify(error)}`);
      return false;
    }
  }
  
  // 对单张图片进行分类
  async classifyImage(
    pixelMap: image.PixelMap,
    uri: string
  ): Promise<ClassifyResult> {
    if (!this.isInitialized || !this.classifier) {
      throw new Error('分类引擎未初始化');
    }
    
    try {
      // 执行分类推理
      const result = await this.classifier.classify(pixelMap);
      
      // 转换为自定义标签结构
      const labels: LabelInfo[] = result.map(item => ({
        name: this.translateLabel(item.label), // 翻译标签为中文
        confidence: item.confidence,
        category: this.getCategory(item.label)  // 归入大类
      })).filter(item => item.confidence > 0.3); // 过滤低置信度
      
      return {
        uri,
        labels,
        timestamp: Date.now()
      };
    } catch (error) {
      console.error(`[AIClassifier] 分类失败: ${JSON.stringify(error)}`);
      return { uri, labels: [], timestamp: Date.now() };
    }
  }
  
  // 批量分类（带进度回调）
  async classifyBatch(
    photos: photoAccessHelper.PhotoAsset[],
    scanner: PhotoScanner,
    onProgress?: (current: number, total: number) => void
  ): Promise<ClassifyResult[]> {
    const results: ClassifyResult[] = [];
    const total = photos.length;
    
    for (let i = 0; i < total; i++) {
      const asset = photos[i];
      const pixelMap = await scanner.getThumbnail(asset);
      
      if (pixelMap) {
        const result = await this.classifyImage(pixelMap, asset.uri);
        results.push(result);
      }
      
      // 每处理10张回调一次进度
      if (onProgress && i % 10 === 0) {
        onProgress(i + 1, total);
      }
    }
    
    return results;
  }
  
  // 标签中文翻译映射
  private translateLabel(label: string): string {
    const labelMap: Record<string, string> = {
      'cat': '猫', 'dog': '狗', 'bird': '鸟',
      'person': '人物', 'car': '汽车', 'flower': '花卉',
      'food': '美食', 'building': '建筑', 'sky': '天空',
      'beach': '海滩', 'mountain': '山', 'tree': '树木',
      'water': '水域', 'sunset': '日落', 'indoor': '室内',
      'outdoor': '户外', 'night': '夜景', 'snow': '雪景'
    };
    return labelMap[label] || label;
  }
  
  // 标签归类
  private getCategory(label: string): string {
    const categoryMap: Record<string, string> = {
      'cat': '动物', 'dog': '动物', 'bird': '动物',
      'person': '人物', 'flower': '植物', 'tree': '植物',
      'food': '美食', 'car': '交通', 'building': '建筑',
      'sky': '自然', 'beach': '自然', 'mountain': '自然',
      'water': '自然', 'sunset': '自然', 'snow': '自然',
      'indoor': '场景', 'outdoor': '场景', 'night': '场景'
    };
    return categoryMap[label] || '其他';
  }
  
  // 释放资源
  release(): void {
    if (this.classifier) {
      this.classifier.release();
      this.classifier = null;
      this.isInitialized = false;
    }
  }
}

3.3 倒排索引与智能检索

有了分类结果，我们需要建立索引来支持快速检索：

// SmartIndex.ets - 智能索引与检索引擎

// 索引条目
interface IndexEntry {
  uri: string;
  labels: string[];
  categories: string[];
  timestamp: number;
  confidenceMap: Record<string, number>; // 标签→置信度
}

export class SmartIndex {
  // 倒排索引：标签 → 图片URI列表
  private invertedIndex: Map<string, Set<string>> = new Map();
  // 正排索引：URI → 索引条目
  private forwardIndex: Map<string, IndexEntry> = new Map();
  // 分类索引：大类 → 图片URI列表
  private categoryIndex: Map<string, Set<string>> = new Map();
  
  // 构建索引
  buildIndex(results: ClassifyResult[]): void {
    this.invertedIndex.clear();
    this.forwardIndex.clear();
    this.categoryIndex.clear();
    
    for (const result of results) {
      if (result.labels.length === 0) continue;
      
      const entry: IndexEntry = {
        uri: result.uri,
        labels: result.labels.map(l => l.name),
        categories: [...new Set(result.labels.map(l => l.category))],
        timestamp: result.timestamp,
        confidenceMap: {}
      };
      
      // 构建置信度映射
      for (const label of result.labels) {
        entry.confidenceMap[label.name] = label.confidence;
      }
      
      // 写入正排索引
      this.forwardIndex.set(result.uri, entry);
      
      // 写入倒排索引
      for (const labelName of entry.labels) {
        if (!this.invertedIndex.has(labelName)) {
          this.invertedIndex.set(labelName, new Set());
        }
        this.invertedIndex.get(labelName)!.add(result.uri);
      }
      
      // 写入分类索引
      for (const category of entry.categories) {
        if (!this.categoryIndex.has(category)) {
          this.categoryIndex.set(category, new Set());
        }
        this.categoryIndex.get(category)!.add(result.uri);
      }
    }
    
    console.info(`[SmartIndex] 索引构建完成: ${this.forwardIndex.size} 张图片, ${this.invertedIndex.size} 个标签`);
  }
  
  // 按标签检索
  searchByLabel(label: string): IndexEntry[] {
    const uriSet = this.invertedIndex.get(label);
    if (!uriSet) return [];
    
    return Array.from(uriSet)
      .map(uri => this.forwardIndex.get(uri)!)
      .filter(entry => entry !== undefined)
      .sort((a, b) => (b.confidenceMap[label] || 0) - (a.confidenceMap[label] || 0));
  }
  
  // 按分类检索
  searchByCategory(category: string): IndexEntry[] {
    const uriSet = this.categoryIndex.get(category);
    if (!uriSet) return [];
    
    return Array.from(uriSet)
      .map(uri => this.forwardIndex.get(uri)!)
      .filter(entry => entry !== undefined)
      .sort((a, b) => b.timestamp - a.timestamp);
  }
  
  // 多标签组合检索（交集）
  searchByLabels(labels: string[]): IndexEntry[] {
    if (labels.length === 0) return [];
    if (labels.length === 1) return this.searchByLabel(labels[0]);
    
    // 取各标签结果集的交集
    let resultUris: Set<string> | null = null;
    for (const label of labels) {
      const uriSet = this.invertedIndex.get(label);
      if (!uriSet) return []; // 任一标签无结果则交集为空
      
      if (resultUris === null) {
        resultUris = new Set(uriSet);
      } else {
        resultUris = new Set([...resultUris].filter(uri => uriSet.has(uri)));
      }
    }
    
    if (!resultUris) return [];
    
    // 按综合置信度排序
    return Array.from(resultUris)
      .map(uri => this.forwardIndex.get(uri)!)
      .filter(entry => entry !== undefined)
      .sort((a, b) => {
        const scoreA = labels.reduce((sum, l) => sum + (a.confidenceMap[l] || 0), 0);
        const scoreB = labels.reduce((sum, l) => sum + (b.confidenceMap[l] || 0), 0);
        return scoreB - scoreA;
      });
  }
  
  // 语义检索（模糊匹配标签）
  semanticSearch(query: string): IndexEntry[] {
    const queryLower = query.toLowerCase();
    const matchedLabels: string[] = [];
    
    // 在所有标签中模糊匹配
    for (const label of this.invertedIndex.keys()) {
      if (label.includes(queryLower) || queryLower.includes(label)) {
        matchedLabels.push(label);
      }
    }
    
    // 合并所有匹配标签的结果
    const uriSet = new Set<string>();
    for (const label of matchedLabels) {
      const results = this.invertedIndex.get(label);
      if (results) {
        results.forEach(uri => uriSet.add(uri));
      }
    }
    
    return Array.from(uriSet)
      .map(uri => this.forwardIndex.get(uri)!)
      .filter(entry => entry !== undefined)
      .sort((a, b) => b.timestamp - a.timestamp);
  }
  
  // 获取所有标签统计
  getLabelStats(): Array<{ label: string; count: number }> {
    const stats: Array<{ label: string; count: number }> = [];
    for (const [label, uriSet] of this.invertedIndex) {
      stats.push({ label, count: uriSet.size });
    }
    return stats.sort((a, b) => b.count - a.count);
  }
  
  // 获取所有分类统计
  getCategoryStats(): Array<{ category: string; count: number }> {
    const stats: Array<{ category: string; count: number }> = [];
    for (const [category, uriSet] of this.categoryIndex) {
      stats.push({ category, count: uriSet.size });
    }
    return stats.sort((a, b) => b.count - a.count);
  }
}

3.4 完整的相册UI界面

最后，把所有模块组合成一个完整的UI：

// SmartAlbumPage.ets - 智能相册主页面
import { photoAccessHelper } from '@kit.MediaLibraryKit';

@Entry
@Component
struct SmartAlbumPage {
  // 状态管理
  @State photoList: photoAccessHelper.PhotoAsset[] = [];
  @State classifyResults: ClassifyResult[] = [];
  @State labelStats: Array<{ label: string; count: number }> = [];
  @State categoryStats: Array<{ category: string; count: number }> = [];
  @State searchQuery: string = '';
  @State searchResults: IndexEntry[] = [];
  @State isScanning: boolean = false;
  @State scanProgress: number = 0;
  @State selectedCategory: string = '';
  @State currentView: 'grid' | 'category' | 'search' = 'grid';
  
  // 引擎实例
  private scanner: PhotoScanner = new PhotoScanner();
  private classifier: AIClassifier = new AIClassifier();
  private index: SmartIndex = new SmartIndex();
  
  aboutToAppear() {
    this.initAndScan();
  }
  
  // 初始化并开始扫描
  async initAndScan() {
    this.isScanning = true;
    
    // 初始化AI引擎
    const initResult = await this.classifier.init();
    if (!initResult) {
      console.error('AI引擎初始化失败');
      this.isScanning = false;
      return;
    }
    
    // 扫描图片
    this.photoList = await this.scanner.scanAllPhotos();
    
    // 执行AI分类
    this.classifyResults = await this.classifier.classifyBatch(
      this.photoList,
      this.scanner,
      (current, total) => {
        this.scanProgress = Math.floor((current / total) * 100);
      }
    );
    
    // 构建索引
    this.index.buildIndex(this.classifyResults);
    this.labelStats = this.index.getLabelStats();
    this.categoryStats = this.index.getCategoryStats();
    
    this.isScanning = false;
  }
  
  build() {
    Column() {
      // 顶部搜索栏
      this.SearchBar();
      
      // 分类标签栏
      this.CategoryTabs();
      
      // 内容区域
      if (this.isScanning) {
        this.ScanningView();
      } else if (this.currentView === 'search') {
        this.SearchResultsView();
      } else if (this.currentView === 'category') {
        this.CategoryView();
      } else {
        this.PhotoGridView();
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0F0F1A')
  }
  
  // 搜索栏组件
  @Builder SearchBar() {
    Row() {
      Search({ value: this.searchQuery, placeholder: '搜索照片（如：猫、海滩、美食）' })
        .width('85%')
        .height(44)
        .backgroundColor('#1A1A2E')
        .fontColor('#FFFFFF')
        .placeholderColor('#6B7280')
        .borderRadius(22)
        .onChange((value: string) => {
          this.searchQuery = value;
        })
        .onSubmit(() => {
          this.performSearch();
        })
      
      Button('搜索')
        .height(36)
        .fontSize(14)
        .fontColor('#FFFFFF')
        .backgroundColor('#4F46E5')
        .borderRadius(18)
        .margin({ left: 8 })
        .onClick(() => this.performSearch())
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 12, bottom: 8 })
  }
  
  // 分类标签栏
  @Builder CategoryTabs() {
    Scroll() {
      Row() {
        ForEach(this.categoryStats, (item: { category: string; count: number }) => {
          Text(`${item.category}(${item.count})`)
            .fontSize(13)
            .fontColor(this.selectedCategory === item.category ? '#FFFFFF' : '#9CA3AF')
            .backgroundColor(this.selectedCategory === item.category ? '#4F46E5' : '#1A1A2E')
            .borderRadius(16)
            .padding({ left: 12, right: 12, top: 6, bottom: 6 })
            .margin({ right: 8 })
            .onClick(() => {
              this.selectedCategory = item.category;
              this.currentView = 'category';
            })
        })
      }
    }
    .scrollable(ScrollDirection.Horizontal)
    .width('100%')
    .padding({ left: 16, right: 16, bottom: 12 })
  }
  
  // 扫描进度视图
  @Builder ScanningView() {
    Column() {
      LoadingProgress()
        .width(60)
        .height(60)
        .color('#4F46E5')
      
      Text('正在智能分析您的相册...')
        .fontSize(16)
        .fontColor('#FFFFFF')
        .margin({ top: 20 })
      
      Text(`${this.scanProgress}%`)
        .fontSize(28)
        .fontWeight(FontWeight.Bold)
        .fontColor('#4F46E5')
        .margin({ top: 12 })
      
      Progress({ value: this.scanProgress, total: 100, type: ProgressType.Linear })
        .width('60%')
        .color('#4F46E5')
        .backgroundColor('#1A1A2E')
        .margin({ top: 16 })
    }
    .width('100%')
    .layoutWeight(1)
    .justifyContent(FlexAlign.Center)
  }
  
  // 搜索结果视图
  @Builder SearchResultsView() {
    Column() {
      Text(`找到 ${this.searchResults.length} 张相关照片`)
        .fontSize(14)
        .fontColor('#9CA3AF')
        .margin({ left: 16, bottom: 12 })
      
      // 照片网格
      Flex({ wrap: FlexWrap.Wrap, justifyContent: FlexAlign.Start }) {
        ForEach(this.searchResults, (entry: IndexEntry) => {
          Image(entry.uri)
            .width('31%')
            .height(120)
            .objectFit(ImageFit.Cover)
            .borderRadius(8)
            .margin({ left: '2%', bottom: 8 })
        })
      }
      .width('100%')
      .padding({ left: 8, right: 8 })
    }
    .width('100%')
    .layoutWeight(1)
  }
  
  // 分类详情视图
  @Builder CategoryView() {
    Column() {
      // 返回按钮
      Row() {
        Text('← 返回')
          .fontSize(14)
          .fontColor('#4F46E5')
          .onClick(() => {
            this.currentView = 'grid';
            this.selectedCategory = '';
          })
        
        Text(this.selectedCategory)
          .fontSize(18)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
          .margin({ left: 12 })
      }
      .width('100%')
      .padding({ left: 16, top: 8, bottom: 12 })
      
      // 该分类下的标签云
      Flex({ wrap: FlexWrap.Wrap }) {
        ForEach(
          this.labelStats.filter(l => {
            const entry = this.index.searchByLabel(l.label);
            return entry.length > 0 && entry[0].categories.includes(this.selectedCategory);
          }),
          (item: { label: string; count: number }) => {
            Text(`${item.label} ${item.count}`)
              .fontSize(13)
              .fontColor('#E0E7FF')
              .backgroundColor('#312E81')
              .borderRadius(12)
              .padding({ left: 10, right: 10, top: 4, bottom: 4 })
              .margin({ right: 6, bottom: 6 })
          }
        )
      }
      .width('100%')
      .padding({ left: 16, right: 16, bottom: 12 })
      
      // 该分类的照片
      Scroll() {
        Flex({ wrap: FlexWrap.Wrap, justifyContent: FlexAlign.Start }) {
          ForEach(this.index.searchByCategory(this.selectedCategory), (entry: IndexEntry) => {
            Image(entry.uri)
              .width('31%')
              .height(120)
              .objectFit(ImageFit.Cover)
              .borderRadius(8)
              .margin({ left: '2%', bottom: 8 })
          })
        }
        .width('100%')
        .padding({ left: 8, right: 8 })
      }
      .layoutWeight(1)
    }
    .width('100%')
    .layoutWeight(1)
  }
  
  // 照片网格视图
  @Builder PhotoGridView() {
    Scroll() {
      // 热门标签
      Column() {
        Text('热门标签')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
          .width('100%')
          .padding({ left: 16, bottom: 8 })
        
        Flex({ wrap: FlexWrap.Wrap }) {
          ForEach(this.labelStats.slice(0, 15), (item: { label: string; count: number }) => {
            Text(`${item.label}(${item.count})`)
              .fontSize(13)
              .fontColor('#C7D2FE')
              .backgroundColor('#312E81')
              .borderRadius(14)
              .padding({ left: 10, right: 10, top: 5, bottom: 5 })
              .margin({ right: 6, bottom: 6 })
              .onClick(() => {
                this.searchQuery = item.label;
                this.performSearch();
              })
          })
        }
        .width('100%')
        .padding({ left: 16, right: 16 })
      }
      .width('100%')
      
      // 最近照片网格
      Column() {
        Text('最近照片')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
          .width('100%')
          .padding({ left: 16, top: 16, bottom: 8 })
        
        Flex({ wrap: FlexWrap.Wrap, justifyContent: FlexAlign.Start }) {
          ForEach(this.classifyResults.slice(0, 30), (result: ClassifyResult) => {
            Image(result.uri)
              .width('31%')
              .height(120)
              .objectFit(ImageFit.Cover)
              .borderRadius(8)
              .margin({ left: '2%', bottom: 8 })
          })
        }
        .width('100%')
        .padding({ left: 8, right: 8 })
      }
      .width('100%')
    }
    .layoutWeight(1)
  }
  
  // 执行搜索
  private performSearch() {
    if (!this.searchQuery.trim()) return;
    
    // 先尝试精确标签匹配
    let results = this.index.searchByLabel(this.searchQuery);
    
    // 无精确结果则语义搜索
    if (results.length === 0) {
      results = this.index.semanticSearch(this.searchQuery);
    }
    
    this.searchResults = results;
    this.currentView = 'search';
  }
  
  aboutToDisappear() {
    // 释放AI引擎资源
    this.classifier.release();
  }
}

四、踩坑与注意事项

4.1 媒体库权限问题

这是最常见的坑。访问媒体库需要ohos.permission.READ_IMAGEVIDEO权限，而且在HarmonyOS 5.0+中，这个权限是用户授权级别的，必须在module.json5中声明并在运行时请求：

// module.json5
{
  "requestPermissions": [
    {
      "name": "ohos.permission.READ_IMAGEVIDEO",
      "reason": "$string:read_image_reason",
      "usedScene": {
        "abilities": ["EntryAbility"],
        "when": "inuse"
      }
    }
  ]
}

运行时请求：

import { abilityAccessCtrl } from '@kit.AbilityKit';

async function requestPermission(): Promise<boolean> {
  const atManager = abilityAccessCtrl.createAtManager();
  const result = await atManager.requestPermissionsFromUser(
    getContext(),
    ['ohos.permission.READ_IMAGEVIDEO']
  );
  return result.authResults[0] === 0;
}

4.2 NPU不可用的降级策略

不是所有设备都有NPU，部分低端设备可能不支持端侧AI推理。务必在初始化时检查isAvailable()，如果不可用，需要降级到云端API或者跳过AI功能：

if (!imageClassification.isAvailable()) {
  // 降级方案1：使用云端API
  // 降级方案2：使用基于规则的简单分类（如EXIF信息）
  // 降级方案3：仅提供手动标签功能
}

4.3 内存管理

处理大量图片时，PixelMap对象会占用大量内存。务必及时释放不再使用的PixelMap：

// 处理完一张图片后立即释放
pixelMap.release();

同时建议分批处理，每批不超过50张，避免同时加载过多图片导致OOM。

4.4 分类结果缓存

AI分类是耗时操作，不应该每次打开应用都重新分类。建议将分类结果持久化到数据库：

import { relationalStore } from '@kit.ArkData';

// 将ClassifyResult序列化后存入关系型数据库
// 下次启动时先读取缓存，只对新图片执行分类

五、HarmonyOS 6适配

5.1 API变更

HarmonyOS 6对AI服务Kit进行了重要更新：

5.2 迁移要点

1. 模型管理：HarmonyOS 6新增了模型版本管理能力，建议在初始化时检查模型是否需要更新：

   // HarmonyOS 6 新增
   const modelManager = imageClassification.getModelManager();
   const updateInfo = await modelManager.checkUpdate();
   if (updateInfo.needUpdate) {
     await modelManager.updateModel();
   }
   

2. NPU调度：如果应用同时运行多个AI任务，建议使用NpuScheduler进行调度，避免资源竞争。

3. 权限变更：HarmonyOS 6的媒体库权限新增了"仅本次允许"选项，需要在代码中处理权限被临时授予的情况。

六、总结

本文从零构建了一个完整的HarmonyOS智能相册系统，核心知识点如下：

智能相册系统
├── 媒体库扫描
│   ├── photoAccessHelper API
│   ├── 分批加载策略
│   └── 缩略图获取
├── AI图像分类
│   ├── imageClassification端侧推理
│   ├── 标签提取与中文映射
│   ├── 批量分类与进度回调
│   └── NPU不可用降级
├── 智能索引
│   ├── 倒排索引（标签→URI）
│   ├── 分类索引（大类→URI）
│   ├── 多标签交集检索
│   └── 语义模糊匹配
├── UI交互
│   ├── 搜索栏与语义检索
│   ├── 分类标签栏
│   ├── 照片网格展示
│   └── 扫描进度可视化
└── 工程化
    ├── 权限管理
    ├── 内存优化（PixelMap释放）
    ├── 分类结果持久化
    └── HarmonyOS 6适配

关键收获：

• 端侧AI推理是HarmonyOS的核心优势，隐私安全+低延迟
• 倒排索引是检索性能的基石，比遍历快几个数量级
• 内存管理是图片密集型应用的生命线，不及时释放必OOM
• 永远要有降级方案，不是所有设备都支持NPU

智能相册只是AI+图片的起点，在此基础上还可以扩展人脸聚类、场景识别、智能修图等功能。HarmonyOS的AI能力正在快速迭代，保持关注官方文档更新是持续进化的关键。