HarmonyOS开发：企业发布企业内部分发

核心要点：企业内部分发绕过了公开应用市场，但绕不过安全合规——企业证书管理、MDM集成、内部分发平台搭建，每一步都关乎企业数据安全。一个管理不善的企业证书，可能让整个企业的移动设备暴露在风险中。

背景与动机

企业内部应用不需要上架公开应用市场。OA系统、CRM系统、内部工具——这些应用只有企业员工使用，放应用市场上毫无意义，还可能泄露企业业务信息。

但问题是：不上应用市场，怎么把应用装到员工手机上？

最原始的方式：把HAP包扔到内网服务器，员工自己下载安装。但这种方式问题太多了——版本混乱、无法强制更新、设备无法管控、应用可能被泄露到外部。

企业内部分发需要一套完整的管理体系：企业证书管理、设备注册与管控、应用分发与更新、数据安全保护。这不是一个技术问题，是一个安全+管理+技术的综合问题。

这篇文章，把企业证书、MDM集成、内部分发平台搭建全部讲清楚。

核心原理

企业内部分发架构

graph TD
    A[企业管理后台] --> B[企业证书管理]
    A --> C[设备管理 MDM]
    A --> D[应用管理]
    A --> E[策略管理]
    
    B --> B1[企业P12证书]
    B --> B2[证书续期]
    B --> B3[证书吊销]
    
    C --> C1[设备注册]
    C --> C2[设备策略下发]
    C --> C3[设备远程擦除]
    
    D --> D1[应用上传]
    D --> D2[版本管理]
    D --> D3[灰度发布]
    
    E --> E1[安装策略]
    E --> E2[网络策略]
    E --> E3[数据保护策略]
    
    A --> F[内部分发平台]
    F --> G[员工设备]
    G --> H[企业应用]
    
    classDef mainStyle fill:#FF6B35,stroke:#D4551F,color:#fff,font-weight:bold
    classDef subStyle fill:#4ECDC4,stroke:#3BA99C,color:#fff
    classDef leafStyle fill:#45B7D1,stroke:#2E8EA8,color:#fff
    classDef deviceStyle fill:#96CEB4,stroke:#6DAF8E,color:#fff
    classDef appStyle fill:#FFE66D,stroke:#D4B93C,color:#333
    
    class A mainStyle
    class B,C,D,E,F subStyle
    class B1,B2,B3,C1,C2,C3,D1,D2,D3,E1,E2,E3 leafStyle
    class G deviceStyle
    class H appStyle

企业分发 vs 公开发布

代码实战

基础用法：企业证书与签名配置

企业内部分发的第一步是获取企业开发者证书。

// scripts/enterprise_sign.ets
// 企业应用签名配置

// 企业签名配置信息
interface EnterpriseSignConfig {
  // 企业P12证书路径
  certPath: string;
  // 证书密码
  certPassword: string;
  // 企业Profile文件路径
  profilePath: string;
  // 签名算法
  signAlg: string;
  // 输出路径
  outputPath: string;
}

// 企业签名管理器
class EnterpriseSignManager {
  private config: EnterpriseSignConfig;

  constructor(config: EnterpriseSignConfig) {
    this.config = config;
  }

  // 验证证书有效性
  async validateCertificate(): Promise<{
    isValid: boolean;
    expiresAt: string;
    daysRemaining: number;
    warnings: string[];
  }> {
    const warnings: string[] = [];
    
    // 检查证书文件是否存在
    // 实际项目中需要读取证书信息
    const daysRemaining = 180; // 模拟
    
    if (daysRemaining < 30) {
      warnings.push(`证书将在${daysRemaining}天后过期，请及时续期`);
    }
    
    if (daysRemaining < 7) {
      warnings.push('证书即将过期！紧急续期！');
    }

    return {
      isValid: daysRemaining > 0,
      expiresAt: new Date(Date.now() + daysRemaining * 86400000).toISOString(),
      daysRemaining: daysRemaining,
      warnings: warnings
    };
  }

