//导入lottieEts组件库
import lottieEts from '@ohos/lottieETS'

  @State listening: boolean = true
  @State answer: string = '您好，有什么吩咐!'
  private listeningWord: string = '我正在聆听..'
  private doneWord: string = '好的,\n已经帮您搞定啦!'
  
  //Lottie动画
  private settings: RenderingContextSettings = new RenderingContextSettings(true)
  private context: CanvasRenderingContext2D = new CanvasRenderingContext2D(this.settings)
  private animateItem: any = null
  private animateName: string = "grunt";
  private path: string = "common/balls.json"
  
  //动画Canvas
  Row() {
  Canvas(this.context)
  .width('100%')
  //.height(90)
  .border({ style: BorderStyle.Dashed })
  .onAppear(() => {
  this.animateItem = lottieEts.loadAnimation({
  container: this.context,
  renderer: 'canvas',
  loop: 1,
  autoplay: true,
  name: this.animateName,
  path: this.path
  })
  Animator('__lottie_ets')

//监听播放完成
this.animateItem.addEventListener('loopComplete', () => {
logger.getInstance(this).debug(`loopComplete...`)
this.answer = this.listeningWord;
})
})
.onDisAppear(() => {
logger.getInstance(this).debug(`destroy lottie...`)
lottieEts.destroy(this.animateName);
})

}
.align(Alignment.Center)
.alignItems(VerticalAlign.Center)
.alignSelf(ItemAlign.Center)
.height('40%')
.onClick(() => {
//播放动画
this.playing()
this.answer = '我想想看啊...';
})

//播放lottie动画
playing() {
logger.getInstance(this).debug(`player...`)
if (this.animateItem !== null) {
//从250帧开始播放
//this.animateItem.goToAndPlay(50, true);
//延迟到下轮循环播放再生效
this.animateItem.resetSegments(false)
lottieEts.play(this.animateName)
}
}

//模拟翻译功能
translateWord() {
  logger.getInstance(this).debug(`translateWord begin`)
  //获取RPC代理对象
  let mRemote = this.serviceModel.getRemoteObject()
  if (mRemote === null) {
    prompt.showToast({
      message: 'please connect service'
    })
  }
  //发送请求数据封装
  let option: rpc.MessageOption = new rpc.MessageOption()
  //入参
  let data: rpc.MessageParcel = rpc.MessageParcel.create()
  data.writeString(this.beforeSortString)

  //返回数据
  let reply: rpc.MessageParcel = rpc.MessageParcel.create()

  //发送请求
  mRemote.sendRequest(1, data, reply, option, () => {
    this.afterSortString = reply.readString()
    this.answer = '翻译好啦！'
  })

}

@Builder
  buildLoading(context: any) {
    Column() {
      Canvas(context)
        .width('100%')
        .height('50%')
        .onAppear(() => {
          try {
            this.animateItem = lottieEts.loadAnimation({
              container: context,
              renderer: 'canvas',
              loop: true,
              autoplay: true,
              name: this.animateName,
              path: this.path
            })
          } catch (e) {
            console.error(`error:${e}`)
          }
        })
        .onDisAppear(() => {
          lottieEts.destroy(this.animateName)
        })
      Text('开发中...').fontSize(30).fontColor(Color.White)
    }
    .width('100%')
    .height('100%')
    .backgroundColor(Color.Brown)
  }

let tabs = [
  $rawfile('tabs/ic_public_home.png'),
  $rawfile('tabs/ic_public_appstore.png'),
  $rawfile('tabs/ic_public_search_things.png'),
  $rawfile('tabs/ic_public_video.png'),
  $rawfile('tabs/ic_user_portrait.png'),
]

let tabs_selected = [
  $rawfile('tabs/ic_public_home_filled.png'),
  $rawfile('tabs/ic_public_appstore_filled.png'),
  $rawfile('tabs/ic_public_search_things_filled.png'),
  $rawfile('tabs/ic_public_video_filled.png'),
  $rawfile('tabs/ic_user_portrait_filled.png'),
]

