【成长纪实】三个月从小白到鸿蒙开发者，分享我的成长之路

# 内存配置优化
-Xms2048m
-Xmx4096m
-XX:ReservedCodeCacheSize=512m

// 入口文件：entry/src/main/ets/entryability/EntryAbility.ts
import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';

export default class EntryAbility extends UIAbility {
  onCreate(want, launchParam) {
    console.info('[EntryAbility] onCreate');
  }

  onWindowStageCreate(windowStage: window.WindowStage) {
    windowStage.loadContent('pages/Index', (err, data) => {
      if (err.code) {
        console.error('Failed to load content. Cause: ' + JSON.stringify(err));
        return;
      }
      console.info('Succeeded in loading content. Data: ' + JSON.stringify(data));
    });
  }
}

// 页面文件：entry/src/main/ets/pages/Index.ets
@Entry
@Component
struct Index {
  @State message: string = 'Hello HarmonyOS!';

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
          .fontColor(Color.Blue)
      }
      .width('100%')
    }
    .height('100%')
  }
}

// TypeScript静态类型
interface User {
  id: number;
  name: string;
  email?: string; // 可选属性
}

function createUser(userData: User): User {
  return {
    id: userData.id,
    name: userData.name,
    email: userData.email || ''
  };
}

@Entry
@Component
struct MyComponent {
  @State count: number = 0;
  @Prop title: string;
  @Link globalData: string;
  
  build() {
    // UI构建逻辑
  }
}

@Component
struct CounterComponent {
  @State private count: number = 0;
  
  private increment() {
    this.count++;
  }
  
  build() {
    Column() {
      Text(`Count: ${this.count}`)
        .fontSize(24)
      
      Button('Increment')
        .onClick(() => this.increment())
    }
  }
}

// 声明式（ArkUI）
@Component
struct UserProfile {
  @State user: User = getUser();
  
  build() {
    Column() {
      Image(this.user.avatar)
        .width(100)
        .height(100)
        .borderRadius(50)
      
      Text(this.user.name)
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
    }
  }
}

// 命令式（传统Android）
// TextView nameView = findViewById(R.id.name);
// nameView.setText(user.getName());
// nameView.setTextSize(18);

@Component
export struct CustomCard {
  @Prop title: string;
  @Prop content: string;
  @BuilderParam cardContent: () => void;
  
  build() {
    Column() {
      Text(this.title)
        .fontSize(20)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 10 })
      
      if (this.cardContent) {
        this.cardContent();
      } else {
        Text(this.content)
          .fontSize(16)
      }
    }
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(8)
    .shadow({ radius: 4, color: Color.Gray, offsetX: 2, offsetY: 2 })
  }
}

@Component
struct FlexLayoutDemo {
  build() {
    Flex({ 
      direction: FlexDirection.Row, 
      justifyContent: FlexAlign.SpaceBetween,
      alignItems: ItemAlign.Center 
    }) {
      Text('Left')
        .flexGrow(1)
      
      Text('Center')
        .flexGrow(2)
      
      Text('Right')
        .flexGrow(1)
    }
    .width('100%')
    .height(60)
  }
}

@Component
struct AnimationDemo {
  @State rotateAngle: number = 0;
  
  build() {
    Column() {
      Image($r('app.media.icon'))
        .width(100)
        .height(100)
        .rotate({ angle: this.rotateAngle })
        .animation({
          duration: 1000,
          curve: Curve.EaseInOut,
          iterations: -1
        })
      
      Button('Start Animation')
        .onClick(() => {
          this.rotateAngle = this.rotateAngle === 0 ? 360 : 0;
        })
    }
  }
}

import deviceManager from '@ohos.distributedHardware.deviceManager';

class DeviceDiscovery {
  private dmInstance: deviceManager.DeviceManager;
  
  async initDeviceManager() {
    try {
      this.dmInstance = deviceManager.createDeviceManager('com.example.myapp');
      this.dmInstance.on('deviceStateChange', this.onDeviceStateChange);
    } catch (error) {
      console.error('Init device manager failed:', error);
    }
  }
  
