116 lines
3.0 KiB
Go
116 lines
3.0 KiB
Go
package protocol
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
neturl "net/url"
|
|
"path"
|
|
"regexp"
|
|
|
|
"go.uber.org/zap"
|
|
|
|
"github.com/status-im/status-go/images"
|
|
"github.com/status-im/status-go/protocol/common"
|
|
"github.com/status-im/status-go/protocol/protobuf"
|
|
)
|
|
|
|
const (
|
|
maxImageSize = 1024 * 350
|
|
)
|
|
|
|
var imageURLRegexp = regexp.MustCompile(`(?i)^.+(png|jpg|jpeg|webp)$`)
|
|
|
|
type ImageUnfurler struct {
|
|
url *neturl.URL
|
|
logger *zap.Logger
|
|
httpClient *http.Client
|
|
}
|
|
|
|
func NewImageUnfurler(URL *neturl.URL, logger *zap.Logger, httpClient *http.Client) *ImageUnfurler {
|
|
return &ImageUnfurler{
|
|
url: URL,
|
|
logger: logger,
|
|
httpClient: httpClient,
|
|
}
|
|
}
|
|
|
|
func compressImage(imgBytes []byte) ([]byte, error) {
|
|
smallest := imgBytes
|
|
|
|
img, err := images.DecodeImageData(imgBytes, bytes.NewReader(imgBytes))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
compressed := bytes.NewBuffer([]byte{})
|
|
err = images.CompressToFileLimits(compressed, img, images.DefaultBounds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(compressed.Bytes()) < len(smallest) {
|
|
smallest = compressed.Bytes()
|
|
}
|
|
|
|
if len(smallest) > maxImageSize {
|
|
return nil, errors.New("image too large")
|
|
}
|
|
|
|
return smallest, nil
|
|
}
|
|
|
|
// IsSupportedImageURL detects whether a URL ends with one of the
|
|
// supported image extensions. It provides a quick way to identify whether URLs
|
|
// should be unfurled as images without needing to retrieve the full response
|
|
// body first.
|
|
func IsSupportedImageURL(url *neturl.URL) bool {
|
|
return imageURLRegexp.MatchString(url.Path)
|
|
}
|
|
|
|
// isSupportedImage returns true when payload is one of the supported image
|
|
// types. In the future, we should differentiate between animated and
|
|
// non-animated WebP because, currently, only static WebP can be processed by
|
|
// functions in the status-go/images package.
|
|
func isSupportedImage(payload []byte) bool {
|
|
return images.IsJpeg(payload) || images.IsPng(payload) || images.IsWebp(payload)
|
|
}
|
|
|
|
func (u *ImageUnfurler) Unfurl() (*common.LinkPreview, error) {
|
|
preview := newDefaultLinkPreview(u.url)
|
|
preview.Type = protobuf.UnfurledLink_IMAGE
|
|
|
|
headers := map[string]string{"user-agent": headerUserAgent}
|
|
imgBytes, err := fetchBody(u.logger, u.httpClient, u.url.String(), headers)
|
|
if err != nil {
|
|
return preview, err
|
|
}
|
|
|
|
if !isSupportedImage(imgBytes) {
|
|
return preview, fmt.Errorf("unsupported image type url='%s'", u.url.String())
|
|
}
|
|
|
|
compressedBytes, err := compressImage(imgBytes)
|
|
if err != nil {
|
|
return preview, fmt.Errorf("failed to compress image url='%s': %w", u.url.String(), err)
|
|
}
|
|
|
|
width, height, err := images.GetImageDimensions(compressedBytes)
|
|
if err != nil {
|
|
return preview, fmt.Errorf("could not get image dimensions url='%s': %w", u.url.String(), err)
|
|
}
|
|
|
|
dataURI, err := images.GetPayloadDataURI(compressedBytes)
|
|
if err != nil {
|
|
return preview, fmt.Errorf("could not build data URI url='%s': %w", u.url.String(), err)
|
|
}
|
|
|
|
preview.Title = path.Base(u.url.Path)
|
|
preview.Thumbnail.Width = width
|
|
preview.Thumbnail.Height = height
|
|
preview.Thumbnail.DataURI = dataURI
|
|
|
|
return preview, nil
|
|
}
|