let tabs_text = [
  '家居', '商城', '发现', '视频', '我的'
]

function getTabSrc(tabIndex: number, index: number) {
  let imgSrc = tabs[index]
  if (tabIndex === index) {
    imgSrc = tabs_selected[tabIndex]
  }
  return imgSrc
}

function getTabTextColor(tabIndex: number, index: number) {
  let color = '#000000'
  if (tabIndex === index) {
    color = '#0091FF'
  }
  return color
}

function getTabText(index: number) {
  let text = tabs_text[index]
  return text
}

@Component
export struct BottomTabs {
  private tabSrc: number[] = [0, 1, 2, 3, 4]
  private backgroundColor: string = '#cbcdd0'
  //Tab页控制器
  private controller: TabsController = new TabsController()
  @Link bottomTabIndex: number
  @Link is_landscape:boolean

  build() {
    Flex({ direction: FlexDirection.Row, alignItems: ItemAlign.Center, justifyContent: FlexAlign.SpaceEvenly }) {
      ForEach(this.tabSrc, item => {
        Column() {
          Image(getTabSrc(this.bottomTabIndex, item))
            .objectFit(ImageFit.Contain)
            .width('60%').height('60%')
          Text(getTabText(item))
            .fontSize(15)
            .fontWeight(FontWeight.Bolder)
            .fontColor(getTabTextColor(this.bottomTabIndex, item))
        }
        .onClick(() => {
          //改变Tab页控制器的索引
          if (item != this.bottomTabIndex) {
            this.controller.changeIndex(item)
          }
        })
      }, item => item.toString())
    }
    .width('100%').height(this.is_landscape? 60:90)
    .padding(5)
    .backgroundColor(this.backgroundColor)
  }
}

/**
 * 发布通知
 * @param data
 */
publish() {
  logger.getInstance(this).debug(`publish...`)
  try {
    //WantAgentInfo对象
    var wantAgentInfo = {
      wants: [
        {
          deviceId: "",
          bundleName: 'com.example.lanls',
          abilityName: 'com.example.lanls.NoticePageAbility',
          action: "",
          entities: [],
          uri: "",
          parameters: {'routeSource':10}
        }
      ],
      operationType: wantAgent.OperationType.START_ABILITY,
      requestCode: 0,
      wantAgentFlags: [wantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG]
    }
    // 获取wantAgent对象
    wantAgent.getWantAgent(wantAgentInfo)
      .then((data) => {
        this.noticeWantAgent = data
        //构造NotificationRequest对象
        var notificationRequest = {
          content: {
            contentType: notification.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
            normal: {
              title: "您有一条物业缴费通知",
              text: "2022年的第一季度物业费，请各位业主于2月1号前缴纳，谢谢！",
              additionalText: "12312312312"
            },
          },
          actionButtons: [
            {
              title: '查看详情',
              wantAgent: this.noticeWantAgent,
            }
          ],
          id: 1,
          label: 'TEST666',
          slotType: notification.SlotType.CONTENT_INFORMATION,
          //deliveryTime: new Date().getTime()
        }

        //request: NotificationRequest, userId: number
        notification.publish(notificationRequest)
          .then((data) => {
            logger.getInstance(this).debug('publish success data : ' + JSON.stringify(data))
          }).catch((err) => {
          logger.getInstance(this).error('publish failed because ' + JSON.stringify(err));
        });
      })
      .catch((reason) => {
        logger.getInstance(this).error(`publish error:${reason}`)
      })
  } catch (err) {
    logger.getInstance(this).error(`publish err:${err}`)
  }
}

import rpc from "@ohos.rpc"
import { ServiceModel } from '../model/ServiceModel'

this.serviceModel.connectService(this.want)

//发送请求数据封装
let option: rpc.MessageOption = new rpc.MessageOption()
//入参
let data: rpc.MessageParcel = rpc.MessageParcel.create()
data.writeString(this.beforeSortString)

