鸿蒙特色实战2

news2024/12/26 1:28:30

服务卡片开发

创建服务卡片

创建一个新的工程后,可以通过如下方法进行创建服务卡片:

  1. 创建服务卡片包括如下两种方式:

    • 选择模块(如entry模块)下的任意文件,单击菜单栏File > New > Service Widget创建服务卡片。
    • 选择模块(如entry模块)下的任意文件,单击右键 > New > Service Widget创建服务卡片。
  2. Choose a Template for Your Service Widget界面中,选择卡片模板,单击Next

在这里插入图片描述

  1. Configure Your Service Widget界面中,配置卡片的基本信息,包括:

  2. 单击Finish完成卡片的创建。创建完成后,工具会自动创建出服务卡片的布局文件,并在form_config.json文件中写入服务卡片的属性字段,关于各字段的说明请参考配置文件说明。

    在这里插入图片描述

  3. 卡片创建完成后,请根据开发指导,完成服务卡片的开发,详情请参考服务卡片开发指南。

  4. 本项目开发两个卡片,分别为 2X2 和 4X4卡片,2X2卡片为一张Logo图片,4X4卡片为新闻列表。如图:

    2X2卡片4X4卡片
    在这里插入图片描述

|在这里插入图片描述|

2X2卡片开发

2X2卡片比较简单,就是一张Logo图片,点击跳转到主界面,全部代码以下:

@Entry
@Component
struct WidgetCard {

  readonly ACTION_TYPE: string = 'router';
  readonly ABILITY_NAME: string = 'EntryAbility';
  readonly FULL_WIDTH_PERCENT: string = '100%';
  readonly FULL_HEIGHT_PERCENT: string = '100%';

  build() {
    Stack() {
        // Logo图片
      Image($r("app.media.startIcon"))
        .width(this.FULL_WIDTH_PERCENT)
        .height(this.FULL_HEIGHT_PERCENT)
        .objectFit(ImageFit.Contain)
    }
    .width(this.FULL_WIDTH_PERCENT)
    .height(this.FULL_HEIGHT_PERCENT)
    .onClick(() => {
        // 点击跳转到主界面
      postCardAction(this, {
        action: this.ACTION_TYPE,
        abilityName: this.ABILITY_NAME
      });
    })
  }
}

4X4卡片开发

4X4卡片相对复杂些,获取网络上新闻列表数组,循环数据显示出现,点击每条新闻,把新闻Id传过去,获取相应的详情新闻。

  1. 卡片页面布局代码:

    Column() {
          Row() {
            Row() {
              Text('Days Matter')
                .fontColor(0xF55A42)
                .fontWeight(700)
                .fontSize(18)
            }
            .height(40)
            .justifyContent(FlexAlign.Start)
    
            Text('更多 >')
              .width(64)
              .height("100%")
              .textAlign(TextAlign.End)
              .onClick(() => {
                console.info(`xx 跳转到更多`)
                postCardAction(this, {
                  action: this.ACTION_TYPE,
                  abilityName: this.ABILITY_NAME,
                  params: {
                    'id': '-1',
                    'targetPage': 'Index'
                  }
                });
              })
          }
          .width("100%")
          .height(40)
          .justifyContent(FlexAlign.SpaceBetween)
    
          List({ space: 20, initialIndex: 0 }) {
            ForEach(this.newsArticles, (item:object) => {
              ListItem() {
                Text(item['title'])
                  .width("100%")
                  .height(20)
                  .fontSize(14)
                  .padding({ left: 10, right: 10})
                  .textOverflow({ overflow: TextOverflow.Ellipsis })
                  .fontWeight(FontWeight.Regular)
                  .maxLines(this.MAX_LINES)
              }
              .onClick(() => {
                this.routerPage(item['id'])
              })
            })
          }
          .listDirection(Axis.Vertical)
          .divider({ strokeWidth: 1, color: "#E4EBF5", startMargin: 10, endMargin: 10 })
          .edgeEffect(EdgeEffect.Spring)
          .margin({ top: 4 })
          .padding( { bottom: 40 })
    
        }
        .width("100%")
        .height("100%")
        .justifyContent(FlexAlign.Start)
        .alignItems(HorizontalAlign.Start)
        .padding($r('app.float.column_padding'))
    
  2. 路由跳转代码:

      routerPage(uid: string) {
        console.info(`xx 跳转文章Id: ${uid}`)
        postCardAction(this, {
          action: this.ACTION_TYPE,
          abilityName: this.ABILITY_NAME,
          params: {
            'id': uid,
            'targetPage': 'Detail'
          }
        });
      }
    
  3. 卡片页面中使用LocalStorageProp装饰需要刷新的卡片数据

    let storageCard = new LocalStorage();
    
    @Entry(storageCard)
    @Component
    struct Widget4Card {
    
      @LocalStorageProp('newsArticles') newsArticles: Array<object> = [];
        ......
    }
    
  4. 4x4服务卡片完整代码如下:

    let storageCard = new LocalStorage();
    
    @Entry(storageCard)
    @Component
    struct Widget4Card {
    
      @LocalStorageProp('newsArticles') newsArticles: Array<object> = [];
    
      readonly MAX_LINES: number = 1;
      readonly ACTION_TYPE: string = 'router';
      readonly ABILITY_NAME: string = 'EntryAbility';
    
      routerPage(uid: string) {
        console.info(`xx 跳转文章Id: ${uid}`)
        postCardAction(this, {
          action: this.ACTION_TYPE,
          abilityName: this.ABILITY_NAME,
          params: {
            'id': uid,
            'targetPage': 'Detail'
          }
        });
      }
    
      build() {
        Column() {
          Row() {
            Row() {
              Text('Days Matter')
                .fontColor(0xF55A42)
                .fontWeight(700)
                .fontSize(18)
            }
            .height(40)
            .justifyContent(FlexAlign.Start)
    
            Text('更多 >')
              .width(64)
              .height("100%")
              .textAlign(TextAlign.End)
              .onClick(() => {
                console.info(`xx 跳转到更多`)
                postCardAction(this, {
                  action: this.ACTION_TYPE,
                  abilityName: this.ABILITY_NAME,
                  params: {
                    'id': '-1',
                    'targetPage': 'Index'
                  }
                });
              })
          }
          .width("100%")
          .height(40)
          .justifyContent(FlexAlign.SpaceBetween)
    
          List({ space: 20, initialIndex: 0 }) {
            ForEach(this.newsArticles, (item:object) => {
              ListItem() {
                Text(item['title'])
                  .width("100%")
                  .height(20)
                  .fontSize(14)
                  .padding({ left: 10, right: 10})
                  .textOverflow({ overflow: TextOverflow.Ellipsis })
                  .fontWeight(FontWeight.Regular)
                  .maxLines(this.MAX_LINES)
              }
              .onClick(() => {
                this.routerPage(item['id'])
              })
            })
          }
          .listDirection(Axis.Vertical)
          .divider({ strokeWidth: 1, color: "#E4EBF5", startMargin: 10, endMargin: 10 })
          .edgeEffect(EdgeEffect.Spring)
          .margin({ top: 4 })
          .padding( { bottom: 40 })
    
        }
        .width("100%")
        .height("100%")
        .justifyContent(FlexAlign.Start)
        .alignItems(HorizontalAlign.Start)
        .padding($r('app.float.column_padding'))
    
      }
    }
    

