imobile_for_reactnative/NativeModule/interfaces/collector/SMediaCollector.ts

iMobile for ReactNative，是SuperMap iMobile推出的一款基于React-Native框架的移动应用开发工具。基于该开发工具，用户可以使用JavaScript开发语言，开发出在Android和IOS操作系统下运行的原生移动GIS应用，入门门槛低，一次开发，处处运行。

/**
 * 多媒体采集类
 */
import { NativeModules, NativeEventEmitter, EmitterSubscription } from 'react-native'
import { EventConst } from 'imobile_for_reactnative/NativeModule/constains'
import { DatasetInfo, Point2D } from '../data/SData'
import * as SMap from '../mapping/SMap'
const Collector = NativeModules.SMediaCollector
const nativeEvt = new NativeEventEmitter(Collector)

interface BaseMedia {
  /** 对象ID */
  geoID: number,
  /** 多媒体callout名称 */
  mediaName: string,
  /** 多媒体callout描述 */
  description: string,
  /** 多媒体callout位置 */
  coordinate: Point2D,
  /** 多媒体类型 */
  mediaType: string,
  /** 多媒体数据json字符串 */
  mediaData: string,
  /** http */
  httpAddress: string,
  /** 关联的数据源名称 */
  datasourceName: string,
  /** 关联的数据集名称 */
  datasetName: string,
}

/**
 * 多媒体数据信息
 */
export interface MediaData extends BaseMedia {
  /** callout id */
  id: string,
  /** 关联的图层名称 */
  layerName: string,
  /** 修改时间 */
  modifiedDate: string,
  /** 多媒体路径数组 */
  mediaFilePaths: string[],
  /** 多媒体对应Online ID数组，与路径一一对应 */
  mediaServiceIds: number[],
}

/** 多媒体视频 */
export interface MediaVideo {
  /** 视频文件路径 */
  path: string,
  /** 视频宽度 */
  width: number,
  /** 视频高度 */
  height: number,
  /** 视频时常（秒） */
  duration: number,
}

/** 旅行轨迹添加结果 */
export interface TourAddResult {
  /** 是否添加成功 */
  result: boolean,
  /** 添加的多媒体文件信息数组 */
  medias?: MediaData[],
  /** 错误文件信息数组 */
  errorFiles?: TourMediaData[],
}

let calloutTapListener: EmitterSubscription | undefined | null
let calloutTapHandler: ((data: MediaData) => void) | undefined
/**
 * 添加多媒体采集图片点击回调事件
 * @param handler 点击回调事件
 */
export function setCalloutTapListener (handler?:(data: MediaData) => void): void {
  calloutTapHandler = handler
  calloutTapListener?.remove()
  calloutTapListener = null
  if (calloutTapHandler && typeof calloutTapHandler === 'function') {
    calloutTapListener = nativeEvt.addListener(EventConst.MEDIA_CAPTURE_TAP_ACTION, function (e) {
      calloutTapHandler?.(e)
    })
  }
}

/** 下载过程中返回数据 */
export interface DownloadingData extends DownloadData {
  /** 进度条 */
  progress: number,
}
/** 下载完成后返回数据 */
export interface DownloadedData extends DownloadData {
  /** 下载结果 */
  result: boolean,
}
/** 下载失败后返回数据 */
export interface DownloadFailureData extends DownloadData {
  /** 下载结果 */
  result: boolean,
  /** 错误信息 */
  error: any,
}
/** 下载回调函数 */
export interface DownloadHandler {
  /** 下载中回调 */
  downloadingHandler?: (data: DownloadingData) => void,
  /** 下载完成回调 */
  downloadedHandler?: (data: DownloadedData) => void,
  /** 下载失败回调 */
  downloadFailureHandler?: (data: DownloadFailureData) => void,
}

let downloadListeners: {
  downloadingListener?: EmitterSubscription | undefined | null,
  downloadedListener?: EmitterSubscription | undefined | null,
  downloadFailureListener?: EmitterSubscription | undefined | null,
} = {}
let downloadDownloadHandlers: DownloadHandler | undefined