  // 执行签名
  async signApp(hapPath: string): Promise<string> {
    console.log(`正在签名: ${hapPath}`);
    
    // 实际签名命令：
    // java -jarhapsigner.jar sign-app
    //   -keyAlias enterprise_key
    //   -keyPwd ${certPassword}
    //   -keystoreFile ${certPath}
    //   -keystorePwd ${certPassword}
    //   -appCertFile ${certPath}
    //   -profileFile ${profilePath}
    //   -profileSigned 1
    //   -inFile ${hapPath}
    //   -outFile ${outputPath}
    //   -signAlg SHA256withECDSA
    
    const signedPath = hapPath.replace('.hap', '_signed.hap');
    console.log(`签名完成: ${signedPath}`);
    
    return signedPath;
  }
}

// 使用示例
const signManager = new EnterpriseSignManager({
  certPath: './certs/enterprise.p12',
  certPassword: '***',
  profilePath: './certs/enterprise_profile.p7b',
  signAlg: 'SHA256withECDSA',
  outputPath: './output/signed/'
});

// 验证证书
signManager.validateCertificate().then(result => {
  console.log(`证书有效: ${result.isValid}`);
  console.log(`剩余天数: ${result.daysRemaining}`);
  if (result.warnings.length > 0) {
    result.warnings.forEach(w => console.warn(w));
  }
});

进阶用法：MDM集成与设备管理

MDM（Mobile Device Management）是企业内部分发的核心组件。通过MDM，你可以远程管理员工设备上的应用。

// entry/src/main/ets/utils/MDMManager.ets
// MDM管理器——企业设备管控

import { hilog } from '@kit.PerformanceAnalysisKit';
import { common } from '@kit.AbilityKit';
import { preferences } from '@kit.ArkData';

// 设备信息
interface DeviceInfo {
  deviceId: string;           // 设备ID
  deviceName: string;         // 设备名称
  deviceModel: string;        // 设备型号
  osVersion: string;          // 系统版本
  enrollTime: number;         // 注册时间
  lastSyncTime: number;       // 最后同步时间
  isCompliant: boolean;       // 是否合规
  installedApps: string[];    // 已安装应用列表
}

// MDM策略
interface MDMPolicy {
  policyId: string;           // 策略ID
  policyName: string;         // 策略名称
  // 安装策略
  allowedApps: string[];      // 允许安装的应用列表
  blockedApps: string[];      // 禁止安装的应用列表
  forceInstallApps: string[]; // 强制安装的应用列表
  // 网络策略
  wifiOnly: boolean;          // 是否仅允许WiFi
  vpnRequired: boolean;       // 是否要求VPN
  // 安全策略
  screenLockRequired: boolean;    // 是否要求锁屏密码
  screenLockTimeout: number;      // 锁屏超时（秒）
  encryptionRequired: boolean;    // 是否要求存储加密
  // 数据保护策略
  clipboardRestricted: boolean;   // 是否限制剪贴板
  screenshotRestricted: boolean;  // 是否限制截屏
  dataShareRestricted: boolean;   // 是否限制数据分享
}

// 设备注册状态
interface EnrollmentStatus {
  isEnrolled: boolean;       // 是否已注册
  enrollmentTime: number;    // 注册时间
  serverUrl: string;         // MDM服务器地址
  lastPolicySync: number;    // 最后策略同步时间
}

export class MDMManager {
  private static instance: MDMManager;
  private context: common.Context | null = null;
  private enrollmentStatus: EnrollmentStatus | null = null;
  private currentPolicy: MDMPolicy | null = null;

  static getInstance(): MDMManager {
    if (!MDMManager.instance) {
      MDMManager.instance = new MDMManager();
    }
    return MDMManager.instance;
  }

  // 初始化
  async init(context: common.Context): Promise<void> {
    this.context = context;
    await this.loadEnrollmentStatus();
    
    if (this.enrollmentStatus?.isEnrolled) {
      await this.syncPolicy();
    }
    
    hilog.info(0x0000, 'MDM', 
      `MDM初始化完成: 已注册=${this.enrollmentStatus?.isEnrolled}`);
  }