卡片保存开发

  1. 根据配置文件form_config.json配置定时更新卡片数据

    "updateEnabled": true, // 表示卡片是否支持周期性刷新(包含定时刷新和定点刷新)
    "scheduledUpdateTime": "10:30",	// 表示卡片的定点刷新的时刻,采用24小时制,精确到分钟。
    "updateDuration": 1,	// 表示卡片定时刷新的更新周期,单位为30分钟,取值为自然数。
    
  2. 卡片存储

    2.1 在EntryAbility.ets里onCreate回调函数初始化存储卡片数据库和表。

    onCreate() {
            // 初始化保存卡片数据库
        RdbUtils.initDb(this.context, Const.RDB_NAME.dbName ? Const.RDB_NAME.dbName : '');
        await RdbUtils.createDb();
        RdbUtils.createTable(Const.FORM_INFO.tableName ? Const.FORM_INFO.tableName : '', columnFormInfoList)
          .catch((err: Error) => {
            LogUtil.error(`RdbHelper formInfo err : ${JSON.stringify(err)}`);
          });
    }
    

    2.2 在EntryFormAbility.ets里onAddForm回调存储添加的卡片信息

    onAddForm(want: Want) {
        LogUtil.info('xx 开始添加卡片')
        let parameters = want.parameters;
        if (parameters) {
          let formId: string = parameters[Const.FORM_PARAM_IDENTITY_KEY] as string;
          let formName: string = parameters[Const.FORM_PARAM_NAME_KEY] as string;
          let formDimension: number = parameters[Const.FORM_PARAM_DIMENSION_KEY] as number;
          let formInfo: FormInfoModel = {
            formId: formId,
            formName: formName,
            formDimension: formDimension
          };
          LogUtil.info('xx 开始卡片保存到数据库')
          FormUtils.insertFormData(this.context, formInfo);
          LogUtil.info('xx 结束卡片保存到数据库')
        }
    
        LogUtil.info('xx 卡片创建成功')
        return formBindingData.createFormBindingData({
          'latestArticles': []
        });
      }
    

    2.3 卡片周期性刷新时,调用卡片onUpdateForm更新回调

      onUpdateForm(formId: string) {
        // Called to notify the form provider to update a specified form.
        FormUtils.updateCards(this.context);
      }
    

    2.4 卡片移除时,调用卡片onRemoveForm回调

      onRemoveForm(formId: string) {
        // Called to notify the form provider that a specified form has been destroyed.
        FormUtils.deleteFormData(this.context, formId);
      }
    

卡片保存在关系型数据库

接口RdbHelper