  private onDeviceStateChange = (data) => {
    console.info('Device state changed:', data);
  }
  
  async startDeviceDiscovery() {
    const discoverParam = {
      subscribeId: 1,
      mode: 0xAA,
      medium: 0,
      freq: 2,
      isSameAccount: false,
      isWakeRemote: false,
      capability: 1
    };
    
    try {
      this.dmInstance.startDeviceDiscovery(discoverParam);
    } catch (error) {
      console.error('Start device discovery failed:', error);
    }
  }
}

import featureAbility from '@ohos.ability.featureAbility';

class AppMigration {
  async migrateToDevice(deviceId: string) {
    const want = {
      bundleName: 'com.example.myapp',
      abilityName: 'MainAbility',
      deviceId: deviceId,
      parameters: {
        migrationData: JSON.stringify(this.getCurrentState())
      }
    };
    
    try {
      await featureAbility.startAbility(want);
      console.info('Migration successful');
    } catch (error) {
      console.error('Migration failed:', error);
    }
  }
  
  private getCurrentState() {
    // 获取当前应用状态
    return {
      currentPage: 'HomePage',
      userData: this.getUserData(),
      timestamp: Date.now()
    };
  }
}

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   手机端应用     │    │   平板端应用     │    │  智慧屏应用     │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                 │
                    ┌─────────────────┐
                    │  分布式软总线   │
                    └─────────────────┘
                                 │
                    ┌─────────────────┐
                    │   云端服务      │
                    └─────────────────┘

@Entry
@Component
struct HomePage {
  @State deviceList: Device[] = [];
  @State selectedRoom: string = 'living_room';
  
  aboutToAppear() {
    this.loadDevices();
  }
  
  build() {
    Column() {
      // 顶部导航
      this.buildTopNavigation()
      
      // 房间选择
      this.buildRoomSelector()
      
      // 设备列表
      this.buildDeviceGrid()
      
      // 底部操作栏
      this.buildBottomActions()
    }
    .width('100%')
    .height('100%')
    .backgroundColor($r('app.color.background'))
  }
  
  @Builder
  buildTopNavigation() {
    Row() {
      Text('智能家居')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .fontColor($r('app.color.primary'))
      
      Blank()
      
      Button() {
        Image($r('app.media.settings'))
          .width(24)
          .height(24)
      }
      .backgroundColor(Color.Transparent)
      .onClick(() => this.navigateToSettings())
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 12, bottom: 12 })
  }
  
  @Builder
  buildDeviceGrid() {
    Grid() {
      ForEach(this.deviceList, (device: Device) => {
        GridItem() {
          DeviceCard({ device: device })
        }
      })
    }
    .columnsTemplate('1fr 1fr')
    .rowsGap(12)
    .columnsGap(12)
    .padding(16)
  }
}

@Component
struct DeviceCard {
  @Prop device: Device;
  @State isOn: boolean = false;
  
  build() {
    Column() {
      Image(this.device.icon)
        .width(48)
        .height(48)
        .margin({ bottom: 8 })
      
      Text(this.device.name)
        .fontSize(16)
        .fontWeight(FontWeight.Medium)
        .margin({ bottom: 4 })
      
      Text(this.device.status)
        .fontSize(12)
        .fontColor($r('app.color.text_secondary'))
        .margin({ bottom: 12 })
      
      Toggle({ type: ToggleType.Switch, isOn: this.isOn })
        .onChange((isOn: boolean) => {
          this.toggleDevice(isOn);
        })
    }
    .width('100%')
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(12)
    .shadow({ radius: 4, color: Color.Gray, offsetY: 2 })
    .onClick(() => this.showDeviceDetail())
  }
  
  private toggleDevice(isOn: boolean) {
    this.isOn = isOn;
    // 发送控制命令到设备
    DeviceController.toggleDevice(this.device.id, isOn);
  }
}

class DeviceManager {
  private static instance: DeviceManager;
  private devices: Map<string, Device> = new Map();
  private eventEmitter: EventEmitter = new EventEmitter();
  
