Video Handling

import { ContentFeedType, FileRepository } from '@amityco/ts-sdk';

async function uploadVideo(video: File) {
  const formData = new FormData();
  formData.append('files', video);

  const { data: videos } = await FileRepository.uploadVideo(
    formData,
    ContentFeedType.POST,
    percent => {
      console.log(`Upload progress: ${percent}%`);
    },
  );

  return videos[0].fileId;
}

let videoURL = URL(fileURLWithPath: "/tmp/video.mov")

let uploadedVideo = try await fileRepository.uploadVideo(
    with: videoURL,
    progress: { progress in
        print("Upload progress: \(progress)")
    }
)

let videoFileId = uploadedVideo.fileId

val videoUri = Uri.parse("file:///tmp/video.mp4")

AmityCoreClient.newFileRepository()
    .uploadVideo(
        uri = videoUri,
        contentFeedType = AmityContentFeedType.POST
    )
    .doOnNext { result: AmityUploadResult<AmityVideo> ->
        when (result) {
            is AmityUploadResult.PROGRESS -> {
                val progress = result.getUploadInfo().getProgressPercentage()
            }
            is AmityUploadResult.COMPLETE -> {
                val uploadedVideo = result.getFile()
                val videoFileId = uploadedVideo.getFileId()
            }
            is AmityUploadResult.ERROR -> {
                val error = AmityError.from(result.getError())
            }
            is AmityUploadResult.CANCELLED -> {
                // Upload was canceled.
            }
        }
    }
    .subscribe()

import 'dart:io';

final video = File('/tmp/video.mp4');

AmityCoreClient.newFileRepository()
    .uploadVideo(video, feedtype: AmityContentFeedType.POST)
    .stream
    .listen((AmityUploadResult<AmityVideo> result) {
  result.when(
    progress: (uploadInfo, cancelToken) {
      final progress = uploadInfo.getProgressPercentage();
    },
    complete: (uploadedVideo) {
      final videoFileId = uploadedVideo.fileId;
      final resolutions = uploadedVideo.getResolutions();
    },
    error: (error) {
      final exception = error;
    },
    cancel: () {
      // Upload was canceled.
    },
  );
});

import { FileRepository } from '@amityco/ts-sdk';

async function getVideo(videoFileId: string) {
  const { data: video } = await FileRepository.getFile<'video'>(videoFileId);
  const playbackUrl = video.videoUrl?.['720p'] ?? video.fileUrl;

  return {
    playbackUrl,
    status: video.status,
    width: video.getWidth(),
    height: video.getHeight(),
    rotation: video.getRotation(),
  };
}

let rawFile = try await fileRepository.getFile(fileId: videoFileId)

if rawFile.type == .video, let videoData = rawFile.mapToVideoData() {
    let status = videoData.status
    let resolutions = Array(videoData.videoUrls.keys).sorted()
    let playbackURL = videoData.getVideo(resolution: .res_720p)
    let width = videoData.getWidth()
    let height = videoData.getHeight()
    let rotation = videoData.getRotation()
}

AmityCoreClient.newFileRepository()
    .getFile(videoFileId)
    .doOnSuccess { rawFile: AmityRawFile ->
        val video = rawFile.asAmityVideo()
        val status = video?.getStatus()
        val resolutions = video?.getResolutions().orEmpty()
        val playbackUrl = video?.getVideoUrl(AmityVideoResolution.RES_720)
        val width = video?.getWidth()
        val height = video?.getHeight()
        val rotation = video?.getRotation()
    }
    .subscribe()

void inspectVideo(AmityVideo video) {
  final resolutions = video.getResolutions();
  final playbackUrl = video.getVideoUrl(AmityVideoResolution.RES_720);
}