定义一个关系型数据库操作接口RdbHelper

import dataRdb from '@ohos.data.relationalStore';
import ColumnInfo from '../model/ColumnInfo';

export interface RdbHelper {

  getDbName(): string;

  getRdb(context: Context): Promise<RdbHelper>;

  executeSql(sql: string): Promise<void>;

  createTable(tableName: string, columns: Array<ColumnInfo>): Promise<void>;

  deleteTable(tableName: string): Promise<void>;

  addTableColumn(tableName: string, column: ColumnInfo): Promise<void>;

  insert(tableName: string, values: dataRdb.ValuesBucket | Array<dataRdb.ValuesBucket>): Promise<number>;

  update(values: dataRdb.ValuesBucket, rdbPredicates: dataRdb.RdbPredicates): Promise<number>;

  query(rdbPredicates: dataRdb.RdbPredicates, columns?: Array<string>): Promise<dataRdb.ResultSet>;

  queryAll(tableName: string): Promise<dataRdb.ResultSet>;

  queryBySql(sql: string, bindArgs?: Array<dataRdb.ValueType>): Promise<dataRdb.ResultSet>;

  delete(rdbPredicates: dataRdb.RdbPredicates): Promise<number>;
}

实现类RdbHelperImp

定义一个实现RdbHelper接口的实现类RdbHelperImp

import { LogUtil } from '../../utils/LogUtil';
import { RdbHelper } from './RdbHelper';
import dataRdb from '@ohos.data.relationalStore';
import ColumnInfo from '../model/ColumnInfo';
import tableHelper from './TableHelper';

export class RdbHelperImp implements RdbHelper {
  private mDatabaseName: string;
  private rdbStore: dataRdb.RdbStore = {} as dataRdb.RdbStore;
  private storeConfig: dataRdb.StoreConfig = {  name: '', securityLevel: dataRdb.SecurityLevel.S1 } as dataRdb.StoreConfig;

  constructor(databaseName: string) {
    this.mDatabaseName = databaseName;
  }

  getDbName(): string {
    return this.mDatabaseName;
  }

  getRdb(context: Context): Promise<RdbHelper> {
    this.storeConfig = {
      name: this.mDatabaseName, securityLevel: dataRdb.SecurityLevel.S1
    };
    return new Promise<RdbHelper>((success, error) => {
      dataRdb.getRdbStore(context, this.storeConfig).then(dbStore => {
        this.rdbStore = dbStore;
        success(this);
      }).catch((err: Error) => {
        LogUtil.error(`initRdb err : ${JSON.stringify(err)}`);
        error(err);
      })
    })
  }

  executeSql(sql: string): Promise<void> {
    LogUtil.info(`executeSql sql : ${sql}`);
    return this.rdbStore.executeSql(sql);
  }

  createTable(tableName: string, columns: Array<ColumnInfo>): Promise<void> {
    LogUtil.info(`createTable tableName : ${tableName}, columns : ${JSON.stringify(columns)}`);
    let createTableSql = tableHelper.createTableSql(tableName, columns);
    return this.executeSql(createTableSql);
  }

  deleteTable(tableName: string): Promise<void> {
    LogUtil.info(`deleteTable tableName : ${tableName}`);
    let deleteTableSql = tableHelper.deleteTableSql(tableName);
    return this.executeSql(deleteTableSql);
  }

  addTableColumn(tableName: string, column: ColumnInfo): Promise<void> {
    LogUtil.info(`addTableColumn tableName : ${tableName}, column : ${JSON.stringify(column)}`);
    let addTableColumnSql = tableHelper.addTableColumnSql(tableName, column);
    return this.executeSql(addTableColumnSql);
  }

  insert(tableName: string, values: dataRdb.ValuesBucket | Array<dataRdb.ValuesBucket>): Promise<number> {
    return new Promise<number>((success, error) => {
      LogUtil.info(`insert tableName : ${tableName}, values : ${JSON.stringify(values)}`);
      if (!values) {
        LogUtil.info(`insert failed, values is undefined`);
        error(0);
        return;
      }
      if (values instanceof Array) {
        LogUtil.info(`insert values isArray = ${values.length}`);
        this.rdbStore.beginTransaction();
        this.saveArray(tableName, values).then(data => {
          LogUtil.info(`insert success, data : ${JSON.stringify(data)}`);
          success(data);
          this.rdbStore.commit();
        }).catch((err: Error) => {
          LogUtil.error(`insert failed, err : ${err}`);
          error(err);
          this.rdbStore.commit();
        })
      } else {
        this.rdbStore.insert(tableName, values).then(data => {
          LogUtil.info(`insert success id : ${data}`);
          success(data);
          this.rdbStore.commit();
        }).catch((err: Error) => {
          LogUtil.error(`insert failed, err : ${JSON.stringify(err)}`);
          error(err);
          this.rdbStore.commit();
        })
      }
    })
  }

