【HarmonyOS Next之旅】基于ArkTS开发(一) -＞ Ability开发二 原创 精华

import featureAbility from '@ohos.ability.featureAbility'
 import dataAbility from '@ohos.data.dataAbility'
 import dataRdb from '@ohos.data.rdb'

 const TABLE_NAME = 'book'
 const STORE_CONFIG = { name: 'book.db' }
 const SQL_CREATE_TABLE = 'CREATE TABLE IF NOT EXISTS book(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, introduction TEXT NOT NULL)'
 let rdbStore: dataRdb.RdbStore = undefined

 export default {
 onInitialized(abilityInfo) {
     console.info('DataAbility onInitialized, abilityInfo:' + abilityInfo.bundleName)
     let context = featureAbility.getContext()
     dataRdb.getRdbStore(context, STORE_CONFIG, 1, (err, store) => {
         console.info('DataAbility getRdbStore callback')
         store.executeSql(SQL_CREATE_TABLE, [])
         rdbStore = store
     });
 },
 insert(uri, valueBucket, callback) {
     console.info('DataAbility insert start')
     rdbStore.insert(TABLE_NAME, valueBucket, callback)
 },
 batchInsert(uri, valueBuckets, callback) {
     console.info('DataAbility batch insert start')
     for (let i = 0;i < valueBuckets.length; i++) {
         console.info('DataAbility batch insert i=' + i)
         if (i < valueBuckets.length - 1) {
             rdbStore.insert(TABLE_NAME, valueBuckets[i], (err: any, num: number) => {
                 console.info('DataAbility batch insert ret=' + num)
             })
         } else {
             rdbStore.insert(TABLE_NAME, valueBuckets[i], callback)
         }
     }
 },
 query(uri, columns, predicates, callback) {
     console.info('DataAbility query start')
     let rdbPredicates = dataAbility.createRdbPredicates(TABLE_NAME, predicates)
     rdbStore.query(rdbPredicates, columns, callback)
 },
 update(uri, valueBucket, predicates, callback) {
     console.info('DataAbilityupdate start')
     let rdbPredicates = dataAbility.createRdbPredicates(TABLE_NAME, predicates)
     rdbStore.update(valueBucket, rdbPredicates, callback)
 },
 delete(uri, predicates, callback) {
     console.info('DataAbilitydelete start')
     let rdbPredicates =

"abilities":[{
 "srcPath": "DataAbility",
 "name": ".DataAbility",
 "icon": "$media:icon",
 "srcLanguage": "ets",
 "description": "$string:description_dataability",
 "type": "data",
 "visible": true,
 "uri": "dataability://ohos.samples.etsdataability.DataAbility"

// 作为参数传递的Uri,与config中定义的Uri的区别是多了一个"/",是因为作为参数传递的uri中,在第二个与第三个"/"中间,存在一个DeviceID的参数
import featureAbility from '@ohos.ability.featureAbility'
import ohos_data_ability from '@ohos.data.dataAbility'
import ohos_data_rdb from '@ohos.data.rdb'

var urivar = "dataability:///com.ix.DataAbility"
var DAHelper =

var valuesBucket = {"name": "gaolu"}
var da = new ohos_data_ability.DataAbilityPredicates()
var valArray =new Array("value1");
var cars = new Array({"batchInsert1" : "value1",});

// callback方式调用:
DAHelper.insert(
 urivar,
 valuesBucket,
 (error, data) => {
     console.log("DAHelper insert result: "

// promise方式调用:
var datainsert =

// callback方式调用:
DAHelper.delete(
 urivar,
 da,
 (error, data) => {
     console.log("DAHelper delete result: "

// promise方式调用:
var datadelete =

// callback方式调用:
DAHelper.update(
 urivar
 valuesBucket,
 da,
 (error, data) => {
     console.log("DAHelper update result: "

// promise方式调用:
var dataupdate =

// callback方式调用:
DAHelper.query(
 urivar,
 valArray,
 da,
 (error, data) => {
     console.log("DAHelper query result: "

// promise方式调用:
var dataquery =

// callback方式调用:
DAHelper.batchInsert(
 urivar,
 cars,
 (error, data) => {
     console.log("DAHelper batchInsert result: "

// promise方式调用:
var databatchInsert =

// callbacke方式调用:
DAHelper.executeBatch(
 urivar,
 [
     {
         uri: urivar,
         type: featureAbility.DataAbilityOperationType.TYPE_INSERT,
         valuesBucket: {"executeBatch" : "value1",},
         predicates: da,
         expectedCount:0,
         predicatesBackReferences: null,
         interrupted:true,
     }
 ],
 (error, data) => {
     console.log("DAHelper executeBatch result: "

// promise方式调用:
var dataexecuteBatch = await DAHelper.executeBatch(
 urivar,
 [
     {
         uri: urivar,
         type: featureAbility.DataAbilityOperationType.TYPE_INSERT,
         valuesBucket:
         {
             "executeBatch" : "value1",
         },
         predicates: da,
         expectedCount:0,
         predicatesBackReferences: null,
         interrupted:true,
     }
 ]
);

import formBindingData from '@ohos.application.formBindingData'
import formInfo from '@ohos.application.formInfo'
import formProvider from '@ohos.application.formProvider'

export default {
    onCreate(want) {
        console.log('FormAbility onCreate');
        // 由开发人员自行实现，将创建的卡片信息持久化，以便在下次获取/更新该卡片实例时进行使用
        let obj = {
            "title": "titleOnCreate",
            "detail": "detailOnCreate"
        };
        let formData = formBindingData.createFormBindingData(obj);
        return formData;
    },
    onCastToNormal(formId) {
        // 使用方将临时卡片转换为常态卡片触发，提供方需要做相应的处理
        console.log('FormAbility onCastToNormal');
    },
    onUpdate(formId) {
        // 若卡片支持定时更新/定点更新/卡片使用方主动请求更新功能，则提供方需要覆写该方法以支持数据更新
        console.log('FormAbility onUpdate');
        let obj = {
            "title": "titleOnUpdate",
            "detail": "detailOnUpdate"
        };
        let formData = formBindingData.createFormBindingData(obj);
        formProvider.updateForm(formId, formData).catch((error) => {
            console.log('FormAbility updateForm, error:' + JSON.stringify(error));
        });
    },
    onVisibilityChange(newStatus) {
        // 使用方发起可见或者不可见通知触发，提供方需要做相应的处理
        console.log('FormAbility onVisibilityChange');
    },
    onEvent(formId, message) {
        // 若卡片支持触发事件，则需要覆写该方法并实现对事件的触发
        console.log('FormAbility onEvent');
    },
    onDestroy(formId) {
        // 删除卡片实例数据
        console.log('FormAbility onDestroy');
    },
    onAcquireFormState(want) {
        console.log('FormAbility onAcquireFormState');
        return

"js": [{
       "name": "widget",
       "pages": ["pages/index/index"],
       "window": {
           "designWidth": 720,
           "autoDesignWidth": true
       },
       "type": "form"

"abilities": [{
       "name": "FormAbility",
       "description": "This is a FormAbility",
       "formsEnabled": true,
       "icon": "$media:icon",
       "label": "$string:form_FormAbility_label",
       "srcPath": "FormAbility",
       "type": "service",
       "srcLanguage": "ets",
       "forms": [{
           "colorMode": "auto",
           "defaultDimension": "2*2",
           "description": "This is a service widget.",
           "formVisibleNotify": true,
           "isDefault": true,
           "jsComponentName": "widget",
           "name": "widget",
           "scheduledUpdateTime": "10:30",
           "supportDimensions": ["2*2"],
           "type": "JS",
           "updateDuration": 1,
           "updateEnabled": true

'FormAbility onCreate');

           let formId = want.parameters["ohos.extra.param.key.form_identity"];
           let formName = want.parameters["ohos.extra.param.key.form_name"];
           let tempFlag = want.parameters["ohos.extra.param.key.form_temporary"];
           // 由开发人员自行实现，将创建的卡片信息持久化，以便在下次获取/更新该卡片实例时进行使用
           storeFormInfo(formId, formName, tempFlag, want);

           let obj = {
               "title": "titleOnCreate",
               "detail": "detailOnCreate"
           };
           let formData = formBindingData.createFormBindingData(obj);
           return

<div class="container">
  <stack>
   <div class="container-img">
       <image src="/common/widget.png" class="bg-img"></image>
   </div>
   <div class="container-inner">
       <text class="title">{{title}}</text>
       <text class="detail_text" onclick="routerEvent">{{detail}}</text>
   </div>
  </stack>
</div>

.container {
 flex-direction: column;
 justify-content: center;
 align-items: center;
}

.bg-img {
 flex-shrink: 0;
 height: 100%;
}

.container-inner {
 flex-direction: column;
 justify-content: flex-end;
 align-items: flex-start;
 height: 100%;
 width: 100%;
 padding: 12px;
}

.title {
 font-size: 19px;
 font-weight: bold;
 color: white;
 text-overflow: ellipsis;
 max-lines: 1;
}

.detail_text {
 font-size: 16px;
 color: white;
 opacity: 0.66;
 text-overflow: ellipsis;
 max-lines: 1;
 margin-top: 6px;
}

{
"data": {
  "title": "TitleDefault",
  "detail": "TextDefault"
},
"actions": {
  "routerEvent": {
 "action": "router",
 "abilityName": "com.example.MyApplication.hmservice.FormAbility",
 "params": {
   "message": "add detail"

import wantAgent from '@ohos.wantAgent';

private wantAgentObj = null    //用于保存创建成功的wantAgent对象，后续使用其完成触发的动作。

//wantAgentInfo
var wantAgentInfo = {
    wants: [
        {
            deviceId: "",
            bundleName: "com.example.test",
            abilityName: "com.example.test.MainAbility",
            action: "",
            entities: [],
            uri: "",
            parameters: {}
        }
    ],
    operationType: wantAgent.OperationType.START_ABILITY,
    requestCode: 0,
    wantAgentFlags:[wantAgent.WantAgentFlags.CONSTANT_FLAG]
}

private wantAgentObj = null    //用于保存创建成功的WantAgent对象，后续使用其完成触发的动作。

//wantAgentInfo
var wantAgentInfo = {
    wants: [
        {
            action: "event_name", // 设置事件名
            parameters: {}
        }
    ],
    operationType: wantAgent.OperationType.SEND_COMMON_EVENT,
    requestCode: 0,
    wantAgentFlags:[wantAgent.WantAgentFlags.CONSTANT_FLAG]
}

//创建WantAgent
wantAgent.getWantAgent(wantAgentInfo, (err, wantAgentObj) => {
    if (err.code) {
        console.error("[WantAgent]getWantAgent err=" + JSON.stringify(err))
    } else {
        console.log("[WantAgent]getWantAgent success")
        this.wantAgentObj = wantAgentObj
    }
})

//触发WantAgent
var triggerInfo = {
    code:0
}
wantAgent.trigger(wantAgentObj, triggerInfo, (completeData) => {
    console.log("[WantAgent]getWantAgent success, completeData: ",  + JSON.stringify(completeData))
})