  static getInstance(): DeviceManager {
    if (!DeviceManager.instance) {
      DeviceManager.instance = new DeviceManager();
    }
    return DeviceManager.instance;
  }
  
  async addDevice(deviceInfo: DeviceInfo): Promise<Device> {
    try {
      const device = await this.connectToDevice(deviceInfo);
      this.devices.set(device.id, device);
      this.eventEmitter.emit('deviceAdded', device);
      return device;
    } catch (error) {
      console.error('Add device failed:', error);
      throw error;
    }
  }
  
  async removeDevice(deviceId: string): Promise<void> {
    const device = this.devices.get(deviceId);
    if (device) {
      await this.disconnectDevice(device);
      this.devices.delete(deviceId);
      this.eventEmitter.emit('deviceRemoved', deviceId);
    }
  }
  
  async controlDevice(deviceId: string, command: DeviceCommand): Promise<void> {
    const device = this.devices.get(deviceId);
    if (!device) {
      throw new Error('Device not found');
    }
    
    try {
      await device.executeCommand(command);
      this.eventEmitter.emit('deviceStateChanged', { deviceId, command });
    } catch (error) {
      console.error('Control device failed:', error);
      throw error;
    }
  }
  
  private async connectToDevice(deviceInfo: DeviceInfo): Promise<Device> {
    // 设备连接逻辑
    const connection = await DeviceConnector.connect(deviceInfo);
    return new Device(deviceInfo, connection);
  }
}

class SceneManager {
  private scenes: Map<string, Scene> = new Map();
  
  async createScene(sceneConfig: SceneConfig): Promise<Scene> {
    const scene = new Scene(sceneConfig);
    this.scenes.set(scene.id, scene);
    await this.saveScene(scene);
    return scene;
  }
  
  async executeScene(sceneId: string): Promise<void> {
    const scene = this.scenes.get(sceneId);
    if (!scene) {
      throw new Error('Scene not found');
    }
    
    try {
      await scene.execute();
      console.info(`Scene ${scene.name} executed successfully`);
    } catch (error) {
      console.error('Execute scene failed:', error);
      throw error;
    }
  }
  
  async scheduleScene(sceneId: string, schedule: Schedule): Promise<void> {
    const scene = this.scenes.get(sceneId);
    if (!scene) {
      throw new Error('Scene not found');
    }
    
    scene.setSchedule(schedule);
    await this.saveScene(scene);
  }
}

import preferences from '@ohos.data.preferences';

class LocalStorage {
  private static instance: LocalStorage;
  private preferences: preferences.Preferences;
  
  static getInstance(): LocalStorage {
    if (!LocalStorage.instance) {
      LocalStorage.instance = new LocalStorage();
    }
    return LocalStorage.instance;
  }
  
  async init(): Promise<void> {
    try {
      this.preferences = await preferences.getPreferences(
        getContext(), 
        'smart_home_data'
      );
    } catch (error) {
      console.error('Init preferences failed:', error);
    }
  }
  
  async saveDevices(devices: Device[]): Promise<void> {
    try {
      const devicesData = JSON.stringify(devices);
      await this.preferences.put('devices', devicesData);
      await this.preferences.flush();
    } catch (error) {
      console.error('Save devices failed:', error);
    }
  }
  
  async loadDevices(): Promise<Device[]> {
    try {
      const devicesData = await this.preferences.get('devices', '[]');
      return JSON.parse(devicesData as string);
    } catch (error) {
      console.error('Load devices failed:', error);
      return [];
    }
  }
}

import distributedData from '@ohos.data.distributedData';

class DistributedDataManager {
  private kvStore: distributedData.KVStore;
  
  async init(): Promise<void> {
    try {
      const kvManagerConfig = {
        bundleName: 'com.example.smarthome',
        userInfo: {
          userId: '0',
          userType: 0
        }
      };
      
      const kvManager = distributedData.createKVManager(kvManagerConfig);
      
      const options = {
        createIfMissing: true,
        encrypt: false,
        backup: false,
        autoSync: true,
        kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION,
        schema: '',
        securityLevel: distributedData.SecurityLevel.S2
      };
      
      this.kvStore = await kvManager.getKVStore('smart_home_store', options);
      this.setupSyncListener();
    } catch (error) {
      console.error('Init distributed data failed:', error);
    }
  }
  