  private saveArray(tableName: string, values: Array<dataRdb.ValuesBucket>): Promise<number> {
    return new Promise<number>((success, error) => {
      if (!values || values.length === 0) {
        error(0);
        return;
      }
      let index = 0
      let callback = (data: number, err: Error) => {
        if (err) {
          LogUtil.info(`saveArray failed, err : ${err}`);
          error(err);
          return;
        }
        if (data) {
          if (index < values.length - 1) {
            this.saveData(tableName, values, ++index, callback);
          } else {
            success(data);
          }
        }
      }
      this.saveData(tableName, values, index, callback);
    })
  }

  private saveData(tableName: string, values: Array<dataRdb.ValuesBucket>, index: number, callback: Function): void   {
    LogUtil.info(`saveData tableName : ${tableName}, index : ${JSON.stringify(index)}`);
    this.rdbStore.insert(tableName, values[index]).then((data: number) => {
      LogUtil.info(`saveData success id : ${data}`);
      callback(data);
    }).catch((err: Error) => {
      LogUtil.error(`saveData failed, err : ${err}`);
      callback(err);
    })
  }

  update(values: dataRdb.ValuesBucket, rdbPredicates: dataRdb.RdbPredicates): Promise<number> {
    return this.rdbStore.update(values, rdbPredicates);
  }

  query(rdbPredicates: dataRdb.RdbPredicates, columns?: Array<string>): Promise<dataRdb.ResultSet> {
    LogUtil.info(`query rdbPredicates : ${JSON.stringify(rdbPredicates)}`);
    return this.rdbStore.query(rdbPredicates, columns);
  }

  queryAll(tableName: string): Promise<dataRdb.ResultSet> {
    LogUtil.info(`queryAllSize tableName : ${tableName}`);
    return this.rdbStore.querySql(`select * from ${tableName}`);
  }

  queryBySql(sql: string, bindArgs?: Array<dataRdb.ValueType>): Promise<dataRdb.ResultSet> {
    LogUtil.info(`queryBySql sql : ${sql}`);
    return this.rdbStore.querySql(sql, bindArgs);
  }

  delete(rdbPredicates: dataRdb.RdbPredicates): Promise<number> {
    LogUtil.info(`delete rdbPredicates : ${JSON.stringify(rdbPredicates)}`);
    return this.rdbStore.delete(rdbPredicates);
  }
}

操作类TableHelper

定义表操作类TableHelper

import { LogUtil } from '../../utils/LogUtil';
import ColumnInfo from '../model/ColumnInfo';

class TableHelper {
  createTableSql(tableName: string, columns: Array<ColumnInfo>): string {
    let sql = `create table if not exists ${tableName}(`;
    for (let column of columns) {
      sql = sql.concat(`${column.name} ${column.type}`);
      sql = sql.concat(`${column.length && column.length > 0 ? `(${column.length})` : ''}`);
      sql = sql.concat(`${column.primary ? ' primary key' : ''}`);
      sql = sql.concat(`${column.autoincrement ? ' autoincrement' : ''}`);
      sql = sql.concat(`${column.nullable ? '' : ' not null'}`);
      sql = sql.concat(', ');
    }
    sql = `${sql.substring(0, sql.length - 2)})`;
    return sql;
  }

  addTableColumnSql(tableName: string, column: ColumnInfo): string {
    LogUtil.info(`TableHelper updateTableSql : ${JSON.stringify(column)}`);
    let sql = `alter table ${tableName} add `;
    sql = sql.concat(`${column.name} ${column.type}`);
    sql = sql.concat(`${column.length && column.length > 0 ? `(${column.length})` : ''}`);
    LogUtil.info(`TableHelper updateTableSql : ` + sql);
    return sql;
  }

  deleteTableSql(tableName: string): string {
    LogUtil.info(`TableHelper deleteTableSql : ${JSON.stringify(tableName)}`);
    return `drop table if exists ${tableName}`;
  }
}

const tableHelper = new TableHelper();
export default tableHelper;

公共操作类RdbUtils

import { LogUtil } from '../../utils/LogUtil';
import ColumnInfo from '../model/ColumnInfo';
import { RdbHelper } from './RdbHelper';
import { RdbHelperImp } from './RdbHelperImp';
import dataRdb from '@ohos.data.relationalStore';

let dbContext: Context;
let mDatabaseName: string = '';

export class RdbUtils {
  private rdbHelpers = new Map<string, RdbHelper>();

  initDb(context: Context, databaseName: string) {
    dbContext = context;
    mDatabaseName = databaseName;
  }

  createDb(): Promise<RdbHelper> {
    return new Promise<RdbHelper>((success, error) => {
      let dbName = mDatabaseName;
      if (!dbContext || !dbName || dbName.length === 0) {
        error("init err");
        return;
      }
      let dbHelper = this.rdbHelpers.get(dbName);
      if (!dbHelper) {
        LogUtil.info(`initRdb  RdbUtils success`);
        let rdbHelper: RdbHelper = new RdbHelperImp(dbName);
        rdbHelper.getRdb(dbContext).then(data => {
          this.rdbHelpers.set(dbName, data);
          success(data);
        }).catch((err: Error) => {
          error(err);
        })
      } else {
        success(dbHelper);
      }
    })
  }

