val preview = findViewById<TrinityPreviewView>(R.id.preview)

mRecord = TrinityRecord(preview)

mRecord.release()

mRecord.setOnRenderListener(this)

mRecord.setOnRecordingListener(this)

mRecord.setCameraCallback(this)

mRecord.startPreview()

mRecord.stopPreview()

// Set the display type
// Include crop display, the original proportion is displayed in black
mRecord.setFrame(mFrame)

mRecord.switchCamera()

// return the current camera id
val facing = mRecord.getCameraFacing()

mRecord.flash(mFlash)

// Set the focal length zoom, 0-100 100 is the maximum zoom
mRecord.setZoom(0)

// Set the camera exposure, 100 is the maximum exposure
mRecord.setExposureCompensation(0)

// Set manual focus, parameters are x and y
mRecord.focus(mPointF)

/**
 * @param rotation Rotation angle includes 0 90 180 270
 */
mRecord.setRecordRotation(0)

mRecord.setMute(false)

/**
 * @param speed contains 0.25 0.5 1.0 2.0 4.0 times the speed
 */
mRecord.setSpeed(mSpeed)

/**
 * Start recording a video
 * @param path Recorded video save address
 * @param width The width of the recorded video. The SDK will do a 16-times integer operation. The width of the final output video may be inconsistent with the setting.
 * @param height The height of the recorded video. The SDK will do a 16-times integer operation. The width of the final output video may be inconsistent with the setting.
 * @param videoBitRate The bit rate of the video output. If it is set to 2000, it is 2M. The final output and the set may be different.
 * @param frameRate frame rate of video output
 * @param useHardWareEncode whether to use hard coding, if set to true, and hard coding is not supported, it will automatically switch to soft coding
 * @param audioSampleRate audio sample rate
 * @param audioChannel number of audio channels
 * @param audioBitRate audio bit rate
 * @param duration
 * @return Int ErrorCode.SUCCESS is success, others are failures
 * @throws InitRecorderFailException
 */
mRecord.startRecording("/sdcard/a.mp4",
                      720,
                      1280,
                      2000, // 2M bit rate
                      30,
                      false,
                      44100,
                      1, // Mono
                      128, // 128K Rate
                      Int.MAX_VALUE)

mRecord.stopRecording()

mVideoEditor = TrinityCore.createEditor(this)

val surfaceView = findViewById<SurfaceView>(R.id.surface_view)
mVideoEditor.setSurfaceView(surfaceView)

val clip = MediaClip(file.absolutePath)
mVideoEditor.insertClip(clip)

val clip = MediaClip(file.absolutePath)
mVideoEditor.insertClip(0, clip)

/**
 * Delete a segment in accordance with the subscript
 */
mVideoEditor.removeClip(index)

val count = mVideoEditor.getClipsCount()

 /**
  * If the fragment does not exist, returns a null
  */
val clip = mVideoEditor.getClip(index)

mVideoEditor.replaceClip(index, clip)

 /**
  * Returns a collection of all clips
  */
val clips = mVideoEditor.getVideoClips()

val duration = mVideoEditor.getVideoDuration()

val current = mVideoEditor.getCurrentPosition()

val timeRange = mVideoEditor.getClipTimeRange(index)

val index = mVideoEditor.getClipIndex(time)

 /**
  * @param config background music json content
  * The specific json content is as follows:
  * {
  *   "path": "/sdcard/trinity.mp3",
  *   "startTime": 0,
  *   "endTime": 2000
  * }
  * json parameter explanation:
  * path: the local address of the music
  * startTime: the start time of this music
  * endTime: the end time of this music 2000 means this music only plays for 2 seconds
  */
val actionId = mVideoEditor.addMusic(config)

 /**
  * @param config background music json content
  * The specific json content is as follows:
  * {
  *   "path": "/sdcard/trinity.mp3",
  *   "startTime": 2000,
  *   "endTime": 4000
  *}
  * json parameter explanation:
  * path: the local address of the music
  * startTime: the start time of this music
  * endTime: the end time of this music 4000 means this music is played for 2 seconds from the start time to the end time
  */
val actionId = mVideoEditor.addMusic(config)

 /**
  * Remove background music
  * @param actionId must be the actionId returned when adding background music
  */
mVideoEditor.deleteMusic(actionId)

/**
 * Add filters
 * For example: the absolute path of content.json is /sdcard/Android/com.trinity.sample/cache/filters/config.json
 * The path only needs /sdcard/Android/com.trinity.sample/cache/filters
 * If the current path does not contain config.json, the addition fails
 * The specific json content is as follows:
 * {
 *   "type": 0,
 *   "intensity": 1.0,
 *   "lut": "lut_124 / lut_124.png"
 * }
 *
 * json parameter explanation:
 * type: reserved field, currently has no effect
 * intensity: filter transparency, no difference between 0.0 and camera acquisition
 * lut: the address of the filter color table, must be a local address, and it is a relative path
 * Path splicing will be performed inside sdk
 * @param configPath filter parent directory of config.json
 * @return returns the unique id of the current filter
*/
val actionId = mVideoEditor.addFilter(config)

/**
 * Update filters
 * @param configPath config.json path, currently addFilter description
 * @param startTime filter start time
 * @param endTime filter end time
 * @param actionId Which filter needs to be updated, must be the actionId returned by addFilter
 */
mVideoEditor.updateFilter(config, 0, 2000, actionId)

  /**
   * Delete filter
   * @param actionId Which filter needs to be deleted, it must be the actionId returned when addFilter
   */
mVideoEditor.deleteFilter (actionId)

/**
 * Add special effects
 * For example: the absolute path of content.json is /sdcard/Android/com.trinity.sample/cache/effects/config.json
 * The path only needs /sdcard/Android/com.trinity.sample/cache/effects
 * If the current path does not contain config.json, the addition fails
 * @param configPath filter parent directory of config.json
 * @return returns the unique id of the current effect
 */
val actionId = mVideoEditor.addAction(configPath)

/**
 * Update specific effects
 * @param startTime The start time of the effect
 * @param endTime End time of the effect
 * @param actionId Which effect needs to be updated, must be the actionId returned by addAction
 */
mVideoEditor.updateAction(0, 2000, actionId)

/**
 * Delete a special effect
 * @param actionId Which effect needs to be deleted, must be the actionId returned by addAction
 */
mVideoEditor.deleteAction(actionId)

mVideoEditor.prepare()

/**
 * @param repeat whether to repeat playback
 */
mVideoEditor.play(repeat)

mVideoEditor.pause()

mVideoEditor.resume()

mVideoEditor.stop()

mVideoEditor.destroy()

val export = TrinityCore.createExport(this)

/**
  * Start export
  * @param info export object
  * @param l export callback, success failed and progress
  * @return Int ErrorCode.SUCCESS is sucess, other failed
  */
// Create export object, must be insert video out path 
val exportVideoInfo = VideoExportInfo("/sdcard/export.mp4")
// use hardware decode
exportVideoInfo.mediaCodecDecode = true
// use hardware encode
exportVideoInfo.mediaCodecEncode = true  
// video width
exportVideoInfo.width = 544
// video height
exportVideoInfo.height = 960
// frame rate
exportVideoInfo.frameRate = 25
// video bitrate 2M
exportVideoInfo.videoBitRate = 2000
// sample rate
exportVideoInfo.sampleRate = 44100
// channel
exportVideoInfo.channelCount = 1
// audio bitrate 128K
exportVideoInfo.audioBitRate = 128
export.export(exportVideoInfo, this)

export.cancel()

export.release()