  async syncDeviceData(deviceId: string, data: any): Promise<void> {
    try {
      const key = `device_${deviceId}`;
      const value = JSON.stringify(data);
      await this.kvStore.put(key, value);
    } catch (error) {
      console.error('Sync device data failed:', error);
    }
  }
  
  private setupSyncListener(): void {
    this.kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_ALL, (data) => {
      console.info('Data changed:', data);
      this.handleDataChange(data);
    });
  }
}

@Component
struct OptimizedComponent {
  private timer: number = -1;
  private subscription: Subscription;
  
  aboutToAppear() {
    // 设置定时器
    this.timer = setInterval(() => {
      this.updateData();
    }, 1000);
    
    // 订阅数据变化
    this.subscription = DataService.subscribe(this.onDataChange);
  }
  
  aboutToDisappear() {
    // 清理定时器
    if (this.timer !== -1) {
      clearInterval(this.timer);
      this.timer = -1;
    }
    
    // 取消订阅
    if (this.subscription) {
      this.subscription.unsubscribe();
      this.subscription = null;
    }
  }
  
  build() {
    // UI构建逻辑
  }
}

class DeviceObjectPool {
  private pool: Device[] = [];
  private maxSize: number = 50;
  
  acquire(): Device {
    if (this.pool.length > 0) {
      return this.pool.pop();
    }
    return new Device();
  }
  
  release(device: Device): void {
    if (this.pool.length < this.maxSize) {
      device.reset();
      this.pool.push(device);
    }
  }
}

@Component
struct OptimizedDeviceList {
  @State deviceList: Device[] = [];
  private scroller: Scroller = new Scroller();
  
  build() {
    List({ scroller: this.scroller }) {
      LazyForEach(this.deviceDataSource, (device: Device) => {
        ListItem() {
          DeviceCard({ device: device })
        }
        .reuseId(device.type) // 启用组件复用
      })
    }
    .cachedCount(5) // 缓存数量
    .onScrollIndex((start, end) => {
      // 懒加载逻辑
      this.loadMoreIfNeeded(end);
    })
  }
}

@Component
struct OptimizedImage {
  @Prop src: string;
  @State isLoading: boolean = true;
  @State hasError: boolean = false;
  
  build() {
    Stack() {
      if (this.isLoading) {
        LoadingIndicator()
      } else if (this.hasError) {
        Image($r('app.media.placeholder'))
          .width('100%')
          .height('100%')
      } else {
        Image(this.src)
          .width('100%')
          .height('100%')
          .onComplete(() => {
            this.isLoading = false;
          })
          .onError(() => {
            this.isLoading = false;
            this.hasError = true;
          })
      }
    }
  }
}

class Logger {
  private static readonly TAG = 'SmartHome';
  
  static debug(message: string, ...args: any[]): void {
    console.debug(`[${this.TAG}] ${message}`, ...args);
  }
  
  static info(message: string, ...args: any[]): void {
    console.info(`[${this.TAG}] ${message}`, ...args);
  }
  
  static error(message: string, error?: Error): void {
    console.error(`[${this.TAG}] ${message}`, error);
  }
}

class PerformanceMonitor {
  private static startTimes: Map<string, number> = new Map();
  
  static startTimer(label: string): void {
    this.startTimes.set(label, Date.now());
  }
  
  static endTimer(label: string): number {
    const startTime = this.startTimes.get(label);
    if (startTime) {
      const duration = Date.now() - startTime;
      console.info(`[Performance] ${label}: ${duration}ms`);
      this.startTimes.delete(label);
      return duration;
    }
    return 0;
  }
}

初级开发者 → 中级开发者 → 高级开发者 → 技术专家
     ↓           ↓           ↓           ↓
基础应用开发  复杂功能实现  架构设计能力  技术创新引领