  deleteDb(context: Context, dbName: string): Promise<void> {
    this.rdbHelpers.delete(dbName);
    return dataRdb.deleteRdbStore(context, dbName);
  }

  createTable(tableName: string, columns: Array<ColumnInfo>): Promise<void> {
    return this.createDb().then(dbHelper => {
      return dbHelper.createTable(tableName, columns);
    });
  }

  isCreateTable(tableName: string, columns: Array<ColumnInfo>): Promise<boolean> {
    return this.createTable(tableName, columns).then(() => {
      return true;
    }).catch((error: Error) => {
      LogUtil.error('RdbUtils', 'create table error ' + JSON.stringify(error));
      return false;
    });
  }

  deleteTable(tableName: string): Promise<void> {
    return this.createDb().then(dbHelper => {
      return dbHelper.deleteTable(tableName);
    })
  }

  executeSql(sql: string): Promise<void> {
    return this.createDb().then(dbHelper => {
      return dbHelper.executeSql(sql);
    })
  }

  addTableColumn(tableName: string, column: ColumnInfo): Promise<void> {
    return this.createDb().then(dbHelper => {
      return dbHelper.addTableColumn(tableName, column);
    })
  }

  insert(tableName: string, values: dataRdb.ValuesBucket | Array<dataRdb.ValuesBucket>): Promise<number> {
    return this.createDb().then(dbHelper => {
      return dbHelper.insert(tableName, values);
    })
  }

  update(values: dataRdb.ValuesBucket, rdbPredicates: dataRdb.RdbPredicates): Promise<number> {
    return this.createDb().then(dbHelper => {
      return dbHelper.update(values, rdbPredicates);
    })
  }

  query(rdbPredicates: dataRdb.RdbPredicates, columns?: Array<string>): Promise<dataRdb.ResultSet> {
    return this.createDb().then(dbHelper => {
      return dbHelper.query(rdbPredicates, columns);
    })
  }

  queryAll(tableName: string): Promise<dataRdb.ResultSet> {
    return this.createDb().then(dbHelper => {
      return dbHelper.queryAll(tableName);
    })
  }

  queryBySql(sql: string, bindArgs?: Array<dataRdb.ValueType>): Promise<dataRdb.ResultSet> {
    return this.createDb().then(dbHelper => {
      return dbHelper.queryBySql(sql, bindArgs);
    })
  }

  del(rdbPredicates: dataRdb.RdbPredicates): Promise<number> {
    return this.createDb().then(dbHelper => {
      return dbHelper.delete(rdbPredicates);
    })
  }
}

let rdbUtils = new RdbUtils();
export default rdbUtils as RdbUtils;

公共操作类使用

  1. 如何使用公共操作类

        // 初始化保存卡片数据库
        RdbUtils.initDb(this.context, Const.RDB_NAME.dbName ? Const.RDB_NAME.dbName : '');
        await RdbUtils.createDb();
        RdbUtils.createTable(Const.FORM_INFO.tableName ? Const.FORM_INFO.tableName : '', columnFormInfoList)
          .catch((err: Error) => {
            LogUtil.error(`RdbHelper formInfo err : ${JSON.stringify(err)}`);
          });
    
  2. 关系型数据库这里使用了接口型开发,使用Map缓存数据库对象,如果Map包含指定数据库名,直接从Map缓存返回,否则创建数据库,并缓存到Map里。

卡片信息API

import RdbUtils from '../database/rdb/RdbUtils';
import FormInfoModel from '../model/FormInfoModel';
import { LogUtil } from '../utils/LogUtil';
import dataRdb from '@ohos.data.relationalStore';
import { RdbConstants as Const } from '../constant/RdbConstants';

class FormInfoApi {

  public insertData(formInfo: FormInfoModel, callback: Function): void {
    const valueBucket = generateBucket(formInfo);
    RdbUtils.insert('formInfo', valueBucket).then(result => {
      callback(result);
    });
    LogUtil.info('FormInfoTable', 'Insert formInfo finished.');
  }

  public queryFormData(callback: Function): void {
    let predicates = new dataRdb.RdbPredicates(Const.FORM_INFO.tableName ? Const.FORM_INFO.tableName : '');
    RdbUtils.query(predicates).then(resultSet => {
      let count = resultSet.rowCount;
      if (count === 0) {
        callback([]);
      } else {
        resultSet.goToFirstRow();
        let resultArray: Array<FormInfoModel> = new Array<FormInfoModel>();
        do {
          let result = new FormInfoModel();
          result.formId = resultSet.getString(resultSet.getColumnIndex('formId'));
          result.formName = resultSet.getString(resultSet.getColumnIndex('formName'));
          result.formDimension = resultSet.getLong(resultSet.getColumnIndex('formDimension'));
          resultArray.push(result);
        } while (resultSet.goToNextRow());
        resultSet.close();
        callback(resultArray);
      }
    }).catch((error: Error) => {
      LogUtil.error('FormInfoTable', 'queryFormData error ' + JSON.stringify(error));
    });
  }