// TODO 确定类型
export type DownloadDataType = 'Media' | string


/** 下载多媒体数据信息 */
export interface MediaDownloadData {
  /** 下载到指定文件夹的完整路径 */
  toPath: string,
  /** 下载文件的url */
  url: string,
  /** 多媒体关联的对象的ID */
  geoID?: number,
  /** 多媒体关联的图层 */
  layerName?: string,
}
/** 下载在线多媒体参数 */
export interface DownloadData {
  /** 下载多媒体数据类型 */
  type: DownloadDataType,
  /** 下载多媒体数据信息 */
  data: MediaDownloadData,
}
/**
 * 添加多媒体下载监听
 * @param handlers 下载监听
 */
export function setDownloadListener (handlers?: DownloadHandler): void {
  try {
    downloadDownloadHandlers = handlers

    downloadListeners.downloadingListener?.remove()
    downloadListeners.downloadedListener?.remove()
    downloadListeners.downloadFailureListener?.remove()

    downloadListeners.downloadingListener = null
    downloadListeners.downloadedListener = null
    downloadListeners.downloadFailureListener = null
    downloadListeners = {}

    if (downloadDownloadHandlers?.downloadingHandler) {
      downloadListeners.downloadingListener = nativeEvt.addListener(EventConst.DATA_DOWNLOADING, function (e) {
        if (downloadDownloadHandlers?.downloadingHandler && typeof downloadDownloadHandlers.downloadingHandler === 'function') {
          downloadDownloadHandlers.downloadingHandler(e)
        }
      })
    }
    if (downloadDownloadHandlers?.downloadedHandler) {
      downloadListeners.downloadedListener = nativeEvt.addListener(EventConst.DATA_DOWNLOADED, function (e) {
        if (downloadDownloadHandlers?.downloadedHandler && typeof downloadDownloadHandlers.downloadedHandler === 'function') {
          downloadDownloadHandlers.downloadedHandler(e)
        }
      })
    }
    if (downloadDownloadHandlers?.downloadFailureHandler) {
      downloadListeners.downloadFailureListener = nativeEvt.addListener(EventConst.DATA_DOWNLOADFAILURE, function (e) {
        if (downloadDownloadHandlers?.downloadFailureHandler && typeof downloadDownloadHandlers.downloadFailureHandler === 'function') {
          downloadDownloadHandlers.downloadFailureHandler(e)
        }
      })
    }
  } catch (e) {
    __DEV__ && console.warn(e)
  }
}

/**
 * 初始化多媒体采集储存路径
 * @param path 初始化多媒体采集储存路径
 * @returns 返回是否设置成功
 */
export async function initMediaCollector (path = ''): Promise<boolean> {
  if (!path) return false
  return await Collector.initMediaCollector(path)
}

/**
 * 添加一个callout对象
 * @param dataInfo  数据信息
 * @param params    多媒体数据信息
 * @returns 返回是否添加成功
 */
export async function addMedia(dataInfo: DatasetInfo, params: Partial<MediaData>): Promise<boolean> {
  const media: MediaData = await Collector.addMedia(dataInfo, params)

  let tag = dataInfo.datasourceName + "_" + dataInfo.datasetName
  if (media.geoID >= 0) {
    tag += "_" + media.geoID
  }
  await SMap.addCallout(tag, media.coordinate, {
    type: 'media',
    /** 图片/视频资源 */
    ...media,
  })
  return true
}

/**
 * 保存多媒体
 * @param datasetInfo 数据信息
 * @param geoID       数据对象ID
 * @param fieldInfo   修改数据
 * @returns           返回保存成功的多媒体内容
 */
export function saveMedia (datasetInfo: DatasetInfo, geoID = -1, fieldInfo: Array<{[name: string]: any}> = []): Promise<MediaData> {
  let info = []
  for (let i = 0; i < fieldInfo.length; i++) {
    let name = fieldInfo[i].name.substring(0, 1).toUpperCase() + fieldInfo[i].name.slice(1)
    info.push({
      name,
      value: fieldInfo[i].value,
    })
  }
  return Collector.saveMedia(datasetInfo, geoID, info)
}