  // 设备注册
  async enrollDevice(serverUrl: string, authCode: string): Promise<boolean> {
    try {
      // 向MDM服务器注册设备
      // 实际项目中通过HTTP请求完成
      hilog.info(0x0000, 'MDM', `正在注册设备到: ${serverUrl}`);

      // 模拟注册成功
      this.enrollmentStatus = {
        isEnrolled: true,
        enrollmentTime: Date.now(),
        serverUrl: serverUrl,
        lastPolicySync: Date.now()
      };

      // 保存注册状态
      await this.saveEnrollmentStatus();
      
      // 同步策略
      await this.syncPolicy();
      
      hilog.info(0x0000, 'MDM', '设备注册成功');
      return true;
    } catch (error) {
      hilog.error(0x0000, 'MDM', `设备注册失败: ${JSON.stringify(error)}`);
      return false;
    }
  }

  // 取消注册
  async unenrollDevice(): Promise<boolean> {
    try {
      hilog.info(0x0000, 'MDM', '正在取消设备注册');
      
      this.enrollmentStatus = null;
      this.currentPolicy = null;
      
      await this.saveEnrollmentStatus();
      
      hilog.info(0x0000, 'MDM', '设备已取消注册');
      return true;
    } catch (error) {
      hilog.error(0x0000, 'MDM', `取消注册失败: ${JSON.stringify(error)}`);
      return false;
    }
  }

  // 同步MDM策略
  async syncPolicy(): Promise<void> {
    if (!this.enrollmentStatus?.isEnrolled) return;

    try {
      // 从MDM服务器拉取最新策略
      // 实际项目中通过HTTP请求完成
      this.currentPolicy = {
        policyId: 'policy_001',
        policyName: '标准企业策略',
        allowedApps: ['com.enterprise.oa', 'com.enterprise.crm', 'com.enterprise.mail'],
        blockedApps: ['com.game.*'],
        forceInstallApps: ['com.enterprise.oa', 'com.enterprise.mail'],
        wifiOnly: false,
        vpnRequired: true,
        screenLockRequired: true,
        screenLockTimeout: 300,
        encryptionRequired: true,
        clipboardRestricted: true,
        screenshotRestricted: false,
        dataShareRestricted: true
      };

      // 应用策略
      this.applyPolicy();

      // 更新同步时间
      this.enrollmentStatus.lastPolicySync = Date.now();
      await this.saveEnrollmentStatus();

      hilog.info(0x0000, 'MDM', '策略同步完成');
    } catch (error) {
      hilog.error(0x0000, 'MDM', `策略同步失败: ${JSON.stringify(error)}`);
    }
  }

  // 应用MDM策略
  private applyPolicy(): void {
    if (!this.currentPolicy) return;

    // 检查强制安装的应用
    if (this.currentPolicy.forceInstallApps.length > 0) {
      hilog.info(0x0000, 'MDM', 
        `需要强制安装的应用: ${this.currentPolicy.forceInstallApps.join(', ')}`);
      // 实际项目中触发应用安装
    }

    // 检查安全策略
    if (this.currentPolicy.screenshotRestricted) {
      hilog.info(0x0000, 'MDM', '截屏功能已限制');
      // 实际项目中设置窗口安全标志
    }

    if (this.currentPolicy.clipboardRestricted) {
      hilog.info(0x0000, 'MDM', '剪贴板功能已限制');
    }

    hilog.info(0x0000, 'MDM', '策略应用完成');
  }

  // 检查应用是否允许安装
  isAppAllowed(packageName: string): boolean {
    if (!this.currentPolicy) return true;

    // 检查禁止列表
    if (this.currentPolicy.blockedApps.length > 0) {
      for (const blocked of this.currentPolicy.blockedApps) {
        if (blocked.endsWith('*')) {
          // 通配符匹配
          const prefix = blocked.slice(0, -1);
          if (packageName.startsWith(prefix)) return false;
        } else if (packageName === blocked) {
          return false;
        }
      }
    }

    // 检查允许列表
    if (this.currentPolicy.allowedApps.length > 0) {
      return this.currentPolicy.allowedApps.includes(packageName);
    }

    return true;
  }

  // 是否已注册
  isEnrolled(): boolean {
    return this.enrollmentStatus?.isEnrolled ?? false;
  }

