feat(atproto): add bookmarks support

README.md

···
 - [X] Like, repost, reply, quote, and pin
 - [X] Search
 - [ ] Mute, block, and report
-- [ ] Bookmarks
+- [X] Bookmarks
 - [ ] Lists
 - [ ] Filters
 - [ ] Trending posts

mastodon/src/main/java/org/joinmastodon/android/api/StatusInteractionController.java

···
 import app.bsky.actor.Profile;
 import app.bsky.feed.Like;
 import app.bsky.feed.Repost;
+import kotlin.Unit;
 import kotlin.time.Clock;
 import me.grishka.appkit.api.Callback;
 import me.grishka.appkit.api.ErrorResponse;
···
 	public void setBookmarked(Status status, boolean bookmarked){
 		if(!Looper.getMainLooper().isCurrentThread())
 			throw new IllegalStateException("Can only be called from main thread");
+
+		AccountSession session=AccountSessionManager.get(accountID);
+		if(session.protocol==Protocol.ATPROTO){
+			setBookmarkedAtProto(session, status, bookmarked);
+			return;
+		}
 
 		SetStatusBookmarked current=runningBookmarkRequests.remove(status.id);
 		if(current!=null){
···
 					else
 						status.reblogsCount++;
 					E.post(new StatusCountersUpdatedEvent(status, StatusCountersUpdatedEvent.CounterType.REBLOGS));
+					Toast.makeText(MastodonApp.context, "Action failed: "+e.getLocalizedMessage(), Toast.LENGTH_SHORT).show();
+				});
+			}
+		});
+	}
+
+	private void setBookmarkedAtProto(AccountSession session, Status status, boolean bookmarked){
+		status.bookmarked=bookmarked;
+		E.post(new StatusCountersUpdatedEvent(status, StatusCountersUpdatedEvent.CounterType.BOOKMARKS));
+
+		MastodonAPIController.runInBackground(()->{
+			try{
+				if(bookmarked){
+					AtpResponse<Unit> resp = session.executeBluesky((client)->{
+						return AtProtoClient.createBookmark(client, AtProtoClient.createCreateBookmarkRequest(status.uri, status.cid));
+					});
+					if(!(resp instanceof AtpResponse.Success)){
+						throw new Exception("Failed to create bookmark: "+resp);
+					}
+				}else{
+					session.executeBluesky((client)->{
+						return AtProtoClient.deleteBookmark(client, AtProtoClient.createDeleteBookmarkRequest(status.uri));
+					});
+				}
+			}catch(Exception e){
+				Handler uiHandler=new Handler(Looper.getMainLooper());
+				uiHandler.post(()->{
+					status.bookmarked=!bookmarked;
+					E.post(new StatusCountersUpdatedEvent(status, StatusCountersUpdatedEvent.CounterType.BOOKMARKS));
 					Toast.makeText(MastodonApp.context, "Action failed: "+e.getLocalizedMessage(), Toast.LENGTH_SHORT).show();
 				});
 			}

mastodon/src/main/java/org/joinmastodon/android/api/atproto/AtProtoClient.kt

···
 import app.bsky.graph.*
 import app.bsky.notification.*
 import app.bsky.richtext.*
+import app.bsky.bookmark.*
 import kotlin.time.Instant
 import kotlin.time.Clock
 import io.ktor.utils.io.ByteReadChannel
···
     @JvmStatic
     @JvmOverloads
     fun createRepost(subject: StrongRef, createdAt: Instant, via: StrongRef? = null): Repost = Repost(subject, createdAt, via)
+
+    @JvmStatic
+    fun createCreateBookmarkRequest(uri: String, cid: String): CreateBookmarkRequest = CreateBookmarkRequest(AtUri(uri), Cid(cid))
+
+    @JvmStatic
+    fun createDeleteBookmarkRequest(uri: String): DeleteBookmarkRequest = DeleteBookmarkRequest(AtUri(uri))
+
+    @JvmStatic
+    fun createGetBookmarksQueryParams(limit: Long?, cursor: String?): GetBookmarksQueryParams = GetBookmarksQueryParams(limit, cursor)
+
+    @JvmStatic
+    fun createGetActorLikesQueryParams(actor: String, limit: Long?, cursor: String?): GetActorLikesQueryParams = GetActorLikesQueryParams(createAtIdentifier(actor), limit, cursor)
+
+	@JvmStatic
+	fun getActorLikes(client: XrpcBlueskyApi, params: GetActorLikesQueryParams): AtpResponse<GetActorLikesResponse> = runBlocking {
+		client.getActorLikes(params)
+	}
+
+    @JvmStatic
+    fun createBookmark(client: XrpcBlueskyApi, request: CreateBookmarkRequest): AtpResponse<Unit> = runBlocking {
+        client.createBookmark(request)
+    }
+
+    @JvmStatic
+    fun deleteBookmark(client: XrpcBlueskyApi, request: DeleteBookmarkRequest): AtpResponse<Unit> = runBlocking {
+        client.deleteBookmark(request)
+    }
+
+    @JvmStatic
+    fun getBookmarks(client: XrpcBlueskyApi, params: GetBookmarksQueryParams): AtpResponse<GetBookmarksResponse> = runBlocking {
+        client.getBookmarks(params)
+    }
+
+    @JvmStatic
+    fun getBookmarksList(response: GetBookmarksResponse): List<BookmarkView> = response.bookmarks
 }

mastodon/src/main/java/org/joinmastodon/android/api/atproto/AtProtoMapper.kt

···
 		post.viewer?.let { viewer ->
 			status.favourited = viewer.like != null
 			status.reblogged = viewer.repost != null
+			status.bookmarked = viewer.bookmarked ?: false
+			status.pinned = viewer.pinned ?: false
 			status.atProtoLikeUri = viewer.like?.atUri
 			status.atProtoRepostUri = viewer.repost?.atUri
 

mastodon/src/main/java/org/joinmastodon/android/fragments/AccountTimelineFragment.java

···
 	private GetAccountStatuses.Filter filter;
 	private HorizontalScrollView filtersBar;
 	private FilterChipView defaultFilter, withRepliesFilter, mediaFilter;
+	private String atProtoNextCursor;
 
 	public AccountTimelineFragment(){
 		setListLayoutId(R.layout.recycler_fragment_no_refresh);
···
 					default->null;
 				};
 				AtpResponse<GetAuthorFeedResponse> resp=session.executeBluesky((client)->{
-					GetAuthorFeedQueryParams params=AtProtoClient.createGetAuthorFeedQueryParams(user.username, (long)count, offset>0 ? getMaxID() : null, filterVal, false);
+					GetAuthorFeedQueryParams params=AtProtoClient.createGetAuthorFeedQueryParams(user.username, (long)count, offset>0 ? atProtoNextCursor : null, filterVal, false);
 					return AtProtoClient.getAuthorFeed(client,params);
 				});
 				if(resp instanceof AtpResponse.Success<GetAuthorFeedResponse> success){
 					GetAuthorFeedResponse data=success.getResponse();
 					List<Status> result=AtProtoMapper.mapFeed(data.getFeed());
-					String nextCursor=data.getCursor();
+					atProtoNextCursor=data.getCursor();
 					
 					getActivity().runOnUiThread(()->{
 						session.filterStatuses(result, FilterContext.ACCOUNT);
-						onDataLoaded(result, nextCursor!=null);
+						onDataLoaded(result, atProtoNextCursor!=null);
 					});
 				}else{
 					throw new Exception("Failed to load author feed: "+resp);

mastodon/src/main/java/org/joinmastodon/android/fragments/SavedPostsTimelineFragment.java

···
 import android.widget.TextView;
 
 import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.MastodonErrorResponse;
 import org.joinmastodon.android.api.requests.statuses.GetBookmarkedStatuses;
 import org.joinmastodon.android.api.requests.statuses.GetFavoritedStatuses;
+import org.joinmastodon.android.api.atproto.AtProtoClient;
+import org.joinmastodon.android.api.atproto.AtProtoMapper;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.api.MastodonAPIController;
+
+import app.bsky.feed.FeedViewPost;
+import app.bsky.feed.GetActorLikesResponse;
+import sh.christian.ozone.api.response.AtpResponse;
+import app.bsky.bookmark.GetBookmarksResponse;
+import app.bsky.bookmark.BookmarkView;
+import app.bsky.bookmark.BookmarkViewItemUnion;
+import app.bsky.feed.GetLikesResponse;
+import app.bsky.feed.GetLikesLike;
+import app.bsky.feed.GetLikesQueryParams;
+
+import java.util.ArrayList;
+import java.util.List;
 import org.joinmastodon.android.events.RemoveAccountPostsEvent;
 import org.joinmastodon.android.model.Account;
 import org.joinmastodon.android.model.HeaderPaginationList;
+import org.joinmastodon.android.model.Protocol;
 import org.joinmastodon.android.model.Status;
 import org.joinmastodon.android.ui.drawables.EmptyDrawable;
 import org.joinmastodon.android.ui.views.FilterChipView;
···
 
 	@Override
 	protected void doLoadData(int offset, int count){
+		if(AccountSessionManager.get(accountID).protocol==Protocol.ATPROTO){
+			doLoadDataATProto(offset, count);
+			return;
+		}
 		currentRequest=(switch(mode){
 			case FAVORITES -> new GetFavoritedStatuses(offset>0 ? nextPageMaxID : null, count);
 			case BOOKMARKS -> new GetBookmarkedStatuses(offset>0 ? nextPageMaxID : null, count);
···
 				nextPageMaxID=result.getNextPageMaxID();
 			}
 		}).exec(accountID);
+	}
+
+	protected void doLoadDataATProto(int offset, int count){
+		MastodonAPIController.runInBackground(()->{
+			try{
+				if(mode==Mode.BOOKMARKS){
+					var params=AtProtoClient.createGetBookmarksQueryParams((long)count, offset==0 ? null : nextPageMaxID);
+					var resp=AccountSessionManager.get(accountID).executeBluesky(client->AtProtoClient.getBookmarks(client, params));
+					if(resp instanceof AtpResponse.Success<GetBookmarksResponse> success){
+						GetBookmarksResponse result=success.getResponse();
+						List<BookmarkView> bookmarks=AtProtoClient.getBookmarksList(result);
+						List<Status> statuses=new ArrayList<>();
+						for(BookmarkView b:bookmarks){
+							if(b.getItem() instanceof BookmarkViewItemUnion.PostView item){
+								Status s=AtProtoMapper.mapPost(item.getValue());
+								statuses.add(s);
+							}
+						}
+						nextPageMaxID=result.getCursor();
+						getActivity().runOnUiThread(()->onDataLoaded(statuses, nextPageMaxID!=null));
+					}else{
+						throw new Exception("Failed to load bookmarks: "+resp);
+					}
+				}else{
+					// FAVORITES
+					var params=AtProtoClient.createGetActorLikesQueryParams(user.id, (long)count, offset==0 ? null : nextPageMaxID);
+					var resp=AccountSessionManager.get(accountID).executeBluesky(client->AtProtoClient.getActorLikes(client, params));
+					if(resp instanceof AtpResponse.Success<GetActorLikesResponse> success){
+						GetActorLikesResponse result=success.getResponse();
+						List<Status> statuses=AtProtoMapper.mapFeed(result.getFeed());
+						nextPageMaxID=result.getCursor();
+						getActivity().runOnUiThread(()->onDataLoaded(statuses, nextPageMaxID!=null));
+					}else{
+						throw new Exception("Failed to load likes: "+resp);
+					}
+				}
+			}catch(Exception x){
+				getActivity().runOnUiThread(()->onError(new MastodonErrorResponse(x.getLocalizedMessage(), 0, x)));
+			}
+		});
 	}
 
 	@Override