  public deleteFormData(formId: string): void {
    let predicates = new dataRdb.RdbPredicates(Const.FORM_INFO.tableName ? Const.FORM_INFO.tableName : '');
    predicates.equalTo('formId', formId);
    RdbUtils.del(predicates).catch((error: Error) => {
      LogUtil.error('FormInfoTable', 'deleteFormData error ' + JSON.stringify(error));
    });
  }
}

function generateBucket(formInfo: FormInfoModel): dataRdb.ValuesBucket {
  let valueBucket = {} as dataRdb.ValuesBucket;
  Const.FORM_INFO.columns?.forEach((item: string) => {
    if (item !== 'id') {
      switch (item) {
        case 'formId':
          valueBucket[item] = formInfo.formId;
          break;
        case 'formName':
          valueBucket[item] = formInfo.formName;
          break;
        case 'formDimension':
          valueBucket[item] = formInfo.formDimension;
          break;
        default:
          break;
      }
    }
  });
  return valueBucket;
}

let formInfoApi = new FormInfoApi();
export default formInfoApi as FormInfoApi;

卡片保存操作类FormUtils

import FormInfoApi from '../api/FormInfoApi';
import RdbUtils from '../database/rdb/RdbUtils';
import FormInfoModel from '../model/FormInfoModel';
import { RdbConstants as Const } from '../constant/RdbConstants';
import { columnFormInfoList } from '../database/model/RdbColumnModel';
import { LogUtil } from './LogUtil';
import formProvider from '@ohos.app.form.formProvider';
import formBindingData from '@ohos.app.form.formBindingData';
import http from '@ohos.net.http';
import { RequestConstants } from '../constant/RequestConstants';
import { ResponseArray } from '../../model/StandardResponse';
import { BusinessError } from '@ohos.base';

class FormUtils {

  public insertFormData(context: Context, formInfo: FormInfoModel): void {
    LogUtil.info('xx 初始化数据库')
    RdbUtils.initDb(context, Const.RDB_NAME.dbName ? Const.RDB_NAME.dbName : '');
    LogUtil.info('xx 初始化数据表')
    let isCreatePromise = RdbUtils.isCreateTable(Const.FORM_INFO.tableName ?
    Const.FORM_INFO.tableName : '', columnFormInfoList);
    isCreatePromise.then((result: boolean) => {
      if (!result) {
        LogUtil.error(Const.TAG, 'xx insertFormData form table create error');
        return;
      }
      LogUtil.info('xx 插入卡片数据')
      FormInfoApi.insertData(formInfo, (isDone: number) => {
        if (isDone) {
          LogUtil.info(Const.TAG, 'insert formInfo success: ' + JSON.stringify(isDone));
          LogUtil.info('xx 插入卡片数据成功')
          this.queryForms();
        } else {
          LogUtil.info('xx 插入卡片数据失败')
        }
      });
    });
  }

  public deleteFormData(context: Context, formId: string): void {
    RdbUtils.initDb(context, Const.RDB_NAME.dbName ? Const.RDB_NAME.dbName : '');
    let isCreatePromise = RdbUtils.isCreateTable(Const.FORM_INFO.tableName ?
    Const.FORM_INFO.tableName : '', columnFormInfoList);
    isCreatePromise.then((result: boolean) => {
      if (!result) {
        LogUtil.error(Const.TAG, 'deleteFormData form table create error');
        return;
      }
      FormInfoApi.deleteFormData(formId);
    });
  }

  /**
   * Update form operation
   */
  public queryForms(): void {
    LogUtil.info('xx 查询所有卡片信息')
    FormInfoApi.queryFormData((resultSet: Array<FormInfoModel>) => {
      resultSet.forEach((item: FormInfoModel) => {
        this.updateArticleCards(item);
      });
    });
  }

  public updateCards(context: Context): void {
    RdbUtils.initDb(context, Const.RDB_NAME.dbName ? Const.RDB_NAME.dbName : '');
    let isCreatePromise = RdbUtils.isCreateTable(Const.FORM_INFO.tableName ?
    Const.FORM_INFO.tableName : '', columnFormInfoList);
    isCreatePromise.then((result: boolean) => {
      if (!result) {
        LogUtil.error(Const.TAG, 'updateCards form table create error');
        return;
      }
      this.queryForms();
    });
  }

  private updateArticleCards(formInfo: FormInfoModel): void {
    LogUtil.info('xx 更新卡片信息')
    if (formInfo.formDimension === Const.DEFAULT_DIMENSION_4X4) {
      LogUtil.info('xx 更新4x4卡片信息')
      this.getNewsList(formInfo);
    }
  }