  // 获取当前策略
  getCurrentPolicy(): MDMPolicy | null {
    return this.currentPolicy;
  }

  // 加载注册状态
  private async loadEnrollmentStatus(): Promise<void> {
    if (!this.context) return;

    try {
      const pref = await preferences.getPreferences(this.context, 'mdm_status');
      const isEnrolled = (await pref.get('is_enrolled', false)) as boolean;
      
      if (isEnrolled) {
        this.enrollmentStatus = {
          isEnrolled: true,
          enrollmentTime: (await pref.get('enrollment_time', 0)) as number,
          serverUrl: (await pref.get('server_url', '')) as string,
          lastPolicySync: (await pref.get('last_sync', 0)) as number
        };
      }
    } catch (error) {
      hilog.warn(0x0000, 'MDM', '加载注册状态失败');
    }
  }

  // 保存注册状态
  private async saveEnrollmentStatus(): Promise<void> {
    if (!this.context) return;

    try {
      const pref = await preferences.getPreferences(this.context, 'mdm_status');
      
      if (this.enrollmentStatus) {
        await pref.put('is_enrolled', this.enrollmentStatus.isEnrolled);
        await pref.put('enrollment_time', this.enrollmentStatus.enrollmentTime);
        await pref.put('server_url', this.enrollmentStatus.serverUrl);
        await pref.put('last_sync', this.enrollmentStatus.lastPolicySync);
      } else {
        await pref.put('is_enrolled', false);
      }
      
      await pref.flush();
    } catch (error) {
      hilog.error(0x0000, 'MDM', '保存注册状态失败');
    }
  }
}

完整示例：企业内部分发平台

把证书管理、设备注册、应用分发整合成一个完整的内部分发平台。

// entry/src/main/ets/utils/EnterpriseDistribution.ets
// 企业内部分发平台——应用上传、审核、分发、更新一站式管理

import { hilog } from '@kit.PerformanceAnalysisKit';
import { common } from '@kit.AbilityKit';
import { preferences } from '@kit.ArkData';

// 企业应用信息
interface EnterpriseApp {
  appId: string;              // 应用ID
  appName: string;            // 应用名称
  packageName: string;        // 包名
  versionName: string;        // 版本名
  versionCode: number;        // 版本号
  description: string;        // 应用描述
  downloadUrl: string;        // 下载地址
  fileSize: number;           // 文件大小
  md5: string;                // MD5校验
  uploadTime: number;         // 上传时间
  uploader: string;           // 上传者
  status: 'draft' | 'reviewing' | 'approved' | 'rejected' | 'published'; // 状态
  targetDepartments: string[]; // 目标部门
  targetUsers: string[];      // 目标用户
  isForceUpdate: boolean;     // 是否强制更新
}

// 分发记录
interface DistributionRecord {
  recordId: string;
  appId: string;
  deviceIds: string[];        // 目标设备
  distributionTime: number;   // 分发时间
  status: 'pending' | 'downloading' | 'installed' | 'failed'; // 状态
  installedCount: number;     // 已安装数
  failedCount: number;        // 失败数
}

// 用户设备绑定
interface UserDeviceBinding {
  userId: string;
  userName: string;
  department: string;
  deviceId: string;
  deviceModel: string;
  registeredApps: string[];   // 已注册应用
}

export class EnterpriseDistribution {
  private static instance: EnterpriseDistribution;
  private context: common.Context | null = null;
  private apps: Map<string, EnterpriseApp> = new Map();
  private bindings: Map<string, UserDeviceBinding> = new Map();

  static getInstance(): EnterpriseDistribution {
    if (!EnterpriseDistribution.instance) {
      EnterpriseDistribution.instance = new EnterpriseDistribution();
    }
    return EnterpriseDistribution.instance;
  }

  // 初始化
  async init(context: common.Context): Promise<void> {
    this.context = context;
    await this.loadData();
    hilog.info(0x0000, 'EnterpriseDist', '企业分发平台初始化完成');
  }