//返回数据
let reply: rpc.MessageParcel = rpc.MessageParcel.create()

//await
mRemote.sendRequest(1, data, reply, option, () => {
  this.afterSortString = reply.readString()
})

import prompt from '@ohos.prompt'
import featureAbility from '@ohos.ability.featureAbility'
import rpc from "@ohos.rpc"

//代理对象
let mRemote: rpc.IRemoteObject = null

//连接状态码
let connection: number = -1
let TAG: string = '[LANLS.ServiceModel]'

export class ServiceModel {
    private sendMessage: string = ''

    public getRemoteObject() {
        return mRemote
    }


    /**
     * 连接服务
     * @param deviceId
     */
    connectService(want: any): number {
        console.log(`${TAG} connectService begin`)
        //回调处理,The remote object instance
        let options = {
            onConnect: function (elementName, proxy) {
                mRemote = proxy
                console.log(`${TAG} onConnect:${elementName},proxy:${proxy}`)

                prompt.showToast({
                    message: 'connect service success',
                })
            },
            onDisconnect: function (elementName) {
                console.log(`${TAG} onDisconnect element:${elementName}`)
                prompt.showToast({
                    message: `disconnect service success`
                })
            },
            onFailed: function (e) {
                console.log(`${TAG} onFailed errCode:${e}`)

                prompt.showToast({
                    message: `connect onFailed:${e}`
                })
            }
        }

        //开始连接，Returns the number code of the ability connected
        connection = featureAbility.connectAbility(want, options)
        console.log(`${TAG} connection:${connection}`)
        return connection
    }


    /**
     * 断开连接
     */
    disconnectService() {
        console.log(`${TAG} onDisconnectService begin`)
        mRemote = null
        if (connection === -1) {
            prompt.showToast({
                message: 'onDisconnectService not connected yet'
            })
            return
        }
        //开始断开连接
        featureAbility.disconnectAbility(connection).then(() => {
            connection = -1
            prompt.showToast({
                message: 'onDisconnectService disconnect done'
            })
        }).catch((error) => {
            console.error(`${TAG} onDisconnectService error:${error}`)
        })

    }
}

import rpc from "@ohos.rpc"
const TAG: string = '[AIServiceAbilityStub]'

class AIServiceAbilityStub extends rpc.RemoteObject {
    constructor(des: any) {
        if (typeof des === 'string') {
            super(des)
        }
    }

    onRemoteRequest(code: number, data: rpc.MessageParcel, reply: rpc.MessageParcel) {
        console.log(`${TAG} onRemoteRequest called...`)
        //字符串排序服务
        if (code === 1) {
            let string = data.readString()
            console.log(`${TAG} sort string=${string}`)
            let result = Array.from(string).sort().join('')
            console.log(`${TAG} sort result=${result}`)
            reply.writeString(result)
        }
        //翻译服务
        else if (code === 2) {
            let string = data.readString()
            console.log(`${TAG} translate string=${string}`)

            //模拟翻译功能
            let result = ''
            if (string == '鸿蒙系统') {
                result = 'HarmonyOS'
            } else {
                result = 'sorry'
            }
            console.log(`${TAG} sort result=${result}`)
            reply.writeString(result)
        } else {
            console.log(`${TAG} unknown request code`)
        }
        return true;
    }
}

export default {

    onStart() {
        console.info(`${TAG} onStart...`)
    },
    onStop() {
        console.info(`${TAG} onStop`)
    },
    onConnect(want) {
        console.log(`${TAG} onConnect, want:${JSON.stringify(want)}`)
        return new AIServiceAbilityStub("first ts service stub")
    },
    onDisconnect(want) {
        console.log(`${TAG} onDisconnect, want:${JSON.stringify(want)}`)
    },
    onCommand(want, startId) {
        console.log(`${TAG} onCommand, want:${JSON.stringify(want)},startId:${startId}`)
    }
}