  getNewsList(formInfo: FormInfoModel) {
    let httpRequest = http.createHttp()
    const now = new Date();
    const monthStr = String(now.getMonth() + 1).padStart(2, '0');
    const dayStr = String(now.getDate()).padStart(2, '0');

    httpRequest.request(RequestConstants.EVENT_HISTORY_URL, {
      method: http.RequestMethod.POST,
      header: {
        'Content-Type': 'application/json'
      },
      extraData: {
        "token": RequestConstants.TOKEN_KEY,
        "monthday": `${monthStr}${dayStr}`,
        "page": 1
      },
      expectDataType: http.HttpDataType.OBJECT
    }, (err, res) => {
      if (!err) {
        let standardResponse:ResponseArray = res.result as ResponseArray;
        console.info('xx Code:' + standardResponse.code);

        if (standardResponse.code === 200) {
          let newsArticles = standardResponse.data;
          LogUtil.info('xx 数据:' + JSON.stringify(newsArticles))
          LogUtil.info('xx 卡片:' + JSON.stringify(formInfo))

          let obj = formBindingData.createFormBindingData({'newsArticles': newsArticles});
          try {
            formProvider.updateForm(formInfo.formId, obj).then(() => {
              LogUtil.info('xx formProvider updateForm success');
            }).catch((error: BusinessError) => {
              LogUtil.info('xx formProvider updateForm, error:' + JSON.stringify(error));
            });
          } catch (error) {
            LogUtil.info(`xx catch err->${JSON.stringify(error)}`);
          }
        }
        LogUtil.info(`xx get news article data ---> `)


      } else {
        console.info('error:' + JSON.stringify(err));
        // 取消订阅HTTP响应头事件
        httpRequest.off('headersReceive');
        // 当该请求使用完毕时,调用destroy方法主动销毁。
        httpRequest.destroy();
      }
    })
  }

}

export default new FormUtils();

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2254500.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

LCD1602液晶显示屏指令详解

文章目录 LCD1602液晶显示屏1.简介2. 液晶引脚说明3. 指令介绍3.1 清屏指令3.2 光标归位指令3.3 进入模式设置指令3.4 显示开关设置指令3.5 设定显示或光标移动方向指令3.6 功能设定指令3.7 设定CGRAM地址指令3.8 设定DDRAM地址指令3.9 读取忙或AC地址指令3.10 总图3.11 DDRAM …

Python毕业设计选题:基于大数据的旅游景区推荐系统_django

开发语言&#xff1a;Python框架&#xff1a;djangoPython版本&#xff1a;python3.7.7数据库&#xff1a;mysql 5.7数据库工具&#xff1a;Navicat11开发软件&#xff1a;PyCharm 系统展示 系统首页界面 用户注册界面 用户登录界面 景点信息界面 景点资讯界面 个人中心界面 …

引领素养教育行业,猿辅导素养课斩获“2024影响力教育品牌”奖项

近日&#xff0c;由教育界网、校长邦联合主办&#xff0c;鲸媒体、职教共创会协办的“第9届榜样教育年度盛典”评奖结果揭晓。据了解&#xff0c;此次评选共有近500家企业提交参评资料进行奖项角逐&#xff0c;历经教育界权威专家、资深教育从业者以及专业评审团队的多轮严格筛…

十七、监控与度量-Prometheus/Grafana/Actuator

文章目录 前言一、Spring Boot Actuator1. 简介2. 添加依赖2. 开启端点3. 暴露端点4. 总结 二、Prometheus1. 简介2. Prometheus客户端3. Prometheus服务端4. 总结 三、Grafana1. 简介2. Grafana安装3. Grafana配置 前言 系统监控‌ 在企业级的应用中&#xff0c;系统监控至关…

PHP语法学习(第六天)

&#x1f4a1;依照惯例&#xff0c;回顾一下昨天讲的内容 PHP语法学习(第五天)主要讲了PHP中的常量和运算符的运用。 &#x1f525; 想要学习更多PHP语法相关内容点击“PHP专栏” 今天给大家讲课的角色是&#x1f34d;菠萝吹雪&#xff0c;“我菠萝吹雪吹的不是雪&#xff0c;而…

关于遥感图像镶嵌后出现斑点情况的解决方案

把几张GF1的影像镶嵌在一起后&#xff0c;结果在Arcgis里出现了明显的斑点情况&#xff08;在ENVI里显示则不会出现&#xff09;&#xff0c;个人觉得可能是斑点噪声问题&#xff0c;遂用Arcgis的滤波工具进行滤波处理&#xff0c;但由于该工具本身没有直接设置对多波段处理方式…

【嵌套查询】.NET开源 ORM 框架 SqlSugar 系列

.NET开源 ORM 框架 SqlSugar 系列 【开篇】.NET开源 ORM 框架 SqlSugar 系列【入门必看】.NET开源 ORM 框架 SqlSugar 系列【实体配置】.NET开源 ORM 框架 SqlSugar 系列【Db First】.NET开源 ORM 框架 SqlSugar 系列【Code First】.NET开源 ORM 框架 SqlSugar 系列【数据事务…

单链表---合并两个链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 struct ListNode {int val;struct ListNode* next; }; w 方法一---不使用哨兵位 我们创建一个新链表用于合并两个升序链表&#xff0c; 将两个链表中最小的结点依次尾插到…