  // 上传应用
  async uploadApp(appInfo: Omit<EnterpriseApp, 'uploadTime' | 'status'>): Promise<string> {
    const appId = `app_${Date.now()}`;
    
    const app: EnterpriseApp = {
      ...appInfo,
      appId,
      uploadTime: Date.now(),
      status: 'draft'
    };

    this.apps.set(appId, app);
    await this.saveData();

    hilog.info(0x0000, 'EnterpriseDist', `应用已上传: ${app.appName}(${appId})`);
    return appId;
  }

  // 提交审核
  async submitForReview(appId: string): Promise<boolean> {
    const app = this.apps.get(appId);
    if (!app || app.status !== 'draft') return false;

    app.status = 'reviewing';
    await this.saveData();

    hilog.info(0x0000, 'EnterpriseDist', `应用已提交审核: ${appId}`);
    return true;
  }

  // 审核通过
  async approveApp(appId: string): Promise<boolean> {
    const app = this.apps.get(appId);
    if (!app || app.status !== 'reviewing') return false;

    app.status = 'approved';
    await this.saveData();

    hilog.info(0x0000, 'EnterpriseDist', `应用审核通过: ${appId}`);
    return true;
  }

  // 发布应用
  async publishApp(appId: string): Promise<DistributionRecord | null> {
    const app = this.apps.get(appId);
    if (!app || app.status !== 'approved') return null;

    app.status = 'published';

    // 查找目标设备
    const targetDeviceIds: string[] = [];
    this.bindings.forEach((binding, deviceId) => {
      // 检查是否在目标部门
      if (app.targetDepartments.length === 0 || 
          app.targetDepartments.includes(binding.department)) {
        // 检查是否在目标用户
        if (app.targetUsers.length === 0 || 
            app.targetUsers.includes(binding.userId)) {
          targetDeviceIds.push(deviceId);
        }
      }
    });

    const record: DistributionRecord = {
      recordId: `dist_${Date.now()}`,
      appId: appId,
      deviceIds: targetDeviceIds,
      distributionTime: Date.now(),
      status: 'pending',
      installedCount: 0,
      failedCount: 0
    };

    await this.saveData();

    hilog.info(0x0000, 'EnterpriseDist', 
      `应用已发布: ${app.appName}, 目标设备${targetDeviceIds.length}台`);

    return record;
  }

  // 获取用户可用的应用列表
  getAvailableApps(userId: string): EnterpriseApp[] {
    const binding = this.bindings.get(userId);
    if (!binding) return [];

    const availableApps: EnterpriseApp[] = [];
    this.apps.forEach(app => {
      if (app.status !== 'published') return;
      
      // 检查目标部门
      if (app.targetDepartments.length > 0 && 
          !app.targetDepartments.includes(binding.department)) return;
      
      // 检查目标用户
      if (app.targetUsers.length > 0 && 
          !app.targetUsers.includes(userId)) return;

      availableApps.push(app);
    });

    return availableApps;
  }

  // 获取应用详情
  getAppInfo(appId: string): EnterpriseApp | null {
    return this.apps.get(appId) ?? null;
  }

  // 注册设备
  async registerDevice(binding: UserDeviceBinding): Promise<void> {
    this.bindings.set(binding.userId, binding);
    await this.saveData();
    hilog.info(0x0000, 'EnterpriseDist', 
      `设备已注册: ${binding.userName}(${binding.deviceModel})`);
  }

  // 获取分发统计
  getDistributionStats(appId: string): {
    totalTargets: number;
    installed: number;
    failed: number;
    pending: number;
  } {
    const app = this.apps.get(appId);
    if (!app) return { totalTargets: 0, installed: 0, failed: 0, pending: 0 };

    // 模拟统计数据
    return {
      totalTargets: 100,
      installed: 85,
      failed: 5,
      pending: 10
    };
  }

  // 保存数据
  private async saveData(): Promise<void> {
    if (!this.context) return;
    
    try {
      const pref = await preferences.getPreferences(this.context, 'enterprise_dist');
      const appsData = JSON.stringify(Array.from(this.apps.entries()));
      await pref.put('apps', appsData);
      await pref.flush();
    } catch (error) {
      hilog.error(0x0000, 'EnterpriseDist', '保存数据失败');
    }
  }

