Image Handling

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

async function uploadImage(image: File) {
  const formData = new FormData();
  formData.append('file', image);

  const { data: images } = await FileRepository.uploadImage(
    formData,
    percent => {
      console.log(`Upload progress: ${percent}%`);
    },
    'Profile photo',
  );

  return images[0].fileId;
}

let image = UIImage()

let uploadedImage = try await fileRepository.uploadImage(
    image,
    altText: "Profile photo",
    progress: { progress in
        print("Upload progress: \(progress)")
    }
)

let imageFileId = uploadedImage.fileId

val imageUri = Uri.parse("file:///tmp/profile.jpg")

AmityCoreClient.newFileRepository()
    .uploadImage(uri = imageUri, altText = "Profile photo")
    .doOnNext { result: AmityUploadResult<AmityImage> ->
        when (result) {
            is AmityUploadResult.PROGRESS -> {
                val progress = result.getUploadInfo().getProgressPercentage()
            }
            is AmityUploadResult.COMPLETE -> {
                val uploadedImage = result.getFile()
                val imageFileId = uploadedImage.getFileId()
            }
            is AmityUploadResult.ERROR -> {
                val error = AmityError.from(result.getError())
            }
            is AmityUploadResult.CANCELLED -> {
                // Upload was canceled.
            }
        }
    }
    .subscribe()

import 'dart:io';

final image = File('/tmp/profile.jpg');

AmityCoreClient.newFileRepository()
    .uploadImage(image, isFullImage: true)
    .stream
    .listen((AmityUploadResult<AmityImage> result) {
  result.when(
    progress: (uploadInfo, cancelToken) {
      final progress = uploadInfo.getProgressPercentage();
    },
    complete: (uploadedImage) {
      final imageFileId = uploadedImage.fileId;
      final fullImageUrl = uploadedImage.getUrl(AmityImageSize.FULL);
    },
    error: (error) {
      final exception = error;
    },
    cancel: () {
      // Upload was canceled.
    },
  );
});

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

async function getImage(imageFileId: string) {
  const { data: image } = await FileRepository.getFile<'image'>(imageFileId);
  const mediumUrl = FileRepository.fileUrlWithSize(image.fileUrl, 'medium');

  return {
    mediumUrl,
    altText: image.altText,
    width: image.attributes.metadata.width,
    height: image.attributes.metadata.height,
  };
}

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

if rawFile.type == .image, let imageData = rawFile.mapToImageData() {
    let width = imageData.metadata["width"] as? Int
    let height = imageData.metadata["height"] as? Int

    fileRepository.downloadImage(fromURL: imageData.fileURL, size: .medium) { localURL, error in
        print("Downloaded image: \(String(describing: localURL))")
    }
}

AmityCoreClient.newFileRepository()
    .getFile(imageFileId)
    .doOnSuccess { rawFile: AmityRawFile ->
        val image = rawFile.asAmityImage()
        val mediumUrl = image?.getUrl(AmityImage.Size.MEDIUM)
        val width = image?.getWidth()
        val height = image?.getHeight()
        val altText = image?.getAltText()
    }
    .subscribe()

void inspectImage(AmityImage image) {
  final mediumUrl = image.getUrl(AmityImageSize.MEDIUM);
  final width = image.getWidth();
  final height = image.getHeight();
  final isFullImage = image.isFullImage();
}