jw-beauty/miniprogram/pages/treating/treating.js

var ble = require('../../services/ble')
var commandSync = require('../../services/command-sync')

Page({
  data: {
    statusBarHeight: 44,
    regions: 0,
    wavelength: 2,
    duration: 600000,
    mode: 0,
    remainingMs: 600000,
    remainingText: '10:00',
    battery: 0,
    temperature: 0,
    progress: 0,
    paused: false,
    completed: false,
    startedAt: 0,
  },

  onLoad: function (options) {
    var app = getApp()
    this.setData({ statusBarHeight: app.globalData.statusBarHeight })
    this.setData({
      regions: parseInt(options.regions) || 0x7F,
      wavelength: parseInt(options.wavelength) || 2,
      duration: parseInt(options.duration) || 600000,
      mode: parseInt(options.mode) || 0,
      remainingMs: parseInt(options.duration) || 600000,
      startedAt: Date.now()
    })

    this._onStatus = this.onStatus.bind(this)
    this._onComplete = this.onComplete.bind(this)
    this._onException = this.onException.bind(this)
    ble.on('status', this._onStatus)
    ble.on('treatment_complete', this._onComplete)
    ble.on('exception', this._onException)
    this.startLocalTimer()
    this.syncCommands()
  },

  onUnload: function () {
    if (this._onStatus) ble.off('status', this._onStatus)
    if (this._onComplete) ble.off('treatment_complete', this._onComplete)
    if (this._onException) ble.off('exception', this._onException)
    if (this._localTimer) clearInterval(this._localTimer)
  },

  startLocalTimer: function () {
    var self = this
    var timer = setInterval(function () {
      if (self.data.completed || self.data.paused) return
      var elapsed = Date.now() - self.data.startedAt
      var remaining = Math.max(0, self.data.duration - elapsed)
      self.updateProgress(remaining)
      if (remaining <= 0) {
        clearInterval(timer)
        self.finishAsComplete()
      }
    }, 1000)
    this._localTimer = timer
  },

  updateProgress: function (remaining) {
    var total = this.data.duration
    var progress = total > 0 ? Math.round(((total - remaining) / total) * 100) : 0
    var mins = Math.floor(remaining / 60000)
    var secs = Math.floor((remaining % 60000) / 1000)
    this.setData({
      remainingMs: remaining,
      remainingText: ('0' + mins).slice(-2) + ':' + ('0' + secs).slice(-2),
      progress: progress
    })
  },

  onStatus: function (status) {
    var remaining = status.remaining_ms || 0
    this.updateProgress(remaining)
    this.setData({
      battery: status.battery,
      temperature: status.temperature,
      paused: status.mode_state === 0x03
    })
    this.syncCommands()
  },

  syncCommands: function () {
    var app = getApp()
    var device = app.globalData.currentDevice || {}
    var deviceId = device.device_id || this.options.device_id
    if (deviceId) commandSync.sync(deviceId)
  },

  onComplete: function (result) {
    this.setData({ completed: true, progress: 100 })
    var app = getApp()
    app.globalData.currentTreatment = result

    var self = this
    setTimeout(function () {
      wx.redirectTo({
        url: '/pages/treatment-done/treatment-done?session_id=' + result.session_id +
          '&regions=' + result.regions +
          '&duration=' + result.total_duration_ms +
          '&avg_pd=' + result.avg_pd +
          '&mode=' + (self.data.mode || 0)
      })
    }, 1000)
  },

  finishAsComplete: function () {
    var elapsed = Math.min(this.data.duration, Date.now() - this.data.startedAt)
    this.onComplete({
      session_id: 'LOCAL_' + Date.now(),
      regions: this.data.regions,
      total_duration_ms: elapsed,
      avg_pd: 0,
      source: 'client_timer'
    })
  },

  onException: function (err) {
    wx.showModal({
      title: '设备异常',
      content: err.error_msg || '护理过程中出现异常',
      showCancel: false,
      complete: function () {
        wx.navigateBack()
      }
    })
  },

  onStop: function () {
    var self = this
    wx.showModal({
      title: '结束护理',
      content: '确定要提前结束本次护理吗？',
      success: function (res) {
        if (res.confirm) {
          ble.stopTreatment().catch(function () {}).then(function () {
            self.finishAsComplete()
          })
        }
      }
    })
  }
})