  // 加载数据
  private async loadData(): Promise<void> {
    if (!this.context) return;
    
    try {
      const pref = await preferences.getPreferences(this.context, 'enterprise_dist');
      const appsData = (await pref.get('apps', '[]')) as string;
      const appsArray = JSON.parse(appsData) as [string, EnterpriseApp][];
      this.apps = new Map(appsArray);
    } catch (error) {
      hilog.warn(0x0000, 'EnterpriseDist', '加载数据失败，使用空数据');
    }
  }
}

企业内部分发平台的页面：

// entry/src/main/ets/pages/EnterpriseStore.ets
// 企业应用商店页面

import { EnterpriseDistribution } from '../utils/EnterpriseDistribution';
import { EnterpriseApp } from '../utils/EnterpriseDistribution';

@Entry
@Component
struct EnterpriseStore {
  @State appList: EnterpriseApp[] = [];
  @State isLoading: boolean = true;

  private distribution = EnterpriseDistribution.getInstance();

  aboutToAppear() {
    this.loadApps();
  }

  async loadApps() {
    this.isLoading = true;
    // 获取当前用户可用的应用
    this.appList = this.distribution.getAvailableApps('user_001');
    this.isLoading = false;
  }

  build() {
    Column({ space: 0 }) {
      // 标题栏
      Row() {
        Text('企业应用中心')
          .fontSize(20)
          .fontWeight(FontWeight.Bold)
          .fontColor('#333333')
      }
      .width('100%')
      .height(56)
      .padding({ left: 16, right: 16 })
      .backgroundColor(Color.White)
      .shadow({ radius: 2, color: '#1A000000', offsetY: 1 })

      if (this.isLoading) {
        // 加载中
        Column() {
          LoadingProgress()
            .width(48)
            .height(48)
            .color('#007DFF')
          Text('加载中...')
            .fontSize(14)
            .fontColor('#999999')
            .margin({ top: 12 })
        }
        .width('100%')
        .layoutWeight(1)
        .justifyContent(FlexAlign.Center)
      } else if (this.appList.length === 0) {
        // 空状态
        Column() {
          Text('暂无可用应用')
            .fontSize(16)
            .fontColor('#999999')
        }
        .width('100%')
        .layoutWeight(1)
        .justifyContent(FlexAlign.Center)
      } else {
        // 应用列表
        List({ space: 12 }) {
          ForEach(this.appList, (app: EnterpriseApp) => {
            ListItem() {
              this.AppItem(app)
            }
          }, (app: EnterpriseApp) => app.appId)
        }
        .width('100%')
        .layoutWeight(1)
        .padding(16)
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }

  // 应用卡片
  @Builder
  AppItem(app: EnterpriseApp) {
    Row({ space: 12 }) {
      // 应用图标
      Column() {
        Text(app.appName.charAt(0))
          .fontSize(24)
          .fontColor(Color.White)
          .fontWeight(FontWeight.Bold)
      }
      .width(56)
      .height(56)
      .borderRadius(12)
      .backgroundColor('#007DFF')
      .justifyContent(FlexAlign.Center)

      // 应用信息
      Column({ space: 4 }) {
        Text(app.appName)
          .fontSize(16)
          .fontWeight(FontWeight.Medium)
          .fontColor('#333333')

        Text(`v${app.versionName}`)
          .fontSize(12)
          .fontColor('#999999')

        Text(app.description)
          .fontSize(13)
          .fontColor('#666666')
          .maxLines(1)
          .textOverflow({ overflow: TextOverflow.Ellipsis })
      }
      .layoutWeight(1)
      .alignItems(HorizontalAlign.Start)

      // 安装按钮
      Button('安装')
        .height(32)
        .fontSize(13)
        .backgroundColor('#007DFF')
        .onClick(() => {
          this.installApp(app);
        })
    }
    .width('100%')
    .padding(12)
    .backgroundColor(Color.White)
    .borderRadius(12)
  }

  // 安装应用
  private installApp(app: EnterpriseApp) {
    hilog.info(0x0000, 'EnterpriseStore', `安装应用: ${app.appName}`);
    // 实际项目中下载并安装应用
  }
}

import { hilog } from '@kit.PerformanceAnalysisKit';

踩坑与注意事项

坑1：企业证书泄露

企业P12证书和密码泄露到网上——任何人都可以用你的证书签名应用，伪装成你的企业应用。

正确做法：

• 证书文件加密存储，不在代码仓库中明文保存
• 限制证书使用人员范围
• 定期轮换证书密码
• 发现泄露立即吊销证书

坑2：企业应用被外部人员安装

企业内部分发的应用没有做设备校验——任何人拿到安装包都能安装，企业数据可能泄露。

正确做法：

• 应用启动时校验设备是否在MDM注册列表中
• 未注册设备拒绝使用
• 结合设备指纹和用户认证双重校验

// 应用启动时校验设备
async checkDeviceAuthorization(): Promise<boolean> {
  const mdmManager = MDMManager.getInstance();
  
  if (!mdmManager.isEnrolled()) {
    // 设备未注册，拒绝使用
    this.showUnauthorizedDialog();
    return false;
  }
  
  return true;
}

坑3：MDM策略与用户隐私冲突

企业要求限制截屏、限制剪贴板、监控应用使用——这些在个人隐私保护法规下可能有法律风险。

正确做法：

• MDM策略只适用于企业管理的设备（BYOD设备需要员工明确同意）
• 在设备注册时告知用户管控范围
• 敏感操作（如远程擦除）需要审计日志

坑4：证书过期导致应用无法使用

企业证书过期了，所有用该证书签名的应用都无法安装新版本——甚至已安装的应用可能无法正常更新。

正确做法：

• 设置证书过期提醒（提前30天、7天、1天）
• 证书续期后重新签名所有应用
• 建立证书管理台账

坑5：内部分发平台没有版本管理

员工A用的是1.0版本，员工B用的是1.2版本——版本混乱导致Bug无法复现，数据格式不兼容。

正确做法：

• 内部分发平台必须有版本管理功能
• 支持强制更新（企业场景下强制更新比C端更合理）
• 版本发布需要审批流程

坑6：忘记处理员工离职

员工离职了，但他的设备上还装着企业应用——他可能把企业数据带走。

正确做法：

• 员工离职时，通过MDM远程擦除企业应用和数据
• 如果是BYOD设备，选择性擦除企业数据，不影响个人数据
• 及时从分发平台移除离职员工

HarmonyOS 6适配说明

HarmonyOS 6对企业内部分发做了几项增强：

1. 企业设备管理API：HarmonyOS 6提供了官方的Enterprise Device Management Kit，支持设备注册、策略下发、远程管控等企业级功能。

// HarmonyOS 6 企业设备管理API
import { enterpriseDeviceManagement } from '@kit.EnterpriseDeviceManagementKit';

// 注册设备
async function enrollDevice(adminName: string, serverUrl: string): Promise<void> {
  const admin = enterpriseDeviceManagement.getEnterpriseAdmin(adminName);
  await admin.enrollDevice({
    serverUrl: serverUrl,
    enrollmentType: 'mdm'
  });
}

// 下发策略
async function applyPolicy(adminName: string): Promise<void> {
  const admin = enterpriseDeviceManagement.getEnterpriseAdmin(adminName);
  
  // 禁止截屏
  await admin.setSecurityPolicy({
    screenshotDisabled: true
  });
  
  // 强制安装应用
  await admin.installApplication({
    bundleName: 'com.enterprise.oa',
    installType: 'force'
  });
}

2. 企业应用签名增强：HarmonyOS 6支持企业应用的多级签名，可以区分不同部门的应用。

3. 数据沙箱隔离：企业应用和个人应用的数据完全隔离，即使安装在同一设备上，企业数据也不会被个人应用访问。

4. 远程擦除API：支持选择性擦除企业数据，不影响个人数据。

5. 合规审计：企业设备管理操作会生成审计日志，满足企业合规要求。

总结

企业内部分发不只是"不上应用市场"那么简单，它是一套完整的企业移动管理方案。核心记住三点：

1. 证书安全是底线：企业证书泄露的后果比你想的严重得多
2. 设备管控要到位：MDM不是可选项，是企业分发的必需品
3. 数据安全是核心：从分发到使用到离职，每个环节都要考虑数据安全