/**
 * 显示指定图层多媒体采集callouts
 * @param layerName 指定图层名称
 * @param isShow 是否显示
 * @returns 返回是否添加成功
 */
export async function showMedia (layerName: string, isShow = true): Promise<boolean> {
  try {
    let medias: MediaData[] = await Collector.showMedia(layerName, isShow)
    for (const media of medias) {
      let tag = media.datasourceName + "_" + media.datasetName
      if (media.geoID >= 0) {
        tag += "_" + media.geoID
      }
      if (isShow) {
        await SMap.addCallout(tag, media.coordinate, {
          type: 'media',
          /** 图片/视频资源 */
          ...media,
        })
      } else {
        await SMap.removeCallout(media.id)
      }
    }
    return true
  } catch(e) {
    return false
  }
}

/**
 * 获取视频缩略图
 * @param videoPath 视频文件路径
 * @returns 返回视频信息
 */
export function getVideoInfo (videoPath: string): Promise<MediaVideo|null> {
  return Collector.getVideoInfo(videoPath)
}

/**
 * 获取多媒体信息
 * @param layerName 图层名
 * @param geoID     数据集对象ID
 * @returns         返回对象名称
 */
export function getMediaInfo (layerName = '', geoID = -1): Promise<MediaData | null> {
  return Collector.getMediaInfo(layerName, geoID)
}

/** 旅行轨迹多媒体数据 */
export interface TourMediaData {
  [key: string]: any,
  /** 多媒体名字 */
  mediaName: string,
  /** 多媒体callout位置 */
  coordinate?: Point2D,
  /** 文件路径 */
  uri: string,
}

/**
 * 添加多媒体旅行轨迹
 * @param layerName 旅行轨迹图层名
 * @param files     多媒体数据
 * @returns         返回添加结果
 */
export async function addTour (layerName = '', files: TourMediaData[] = []): Promise<TourAddResult | null | undefined> {
  const result: TourAddResult | null = await Collector.addTour(layerName, files)
  const medias = result?.medias || []
  for (const media of medias) {
    let tag = media.datasourceName + "_" + media.datasetName
    if (media.geoID >= 0) {
      tag += "_" + media.geoID
    }
    await SMap.addCallout(tag, media.coordinate, {
      type: 'media',
      /** 图片/视频资源 */
      ...media,
    })
  }
  return result
}

/**
 * 更新旅行轨迹图层
 * @param layerName 旅行轨迹图层
 * @returns 返回是否更新成功
 */
export async function updateTour (layerName = ''): Promise<boolean> {
  try {
    const medias: MediaData[] = await Collector.updateTour(layerName) || []
    for (const media of medias) {
      let tag = media.datasourceName + "_" + media.datasetName
      if (media.geoID >= 0) {
        tag += "_" + media.geoID
      }
      await SMap.updateCallout(media.id, media.coordinate)
    }
    return true
  } catch(e) {
    return false
  }
}

/**
 * 判断图层是否是多媒体图层
 * @param layerName 图层名
 * @returns 返回是否是多媒体图层
 */
export function isMediaLayer (layerName = ''): Promise<boolean> {
  return Collector.isMediaLayer(layerName)
}

/**
 * 判断图层是否是旅行轨迹图层
 * @param layerName 图层名
 * @returns 返回是否是旅行轨迹图层
 */
export function isTourLayer (layerName = ''): Promise<boolean> {
  return Collector.isTourLayer(layerName)
}

/**
 * 判断当前数据集是否存在多媒体信息
 * @param layerName 图层名
 * @param geoID     数据集对象ID
 * @returns         返回是否含有数据
 */
export function haveMediaInfo (layerName = '', geoID = -1): Promise<boolean> {
  return Collector.haveMediaInfo(layerName, geoID)
}