vue聊天对话语音消息播放动态特效

vue2写法&#xff0c;vue3也能用&#xff0c;粘之即走&#xff1a; 示例&#xff1a; <template><div class"voice-hidden"><divclass"voice-play-chat":class"[className, { animate-stop: !isPlaying }]"><div class&q…

深度学习7 梯度下降优化、过拟合、手机价格预测

三、BP算法 3、梯度下降 w w - lr * grad&#xff1a; w 表示权重&#xff0c;lr表示学习率&#xff0c;grad表示梯度 传统下降方式分三类&#xff1a;&#xff08;BGD&#xff09;批量梯度下降、&#xff08;MBGD&#xff09;小批量梯度下降、&#xff08;SGD&#xff09;随…

跑一下pyapp

文档&#xff1a;How-to - PyApp 首先没有rust要安装 安装 Rust - Rust 程序设计语言 查看是否安装成功 然后clone下pyapp https://github.com/ofek/pyapp/releases/latest/download/source.zip -OutFile pyapp-source.zip 进入目录中&#xff0c;cmd&#xff0c;设置环境…

Django模板系统

1.常用语法 Django模板中只需要记两种特殊符号&#xff1a; {{ }}和 {% %} {{ }}表示变量&#xff0c;在模板渲染的时候替换成值&#xff0c;{% %}表示逻辑相关的操作。 2.变量 {{ 变量名 }} 变量名由字母数字和下划线组成。 点&#xff08;.&#xff09;在模板语言中有…

【人工智能】Transformers之Pipeline(二十七):蒙版生成(mask-generation)

​​​​​​​ 目录 一、引言 二、蒙版生成&#xff08;mask-generation&#xff09; 2.1 概述 2.2 facebook/sam-vit-base 2.3 pipeline参数 2.3.1 pipeline对象实例化参数 2.3.2 pipeline对象使用参数 2.3.3 pipeline对象返回参数 2.4 pipeline实战 2.5 模型排…

gpt-computer-assistant - 极简的 GPT-4o 客户端

更多AI开源软件&#xff1a; AI开源 - 小众AIhttps://www.aiinn.cn/sources gpt-computer-assistant是一个将 ChatGPT MacOS 应用程序提供给 Windows 和 Linux 的替代工作。因此&#xff0c;这是一个全新且稳定的项目。此时&#xff0c;您可以轻松地将其作为 Python 库安装&am…

高通---Camera调试流程及常见问题分析

文章目录 一、概述二、Camera配置的整体流程三、Camera的代码架构图四、Camera数据流的传递五、camera debug FAQ 一、概述 在调试camera过程中&#xff0c;经常会遇到各种状况&#xff0c;本篇文章对camera调试的流程进行梳理。对常见问题的提供一些解题思路。 二、Camera配…

软件/游戏运行提示xrnm.dll丢失无法继续执行怎么办?xrnm.dll缺少最佳解决方法

xrnm.dll 文件并不是一个标准的Windows系统文件&#xff0c;也不是广泛已知的第三方应用程序的一部分。因此&#xff0c;如果你遇到了提示 xrnm.dll 文件丢失或缺失的问题&#xff0c;这可能是由于特定软件或游戏的要求&#xff0c;或者是某种错误配置、恶意软件感染或其他问题…

流媒体之linux下离线部署FFmpeg 和 SRS

前言 用户对网络做了限制&#xff0c;只能访问指定的网址&#xff0c;和没网没啥区别&#xff0c;导致无法连接外网&#xff0c;无法获取安装包&#xff0c;还有一些编译需要的开源工具 用户需要用平台查看库房的海康摄像头实时监控&#xff0c;只能在库房里一台纯净的ubantu…

在LabVIEW中实现HARQ协议

HARQ&#xff08;Hybrid Automatic Repeat reQuest&#xff09;可以在LabVIEW中实现。HARQ是一种结合了前向纠错&#xff08;FEC&#xff09;和自动重传请求&#xff08;ARQ&#xff09;的技术&#xff0c;用于提高数据传输的可靠性&#xff0c;尤其是在无线通信和数据链路中。…

网络协议(TCP/IP模型)

目录 网络初识 网络协议 协议分层 协议拆分 分层 协议分层的优势 1.封装效果 2.解耦合 TCP/IP五层模型 协议之间配合工作&#xff08;详解&#xff09; 网络初识 网络核心概念&#xff1a; 局域网&#xff1a;若干电脑连接在一起&#xff0c;通过路由器进行组网。 …

PH热榜 | 2024-12-05

1. Oopsie 标语&#xff1a;用AI和会话回放调试Flutter和React Native应用 介绍&#xff1a;Zipy推出的Oopsie是一款你唯一需要的AI赋能移动端调试工具&#xff0c;它能提供▶️会话回放、&#x1f916;错误监控、&#x1f4a1;AI生成的概要分析&#xff0c;以及&#x1f525…