feat: SendLivePhoto

messages.sendMedia with InputMediaUploadedPhoto{LivePhoto:true, Video:...}: the
still photo is an uploaded file, the live_photo video is finalized to an input
document (upload via uploadMedia, or a file_id). Reuses the message.Sender media
path for caption/reply/markup. Factors out a mimeVideoMP4 constant. Mapping
confirmed against telegram-bot-api 10.1. Hermetic tests; lint clean.

Author: ernado

edit_media.go

@@ -86,10 +86,10 @@ func (b *Bot) inputMediaToTg(ctx context.Context, m InputMedia) (tg.InputMediaCl
 		media, err := b.photoInputMedia(ctx, m.Media)
 		return media, captionData{m.Caption, m.ParseMode, m.CaptionEntities}, err
 	case *InputMediaVideo:
-		media, err := b.documentInputMedia(ctx, m.Media, "video/mp4")
+		media, err := b.documentInputMedia(ctx, m.Media, mimeVideoMP4)
 		return media, captionData{m.Caption, m.ParseMode, m.CaptionEntities}, err
 	case *InputMediaAnimation:
-		media, err := b.documentInputMedia(ctx, m.Media, "video/mp4")
+		media, err := b.documentInputMedia(ctx, m.Media, mimeVideoMP4)
 		return media, captionData{m.Caption, m.ParseMode, m.CaptionEntities}, err
 	case *InputMediaAudio:
 		media, err := b.documentInputMedia(ctx, m.Media, "audio/mpeg")

inline_query_result.go

@@ -9,6 +9,9 @@ import (
 // mimeImageJPEG is the default thumbnail MIME type for inline results.
 const mimeImageJPEG = "image/jpeg"
 
+// mimeVideoMP4 is the MIME type used for uploaded video documents.
+const mimeVideoMP4 = "video/mp4"
+
 // errNilInlineResult is returned when a method is given a nil InlineQueryResult.
 func errNilInlineResult() *Error {
 	return &Error{Code: 400, Description: "Bad Request: inline query result is nil"}
@@ -349,7 +352,7 @@ func (r *InlineQueryResultGif) toTg(ctx context.Context, b *Bot) (tg.InputBotInl
 
 func (r *InlineQueryResultMpeg4Gif) toTg(ctx context.Context, b *Bot) (tg.InputBotInlineResultClass, error) {
 	return b.webResult(ctx, r.ID, "gif", r.Title, "",
-		r.Mpeg4URL, "video/mp4", r.ThumbnailURL, 0, 0,
+		r.Mpeg4URL, mimeVideoMP4, r.ThumbnailURL, 0, 0,
 		r.InputMessageContent, r.captioned, r.ReplyMarkup)
 }
 

live_photo.go

@@ -0,0 +1,74 @@
+package botapi
+
+import (
+	"context"
+
+	"github.com/gotd/td/telegram/message"
+	"github.com/gotd/td/telegram/message/styling"
+	"github.com/gotd/td/tg"
+)
+
+// liveVideoDocument resolves the video component of a live photo into an MTProto
+// input document. An upload is finalized through messages.uploadMedia; a file_id
+// references an existing document. URLs are not supported.
+func (b *Bot) liveVideoDocument(ctx context.Context, file InputFile) (tg.InputDocumentClass, error) {
+	switch f := file.(type) {
+	case InputFileID:
+		return inputDocumentFromFileID(string(f))
+	case *InputFileUpload:
+		uploaded, err := b.uploadInputFile(ctx, f)
+		if err != nil {
+			return nil, err
+		}
+
+		media, err := b.uploadMediaRef(ctx, &tg.InputMediaUploadedDocument{
+			File:       uploaded,
+			MimeType:   mimeVideoMP4,
+			Attributes: []tg.DocumentAttributeClass{&tg.DocumentAttributeVideo{}},
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		doc, ok := media.(*tg.InputMediaDocument)
+		if !ok {
+			return nil, &Error{Code: 500, Description: "Internal Server Error: unexpected live photo video media"}
+		}
+
+		return doc.ID, nil
+	default:
+		return nil, &Error{Code: 400, Description: "Bad Request: live photo video must be an uploaded file or file_id"}
+	}
+}
+
+// SendLivePhoto sends a live photo (an Apple-style still image paired with a short
+// video). The still photo must be an uploaded file; livePhoto is its video, an
+// uploaded file or a file_id.
+func (b *Bot) SendLivePhoto(
+	ctx context.Context, chat ChatID, photo, livePhoto InputFile, caption string, opts ...SendOption,
+) (*Message, error) {
+	up, ok := photo.(*InputFileUpload)
+	if !ok {
+		return nil, &Error{Code: 400, Description: "Bad Request: live photo still must be an uploaded file"}
+	}
+
+	return b.sendResolvedMedia(ctx, chat, caption, func(ctx context.Context, c []styling.StyledTextOption) (message.MediaOption, error) {
+		photoFile, err := b.uploadInputFile(ctx, up)
+		if err != nil {
+			return nil, err
+		}
+
+		video, err := b.liveVideoDocument(ctx, livePhoto)
+		if err != nil {
+			return nil, err
+		}
+
+		media := &tg.InputMediaUploadedPhoto{
+			File:      photoFile,
+			Video:     video,
+			LivePhoto: true,
+		}
+
+		return message.Media(media, c...), nil
+	}, opts...)
+}

live_photo_test.go

@@ -0,0 +1,63 @@
+package botapi
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gotd/td/tg"
+)
+
+func TestSendLivePhoto(t *testing.T) {
+	inv := newMockInvoker()
+	inv.reply(tg.MessagesUploadMediaRequestTypeID, &tg.MessageMediaDocument{
+		Document: &tg.Document{
+			ID: 5, AccessHash: 6, FileReference: []byte{0}, MimeType: "video/mp4", Size: 2000, DCID: 2,
+			Attributes: []tg.DocumentAttributeClass{&tg.DocumentAttributeVideo{}},
+		},
+	})
+	inv.reply(tg.MessagesSendMediaRequestTypeID, sendMediaOK())
+
+	b := newMockBot(inv)
+
+	_, err := b.SendLivePhoto(context.Background(), userRef(10, 20),
+		FileFromBytes("still.jpg", []byte("img")),
+		FileFromBytes("live.mp4", []byte("vid")),
+		"caption")
+	if err != nil {
+		t.Fatalf("SendLivePhoto: %v", err)
+	}
+
+	if !inv.called(tg.MessagesUploadMediaRequestTypeID) {
+		t.Fatal("live photo video should be finalized via uploadMedia")
+	}
+
+	var req tg.MessagesSendMediaRequest
+
+	inv.decode(t, tg.MessagesSendMediaRequestTypeID, &req)
+
+	media, ok := req.Media.(*tg.InputMediaUploadedPhoto)
+	if !ok {
+		t.Fatalf("media = %#v, want uploaded photo", req.Media)
+	}
+
+	if !media.LivePhoto {
+		t.Fatal("LivePhoto flag should be set")
+	}
+
+	if _, ok := media.GetVideo(); !ok {
+		t.Fatal("live photo should attach a video document")
+	}
+}
+
+func TestSendLivePhotoStillMustUpload(t *testing.T) {
+	inv := newMockInvoker()
+
+	if _, err := newMockBot(inv).SendLivePhoto(context.Background(), userRef(10, 20),
+		FileID("somefileid"), FileFromBytes("live.mp4", []byte("vid")), ""); err == nil {
+		t.Fatal("expected error when still photo is not an upload")
+	}
+
+	if inv.count() != 0 {
+		t.Fatalf("made %d RPC calls, want 0", inv.count())
+	}
+}

paid_media.go

@@ -155,7 +155,7 @@ func (b *Bot) paidUploadedVideo(ctx context.Context, f *InputFileUpload, v Input
 
 	doc := &tg.InputMediaUploadedDocument{
 		File:       uploaded,
-		MimeType:   "video/mp4",
+		MimeType:   mimeVideoMP4,
 		Attributes: []tg.DocumentAttributeClass{video},
 	}
 	if f.Name != "" {

stories.go

@@ -280,7 +280,7 @@ func (b *Bot) storyVideoMedia(ctx context.Context, content InputStoryContentVide
 
 		return &tg.InputMediaUploadedDocument{
 			File:         upFile,
-			MimeType:     "video/mp4",
+			MimeType:     mimeVideoMP4,
 			NosoundVideo: content.IsAnimation,
 			Attributes:   []tg.DocumentAttributeClass{&video},
 		}, nil