refactor(SavedPostsTimelineFragment.java): add getFilterContext and getWebUri methods back

We don't use this implementation, but we keep it so the app still compiles

README.md

@@ -1,26 +1,92 @@
-Mastodon for Android
-======================
+# ![MoshidonLogo](mastodon/src/main/res/mipmap-xhdpi/ic_launcher_round.png) Moshidon, the material you mastodon client!
 
-[![Crowdin](https://badges.crowdin.net/mastodon-for-android/localized.svg)](https://crowdin.com/project/mastodon-for-android)
+## This is the rewrite branch. Things probably won't as you expect here for a while
 
-This is the repository for the official Android app for Mastodon.
+> A fast, highly customizable, up-to-date fork of [megalodon](https://github.com/sk22/megalodon) adding important features such as a fully federated timeline, unlisted posting, drafts, scheduled posts, bookmarks, and alt text warnings.
 
-[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png"
-     alt="Get it on F-Droid"
-     height="80">](https://f-droid.org/packages/org.joinmastodon.android/)
-[<img src="https://play.google.com/intl/en_us/badges/images/generic/en-play-badge.png"
-     alt="Get it on Google Play"
-     height="80">](https://play.google.com/store/apps/details?id=org.joinmastodon.android)
 
-Or get the APK from the [The Releases Section](https://github.com/mastodon/mastodon-android/releases/latest).
+## Download Now
 
-## Contributing
+<a href="https://play.google.com/store/apps/details?id=org.joinmastodon.android.moshinda"><img height="35" alt="Get it on Google Play" src="img/google-play-badge.png"></a> <a href="https://f-droid.org/pt_BR/packages/org.joinmastodon.android.moshinda"><img height="35" alt="Get it on F-Droid" src="img/f-droid-badge.png"></a> <a href="https://apt.izzysoft.de/fdroid/index/apk/org.joinmastodon.android.moshinda"><img height="35" alt="Get it on IzzyOnDroid" src="img/izzy-badge.png"></a>
 
-Our goal is delivering a polished, professionally designed and user-friendly app. We proceed according to wireframes provided by a professional UX designer that works with Mastodon gGmbH. This means that any outside contributions that change the app visually must first be coordinated with the UX designer. *This can take time.* Furthermore, we work off of an internal roadmap and aim for feature-parity and consistency with our iOS app. The iOS app is designated as the "primary" between the two, therefore, if you want to request features, please do so in the [Mastodon for iOS](https://github.com/mastodon/mastodon-ios) repository, as you are requesting a feature to be both in iOS and Android (exceptions being system integrations specific to Android). On the other hand, any contributions that improve existing functionality, performance, or accessibility should not have any roadblocks to being merged.
+[![GitHub Release Download](https://img.shields.io/badge/dynamic/json?color=282C37&label=Download%20APK&query=%24.tag_name&url=https%3A%2F%2Fapi.github.com%2Frepos%2FLucasGGamerM%2Fmoshidon%2Freleases%2Flatest&style=for-the-badge)](https://github.com/LucasGGamerM/moshidon/releases/latest/download/moshidon.apk) [![Translation status](https://translate.codeberg.org/widgets/moshidon/-/svg-badge.svg)](https://translate.codeberg.org/engage/moshidon/) [![GitHub Nightly Download](https://img.shields.io/badge/dynamic/json?color=282C37&label=Download%20Nightly%20APK&query=%24.tag_name&url=https%3A%2F%2Fapi.github.com%2Frepos%2FLucasGGamerM%2Fmoshidon%2Freleases%2Flatest&style=for-the-badge)](https://github.com/LucasGGamerM/moshidon-nightly/releases/latest/download/moshidon-nightly.apk) [![GitHub Nightly Build Download](https://github.com/LucasGGamerM/moshidon/actions/workflows/nightly-builds.yml/badge.svg)](https://github.com/LucasGGamerM/moshidon/actions/workflows/nightly-builds.yml)
 
-If you would like to help translate the app into your language, please go to [Crowdin](https://crowdin.com/project/mastodon-for-android). If your language is not listed in the Crowdin project, please create an issue and we will add it. Please do not create pull requests that modify `strings.xml` files for languages other than English.
+## Donate
 
-## Building
+<a href="https://github.com/sponsors/LucasGGamerM">Github Sponsors</a> | <a href="https://liberapay.com/LucasGGamerM/donate">Liberapay</a> | Monero Wallet Key: `4886mdarcyB6Yf8Qc6vDJBK1fz6ibHFLZUmHb4GZZz9yLGNhcG3XC64e5UZ8dVQYTLZb82W6P9WhteowW4STJEec97Gf22j`
+
+## Key Features
+
+[ screenshot of full timeline in default colour scheme ]
+[ screenshot of full timeline in an alt colour scheme ]
+[ screenshot of profile page ]
+[ screenshot of compose post window ]
+
+### Flexible Timelines
+
+[ Home dropdown menu ]
+
+Under the Home menu by default you can see your active account's timeline, your server's local timeline, and your server's federated timeline. You can also pin hashtags, lists, other servers, or make a custom view of just your posts, your bookmarks, or your favourites for quick access. Then sort these timelines to prioritize the ones you visit most often.
+
+### Multiple Accounts & Crossposting
+
+Sign in to multiple accounts in the same app and easily switch between them. Press and hold on the boost or fave button to boost or fave a post to a different account than the one you are currently browsing with.
+
+[ boost icon pop up select profile ]
+
+### Drafts & Scheduled Posts
+
+Write posts and save them, or schedule them to post later. Edit and delete your drafts.
+
+### Alt Text Tag & Reminder
+
+An unobtrusive ALT tag appears on images with alt text. Clicking on the icon makes the alt text appear. By default, Moshidon will show a warning to add alt text if your post has any attachments lacking alt text. This is for better accessibility, and it can be disabled in settings. You can also hide from your feed all posts that are lacking in alt text.
+
+[ image with alt text icon higlighted ]
+[ alt text expanded ]
+
+### Themes & Customization
+
+Moshidon is designed according to Material Design principles. Follow your device's light or dark mode settings or change colour palette - your system's default, purple, black & white, "pitch black" (battery saving) and more. Customize your experience by moving or renaming the publish button, show or hide sensitive media by default, reduce motion, collapse long posts, add haptic feedback, or making the fave button a heart &hearts; or a star &starf;.
+
+### Not Just For Mastodon
+
+Supports features available on other types of fediverse servers such as admin announcements, showing pronouns in user names, post translation, emoji reactions, local-only posting, and markdown or html in posts.
+
+### Fully Federated Feed & Profiles
+
+See all public posts from servers your server federates with and fetch profiles from a user's local server for accurate up to date information.
+
+## And more...
+- quote-posts - links to fediverse posts in other posts will be loaded inline like quote-tweets
+- manage pinned posts and bookmarks
+- manage lists, filters, and most privacy settings
+- display pronouns in timelines, threads, and user listings
+- get only specific types of notifications (no more finished polls!), limit who you get notifications from, or group all notifications into one.
+- automatically add "re:" to beginning of replies with content warnings
+- ask before boosting or deleting posts
+- when replying to a boosted post automatically mention the person who boosted it
+- overlay audio from posts, allowing your existing media to keep playing
+- auto-reveal CWs that are the same as ones you've already opened, or always reveal content warnings and sensitive media
+- hide media previews in timelines (save data)
+- show post interaction counts in timeline
+- allow custom emoji in display names
+- enable scrolling text for long display names
+- hide interaction buttons
+- show post dividers
+
+
+## Installation & Releases
+
+Moshidon is available on GitHub, Google Play, F-Droid, and the IzzyOnDroid repo. All sources provide the same ` moshidon.apk ` stable release. Older releases are available on the [Releases](https://github.com/LucasGGamerM/moshidon/releases) page.
+
+### How to Install from GitHub
+[Download the latest stable release from Github](https://github.com/LucasGGamerM/moshidon/releases/latest/download/moshidon.apk) and open it. You might have to accept installing APK files from your browser. Moshidon will automatically check for new updates available on GitHub and offer to download and install them within the app. You can also manually press “Check for updates” at the bottom of the settings page.
+
+### Nightly Version
+All ` moshidon-night.apk ` nightly builds can be downloaded on the [Nightly Releases](https://github.com/LucasGGamerM/moshidon-nightly/releases) page. This is an unstable version with an integrated updater for development and testing purposes. If you find any bugs with it, please file a bug report on our [Issues](https://github.com/LucasGGamerM/moshidon/issues) page.
+
+## Building & Contributing
 
 As this app is using Java 17 features, you need JDK 17 or newer to build it. Other than that, everything is pretty standard. You can either import the project into Android Studio and build it from there, or run the following command in the project directory:
 
@@ -32,4 +98,13 @@ As this app is using Java 17 features, you need JDK 17 or newer to build it. Oth
 
 This project is released under the [GPL-3 License](./LICENSE).
 
-The Mastodon name and logo are trademarks of Mastodon gGmbH. If you intend to redistribute a modified version of this app, use a unique name and icon for your app that does not mistakenly imply any official connection with or endorsement by Mastodon gGmbH.
+## Contact & Support
+
+**<a rel="me" href="https://floss.social/@moshidon">@moshidon@floss.social</a>**
+
+[Official Matrix Chatroom](https://matrix.to/#/#moshidon:floss.social)
+
+[F.A.Q](FAQ.md)
+
+[Moshidon Roadmap](https://github.com/users/LucasGGamerM/projects/1)
+

mastodon/build.gradle

@@ -10,11 +10,11 @@ android {
 
 	compileSdk 34
 	defaultConfig {
-		applicationId "org.joinmastodon.android"
+		applicationId "org.joinmastodon.android.moshinda"
 		minSdk 23
 		targetSdk 34
-		versionCode 128
-		versionName "2.9.0"
+		versionCode 107
+		versionName "2.9.1+fork.107.moshinda"
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 	}
 
@@ -27,16 +27,16 @@ android {
 		debug{
 			debuggable true
 		}
-		appcenterPrivateBeta{
-			initWith release
-			minifyEnabled false
-			shrinkResources false
-			versionNameSuffix "-priv-beta"
-		}
-		appcenterPublicBeta{
-			initWith release
-			versionNameSuffix "-beta"
-		}
+//		appcenterPrivateBeta{
+//			initWith release
+//			minifyEnabled false
+//			shrinkResources false
+//			versionNameSuffix "-priv-beta"
+//		}
+//		appcenterPublicBeta{
+//			initWith release
+//			versionNameSuffix "-beta"
+//		}
 		githubRelease{
 			initWith release
 		}
@@ -50,12 +50,12 @@ android {
 		coreLibraryDesugaringEnabled true
 	}
 	sourceSets{
-		appcenterPrivateBeta{
-			setRoot "src/appcenter"
-		}
-		appcenterPublicBeta{
-			setRoot "src/appcenter"
-		}
+//		appcenterPrivateBeta{
+//			setRoot "src/appcenter"
+//		}
+//		appcenterPublicBeta{
+//			setRoot "src/appcenter"
+//		}
 		githubRelease{
 			setRoot "src/github"
 		}
@@ -101,11 +101,12 @@ dependencies {
 	annotationProcessor 'org.parceler:parceler:1.1.12'
 	coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.3'
 
-	def appCenterSdkVersion = "5.0.4"
-	appcenterPrivateBetaImplementation "com.microsoft.appcenter:appcenter-crashes:${appCenterSdkVersion}"
-	appcenterPrivateBetaImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
-	appcenterPublicBetaImplementation "com.microsoft.appcenter:appcenter-crashes:${appCenterSdkVersion}"
-	appcenterPublicBetaImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
+	// MOSHIDON: we don't do that here
+//	def appCenterSdkVersion = "5.0.4"
+//	appcenterPrivateBetaImplementation "com.microsoft.appcenter:appcenter-crashes:${appCenterSdkVersion}"
+//	appcenterPrivateBetaImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
+//	appcenterPublicBetaImplementation "com.microsoft.appcenter:appcenter-crashes:${appCenterSdkVersion}"
+//	appcenterPublicBetaImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
 
 	androidTestImplementation 'androidx.test:core:1.5.0'
 	androidTestImplementation 'androidx.test.ext:junit:1.1.5'

mastodon/src/main/java/com/hootsuite/nachos/ChipConfiguration.java

@@ -0,0 +1,78 @@
+package com.hootsuite.nachos;
+
+import android.content.res.ColorStateList;
+
+public class ChipConfiguration {
+
+    private final int mChipHorizontalSpacing;
+    private final ColorStateList mChipBackground;
+    private final int mChipCornerRadius;
+    private final int mChipTextColor;
+    private final int mChipTextSize;
+    private final int mChipHeight;
+    private final int mChipVerticalSpacing;
+    private final int mMaxAvailableWidth;
+
+    /**
+     * Creates a new ChipConfiguration. You can pass in {@code -1} or {@code null} for any of the parameters to indicate that parameter should be
+     * ignored.
+     *
+     * @param chipHorizontalSpacing         the amount of horizontal space (in pixels) to put between consecutive chips
+     * @param chipBackground      the {@link ColorStateList} to set as the background of the chips
+     * @param chipCornerRadius    the corner radius of the chip background, in pixels
+     * @param chipTextColor       the color to set as the text color of the chips
+     * @param chipTextSize        the font size (in pixels) to use for the text of the chips
+     * @param chipHeight          the height (in pixels) of each chip
+     * @param chipVerticalSpacing the amount of vertical space (in pixels) to put between chips on consecutive lines
+     * @param maxAvailableWidth   the maximum available with for a chip (the width of a full line of text in the text view)
+     */
+    ChipConfiguration(int chipHorizontalSpacing,
+                      ColorStateList chipBackground,
+                      int chipCornerRadius,
+                      int chipTextColor,
+                      int chipTextSize,
+                      int chipHeight,
+                      int chipVerticalSpacing,
+                      int maxAvailableWidth) {
+        mChipHorizontalSpacing = chipHorizontalSpacing;
+        mChipBackground = chipBackground;
+        mChipCornerRadius = chipCornerRadius;
+        mChipTextColor = chipTextColor;
+        mChipTextSize = chipTextSize;
+        mChipHeight = chipHeight;
+        mChipVerticalSpacing = chipVerticalSpacing;
+        mMaxAvailableWidth = maxAvailableWidth;
+    }
+
+    public int getChipHorizontalSpacing() {
+        return mChipHorizontalSpacing;
+    }
+
+    public ColorStateList getChipBackground() {
+        return mChipBackground;
+    }
+
+    public int getChipCornerRadius() {
+        return mChipCornerRadius;
+    }
+
+    public int getChipTextColor() {
+        return mChipTextColor;
+    }
+
+    public int getChipTextSize() {
+        return mChipTextSize;
+    }
+
+    public int getChipHeight() {
+        return mChipHeight;
+    }
+
+    public int getChipVerticalSpacing() {
+        return mChipVerticalSpacing;
+    }
+
+    public int getMaxAvailableWidth() {
+        return mMaxAvailableWidth;
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/chip/Chip.java

@@ -0,0 +1,29 @@
+package com.hootsuite.nachos.chip;
+
+import androidx.annotation.Nullable;
+
+public interface Chip {
+
+    /**
+     * @return the text represented by this Chip
+     */
+    CharSequence getText();
+
+    /**
+     * @return the data associated with this Chip or null if no data is associated with it
+     */
+    @Nullable
+    Object getData();
+
+    /**
+     * @return the width of the Chip or -1 if the Chip hasn't been given the chance to calculate its width
+     */
+    int getWidth();
+
+    /**
+     * Sets the UI state.
+     *
+     * @param stateSet one of the state constants in {@link android.view.View}
+     */
+    void setState(int[] stateSet);
+}

mastodon/src/main/java/com/hootsuite/nachos/chip/ChipCreator.java

@@ -0,0 +1,44 @@
+package com.hootsuite.nachos.chip;
+
+import android.content.Context;
+
+import com.hootsuite.nachos.ChipConfiguration;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * Interface to allow the creation and configuration of chips
+ *
+ * @param <C> The type of {@link Chip} that the implementation will create/configure
+ */
+public interface ChipCreator<C extends Chip> {
+
+    /**
+     * Creates a chip from the given context and text. Use this method when creating a brand new chip from a piece of text.
+     *
+     * @param context the {@link Context} to use to initialize the chip
+     * @param text    the text the Chip should represent
+     * @param data    the data to associate with the Chip, or null to associate no data
+     * @return the created chip
+     */
+    C createChip(@NonNull Context context, @NonNull CharSequence text, @Nullable Object data);
+
+    /**
+     * Creates a chip from the given context and existing chip. Use this method when recreating a chip from an existing one.
+     *
+     * @param context      the {@link Context} to use to initialize the chip
+     * @param existingChip the chip that the created chip should be based on
+     * @return the created chip
+     */
+    C createChip(@NonNull Context context, @NonNull C existingChip);
+
+    /**
+     * Applies the given {@link ChipConfiguration} to the given {@link Chip}. Use this method to customize the appearance/behavior of a chip before
+     * adding it to the text.
+     *
+     * @param chip              the chip to configure
+     * @param chipConfiguration the configuration to apply to the chip
+     */
+    void configureChip(@NonNull C chip, @NonNull ChipConfiguration chipConfiguration);
+}

mastodon/src/main/java/com/hootsuite/nachos/chip/ChipInfo.java

@@ -0,0 +1,20 @@
+package com.hootsuite.nachos.chip;
+
+public class ChipInfo {
+
+    private final CharSequence mText;
+    private final Object mData;
+
+    public ChipInfo(CharSequence text, Object data) {
+        this.mText = text;
+        this.mData = data;
+    }
+
+    public CharSequence getText() {
+        return mText;
+    }
+
+    public Object getData() {
+        return mData;
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/chip/ChipSpan.java

@@ -0,0 +1,510 @@
+package com.hootsuite.nachos.chip;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.text.style.ImageSpan;
+
+import org.joinmastodon.android.R;
+
+import androidx.annotation.Dimension;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * A Span that displays text and an optional icon inside of a material design chip. The chip's dimensions, colors etc. can be extensively customized
+ * through the various setter methods available in this class.
+ *     The basic structure of the chip is the following:
+ * For chips with the icon on right:
+ * <pre>
+ *
+ *                                  (chip vertical spacing / 2)
+ *                  ----------------------------------------------------------
+ *                |                                                            |
+ * (left margin)  |  (padding edge)   text   (padding between image)   icon    |   (right margin)
+ *                |                                                            |
+ *                  ----------------------------------------------------------
+ *                                  (chip vertical spacing / 2)
+ *
+ *      </pre>
+ * For chips with the icon on the left (see {@link #setShowIconOnLeft(boolean)}):
+ * <pre>
+ *
+ *                                  (chip vertical spacing / 2)
+ *                  ----------------------------------------------------------
+ *                |                                                            |
+ * (left margin)  |   icon  (padding between image)   text   (padding edge)    |   (right margin)
+ *                |                                                            |
+ *                  ----------------------------------------------------------
+ *                                  (chip vertical spacing / 2)
+ *     </pre>
+ */
+public class ChipSpan extends ImageSpan implements Chip {
+
+    private static final float SCALE_PERCENT_OF_CHIP_HEIGHT = 0.70f;
+    private static final boolean ICON_ON_LEFT_DEFAULT = true;
+
+    private int[] mStateSet = new int[]{};
+
+    private String mEllipsis;
+
+    private ColorStateList mDefaultBackgroundColor;
+    private ColorStateList mBackgroundColor;
+    private int mTextColor;
+    private int mCornerRadius = -1;
+    private int mIconBackgroundColor;
+
+    private int mTextSize = -1;
+    private int mPaddingEdgePx;
+    private int mPaddingBetweenImagePx;
+    private int mLeftMarginPx;
+    private int mRightMarginPx;
+    private int mMaxAvailableWidth = -1;
+
+    private CharSequence mText;
+    private String mTextToDraw;
+
+    private Drawable mIcon;
+    private boolean mShowIconOnLeft = ICON_ON_LEFT_DEFAULT;
+
+    private int mChipVerticalSpacing = 0;
+    private int mChipHeight = -1;
+    private int mChipWidth = -1;
+    private int mIconWidth;
+
+    private int mCachedSize = -1;
+
+    private Object mData;
+
+    /**
+     * Constructs a new ChipSpan.
+     *
+     * @param context a {@link Context} that will be used to retrieve default configurations from resource files
+     * @param text    the text for the ChipSpan to display
+     * @param icon    an optional icon (can be {@code null}) for the ChipSpan to display
+     */
+    public ChipSpan(@NonNull Context context, @NonNull CharSequence text, @Nullable Drawable icon, Object data) {
+        super(icon);
+        mIcon = icon;
+        mText = text;
+        mTextToDraw = mText.toString();
+
+        mEllipsis = context.getString(R.string.chip_ellipsis);
+
+        mDefaultBackgroundColor = context.getColorStateList(R.color.chip_material_background);
+        mBackgroundColor = mDefaultBackgroundColor;
+
+        mTextColor = context.getColor(R.color.chip_default_text_color);
+        mIconBackgroundColor = context.getColor(R.color.chip_default_icon_background_color);
+
+        Resources resources = context.getResources();
+        mPaddingEdgePx = resources.getDimensionPixelSize(R.dimen.chip_default_padding_edge);
+        mPaddingBetweenImagePx = resources.getDimensionPixelSize(R.dimen.chip_default_padding_between_image);
+        mLeftMarginPx = resources.getDimensionPixelSize(R.dimen.chip_default_left_margin);
+        mRightMarginPx = resources.getDimensionPixelSize(R.dimen.chip_default_right_margin);
+
+        mData = data;
+    }
+
+    /**
+     * Copy constructor to recreate a ChipSpan from an existing one
+     *
+     * @param context  a {@link Context} that will be used to retrieve default configurations from resource files
+     * @param chipSpan the ChipSpan to copy
+     */
+    public ChipSpan(@NonNull Context context, @NonNull ChipSpan chipSpan) {
+        this(context, chipSpan.getText(), chipSpan.getDrawable(), chipSpan.getData());
+
+        mDefaultBackgroundColor = chipSpan.mDefaultBackgroundColor;
+        mTextColor = chipSpan.mTextColor;
+        mIconBackgroundColor = chipSpan.mIconBackgroundColor;
+        mCornerRadius = chipSpan.mCornerRadius;
+
+        mTextSize = chipSpan.mTextSize;
+        mPaddingEdgePx = chipSpan.mPaddingEdgePx;
+        mPaddingBetweenImagePx = chipSpan.mPaddingBetweenImagePx;
+        mLeftMarginPx = chipSpan.mLeftMarginPx;
+        mRightMarginPx = chipSpan.mRightMarginPx;
+        mMaxAvailableWidth = chipSpan.mMaxAvailableWidth;
+
+        mShowIconOnLeft = chipSpan.mShowIconOnLeft;
+
+        mChipVerticalSpacing = chipSpan.mChipVerticalSpacing;
+        mChipHeight = chipSpan.mChipHeight;
+
+        mStateSet = chipSpan.mStateSet;
+    }
+
+    @Override
+    public Object getData() {
+        return mData;
+    }
+
+    /**
+     * Sets the height of the chip. This height should not include any extra spacing (for extra vertical spacing call {@link #setChipVerticalSpacing(int)}).
+     * The background of the chip will fill the full height provided here. If this method is never called, the chip will have the height of one full line
+     * of text by default. If {@code -1} is passed here, the chip will revert to this default behavior.
+     *
+     * @param chipHeight the height to set in pixels
+     */
+    public void setChipHeight(int chipHeight) {
+        mChipHeight = chipHeight;
+    }
+
+    /**
+     * Sets the vertical spacing to include in between chips. Half of the value set here will be placed as empty space above the chip and half the value
+     * will be placed as empty space below the chip. Therefore chips on consecutive lines will have the full value as vertical space in between them.
+     * This spacing is achieved by adjusting the font metrics used by the text view containing these chips; however it does not come into effect until
+     * at least one chip is created. Note that vertical spacing is dependent on having a fixed chip height (set in {@link #setChipHeight(int)}). If a
+     * height is not specified in that method, the value set here will be ignored.
+     *
+     * @param chipVerticalSpacing the vertical spacing to set in pixels
+     */
+    public void setChipVerticalSpacing(int chipVerticalSpacing) {
+        mChipVerticalSpacing = chipVerticalSpacing;
+    }
+
+    /**
+     * Sets the font size for the chip's text. If this method is never called, the chip text will have the same font size as the text in the TextView
+     * containing this chip by default. If {@code -1} is passed here, the chip will revert to this default behavior.
+     *
+     * @param size the font size to set in pixels
+     */
+    public void setTextSize(int size) {
+        mTextSize = size;
+        invalidateCachedSize();
+    }
+
+    /**
+     * Sets the color for the chip's text.
+     *
+     * @param color the color to set (as a hexadecimal number in the form 0xAARRGGBB)
+     */
+    public void setTextColor(int color) {
+        mTextColor = color;
+    }
+
+    /**
+     * Sets where the icon (if an icon was provided in the constructor) will appear.
+     *
+     * @param showIconOnLeft if true, the icon will appear on the left, otherwise the icon will appear on the right
+     */
+    public void setShowIconOnLeft(boolean showIconOnLeft) {
+        this.mShowIconOnLeft = showIconOnLeft;
+        invalidateCachedSize();
+    }
+
+    /**
+     * Sets the left margin. This margin will appear as empty space (it will not share the chip's background color) to the left of the chip.
+     *
+     * @param leftMarginPx the left margin to set in pixels
+     */
+    public void setLeftMargin(int leftMarginPx) {
+        mLeftMarginPx = leftMarginPx;
+        invalidateCachedSize();
+    }
+
+    /**
+     * Sets the right margin. This margin will appear as empty space (it will not share the chip's background color) to the right of the chip.
+     *
+     * @param rightMarginPx the right margin to set in pixels
+     */
+    public void setRightMargin(int rightMarginPx) {
+        this.mRightMarginPx = rightMarginPx;
+        invalidateCachedSize();
+    }
+
+    /**
+     * Sets the background color. To configure which color in the {@link ColorStateList} is shown you can call {@link #setState(int[])}.
+     * Passing {@code null} here will cause the chip to revert to it's default background.
+     *
+     * @param backgroundColor a {@link ColorStateList} containing backgrounds for different states.
+     * @see #setState(int[])
+     */
+    public void setBackgroundColor(@Nullable ColorStateList backgroundColor) {
+        mBackgroundColor = backgroundColor != null ? backgroundColor : mDefaultBackgroundColor;
+    }
+
+    /**
+     * Sets the chip background corner radius.
+     *
+     * @param cornerRadius The corner radius value, in pixels.
+     */
+    public void setCornerRadius(@Dimension int cornerRadius) {
+        mCornerRadius = cornerRadius;
+    }
+
+    /**
+     * Sets the icon background color. This is the color of the circle that gets drawn behind the icon passed to the
+     * {@link #ChipSpan(Context, CharSequence, Drawable, Object)}  constructor}
+     *
+     * @param iconBackgroundColor the icon background color to set (as a hexadecimal number in the form 0xAARRGGBB)
+     */
+    public void setIconBackgroundColor(int iconBackgroundColor) {
+        mIconBackgroundColor = iconBackgroundColor;
+    }
+
+    public void setMaxAvailableWidth(int maxAvailableWidth) {
+        mMaxAvailableWidth = maxAvailableWidth;
+        invalidateCachedSize();
+    }
+
+    /**
+     * Sets the UI state. This state will be reflected in the background color drawn for the chip.
+     *
+     * @param stateSet one of the state constants in {@link android.view.View}
+     * @see #setBackgroundColor(ColorStateList)
+     */
+    @Override
+    public void setState(int[] stateSet) {
+        this.mStateSet = stateSet != null ? stateSet : new int[]{};
+    }
+
+    @Override
+    public CharSequence getText() {
+        return mText;
+    }
+
+    @Override
+    public int getWidth() {
+        // If we haven't actually calculated a chip width yet just return -1, otherwise return the chip width + margins
+        return mChipWidth != -1 ? (mLeftMarginPx + mChipWidth + mRightMarginPx) : -1;
+    }
+
+    @Override
+    public int getSize(Paint paint, CharSequence text, int start, int end, Paint.FontMetricsInt fm) {
+        boolean usingFontMetrics = (fm != null);
+
+        // Adjust the font metrics regardless of whether or not there is a cached size so that the text view can maintain its height
+        if (usingFontMetrics) {
+            adjustFontMetrics(paint, fm);
+        }
+
+        if (mCachedSize == -1 && usingFontMetrics) {
+            mIconWidth = (mIcon != null) ? calculateChipHeight(fm.top, fm.bottom) : 0;
+
+            int actualWidth = calculateActualWidth(paint);
+            mCachedSize = actualWidth;
+
+            if (mMaxAvailableWidth != -1) {
+                int maxAvailableWidthMinusMargins = mMaxAvailableWidth - mLeftMarginPx - mRightMarginPx;
+                if (actualWidth > maxAvailableWidthMinusMargins) {
+                    mTextToDraw = mText + mEllipsis;
+
+                    while ((calculateActualWidth(paint) > maxAvailableWidthMinusMargins) && mTextToDraw.length() > 0) {
+                        int lastCharacterIndex = mTextToDraw.length() - mEllipsis.length() - 1;
+                        if (lastCharacterIndex < 0) {
+                            break;
+                        }
+                        mTextToDraw = mTextToDraw.substring(0, lastCharacterIndex) + mEllipsis;
+                    }
+
+                    // Avoid a negative width
+                    mChipWidth = Math.max(0, maxAvailableWidthMinusMargins);
+                    mCachedSize = mMaxAvailableWidth;
+                }
+            }
+        }
+
+        return mCachedSize;
+    }
+
+    private int calculateActualWidth(Paint paint) {
+        // Only change the text size if a text size was set
+        if (mTextSize != -1) {
+            paint.setTextSize(mTextSize);
+        }
+
+        int totalPadding = mPaddingEdgePx;
+
+        // Find text width
+        Rect bounds = new Rect();
+        paint.getTextBounds(mTextToDraw, 0, mTextToDraw.length(), bounds);
+        int textWidth = bounds.width();
+
+        if (mIcon != null) {
+            totalPadding += mPaddingBetweenImagePx;
+        } else {
+            totalPadding += mPaddingEdgePx;
+        }
+
+        mChipWidth = totalPadding + textWidth + mIconWidth;
+        return getWidth();
+    }
+
+    public void invalidateCachedSize() {
+        mCachedSize = -1;
+    }
+
+    /**
+     * Adjusts the provided font metrics to make it seem like the font takes up {@code mChipHeight + mChipVerticalSpacing} pixels in height.
+     * This effectively ensures that the TextView will have a height equal to {@code mChipHeight + mChipVerticalSpacing} + whatever padding it has set.
+     * In {@link #draw(Canvas, CharSequence, int, int, float, int, int, int, Paint)} the chip itself is drawn to that it is vertically centered with
+     * {@code mChipVerticalSpacing / 2} pixels of space above and below it
+     *
+     * @param paint the paint whose font metrics should be adjusted
+     * @param fm    the font metrics object to populate through {@link Paint#getFontMetricsInt(Paint.FontMetricsInt)}
+     */
+    private void adjustFontMetrics(Paint paint, Paint.FontMetricsInt fm) {
+        // Only actually adjust font metrics if we have a chip height set
+        if (mChipHeight != -1) {
+            paint.getFontMetricsInt(fm);
+            int textHeight = fm.descent - fm.ascent;
+            // Break up the vertical spacing in half because half will go above the chip, half will go below the chip
+            int halfSpacing = mChipVerticalSpacing / 2;
+
+            // Given that the text is centered vertically within the chip, the amount of space above or below the text (inbetween the text and chip)
+            // is half their difference in height:
+            int spaceBetweenChipAndText = (mChipHeight - textHeight) / 2;
+
+            int textTop = fm.top;
+            int chipTop = fm.top - spaceBetweenChipAndText;
+
+            int textBottom = fm.bottom;
+            int chipBottom = fm.bottom + spaceBetweenChipAndText;
+
+            // The text may have been taller to begin with so we take the most negative coordinate (highest up) to be the top of the content
+            int topOfContent = Math.min(textTop, chipTop);
+            // Same as above but we want the largest positive coordinate (lowest down) to be the bottom of the content
+            int bottomOfContent = Math.max(textBottom, chipBottom);
+
+            // Shift the top up by halfSpacing and the bottom down by halfSpacing
+            int topOfContentWithSpacing = topOfContent - halfSpacing;
+            int bottomOfContentWithSpacing = bottomOfContent + halfSpacing;
+
+            // Change the font metrics so that the TextView thinks the font takes up the vertical space of a chip + spacing
+            fm.ascent = topOfContentWithSpacing;
+            fm.descent = bottomOfContentWithSpacing;
+            fm.top = topOfContentWithSpacing;
+            fm.bottom = bottomOfContentWithSpacing;
+        }
+    }
+
+    private int calculateChipHeight(int top, int bottom) {
+        // If a chip height was set we can return that, otherwise calculate it from top and bottom
+        return mChipHeight != -1 ? mChipHeight : bottom - top;
+    }
+
+    @Override
+    public void draw(Canvas canvas, CharSequence text, int start, int end, float x, int top, int y, int bottom, Paint paint) {
+        // Shift everything mLeftMarginPx to the left to create an empty space on the left (creating the margin)
+        x += mLeftMarginPx;
+        if (mChipHeight != -1) {
+            // If we set a chip height, adjust to vertically center chip in the line
+            // Adding (bottom - top) / 2 shifts the chip down so the top of it will be centered vertically
+            // Subtracting (mChipHeight / 2) shifts the chip back up so that the center of it will be centered vertically (as desired)
+            top += ((bottom - top) / 2) - (mChipHeight / 2);
+            bottom = top + mChipHeight;
+        }
+
+        // Perform actual drawing
+        drawBackground(canvas, x, top, bottom, paint);
+        drawText(canvas, x, top, bottom, paint, mTextToDraw);
+        if (mIcon != null) {
+            drawIcon(canvas, x, top, bottom, paint);
+        }
+    }
+
+    private void drawBackground(Canvas canvas, float x, int top, int bottom, Paint paint) {
+        int backgroundColor = mBackgroundColor.getColorForState(mStateSet, mBackgroundColor.getDefaultColor());
+        paint.setColor(backgroundColor);
+        int height = calculateChipHeight(top, bottom);
+        RectF rect = new RectF(x, top, x + mChipWidth, bottom);
+        int cornerRadius = (mCornerRadius != -1) ? mCornerRadius : height / 2;
+        canvas.drawRoundRect(rect, cornerRadius, cornerRadius, paint);
+        paint.setColor(mTextColor);
+    }
+
+    private void drawText(Canvas canvas, float x, int top, int bottom, Paint paint, CharSequence text) {
+        if (mTextSize != -1) {
+            paint.setTextSize(mTextSize);
+        }
+        int height = calculateChipHeight(top, bottom);
+        Paint.FontMetrics fm = paint.getFontMetrics();
+
+        // The top value provided here is the y coordinate for the very top of the chip
+        // The y coordinate we are calculating is where the baseline of the text will be drawn
+        // Our objective is to have the midpoint between the top and baseline of the text be in line with the vertical center of the chip
+        // First we add height / 2 which will put the baseline at the vertical center of the chip
+        // Then we add half the height of the text which will lower baseline so that the midpoint is at the vertical center of the chip as desired
+        float adjustedY = top + ((height / 2) + ((-fm.top - fm.bottom) / 2));
+
+        // The x coordinate provided here is the left-most edge of the chip
+        // If there is no icon or the icon is on the right, then the text will start at the left-most edge, but indented with the edge padding, so we
+        // add mPaddingEdgePx
+        // If there is an icon and it's on the left, the text will start at the left-most edge, but indented by the combined width of the icon and
+        // the padding between the icon and text, so we add (mIconWidth + mPaddingBetweenImagePx)
+        float adjustedX = x + ((mIcon == null || !mShowIconOnLeft) ? mPaddingEdgePx : (mIconWidth + mPaddingBetweenImagePx));
+
+        canvas.drawText(text, 0, text.length(), adjustedX, adjustedY, paint);
+    }
+
+    private void drawIcon(Canvas canvas, float x, int top, int bottom, Paint paint) {
+        drawIconBackground(canvas, x, top, bottom, paint);
+        drawIconBitmap(canvas, x, top, bottom, paint);
+    }
+
+    private void drawIconBackground(Canvas canvas, float x, int top, int bottom, Paint paint) {
+        int height = calculateChipHeight(top, bottom);
+
+        paint.setColor(mIconBackgroundColor);
+
+        // Since it's a circle the diameter is equal to the height, so the radius == diameter / 2 == height / 2
+        int radius = height / 2;
+        // The coordinates that get passed to drawCircle are for the center of the circle
+        // x is the left edge of the chip, (x + mChipWidth) is the right edge of the chip
+        // So the center of the circle is one radius distance from either the left or right edge (depending on which side the icon is being drawn on)
+        float circleX = mShowIconOnLeft ? (x + radius) : (x + mChipWidth - radius);
+        // The y coordinate is always just one radius distance from the top
+        canvas.drawCircle(circleX, top + radius, radius, paint);
+
+        paint.setColor(mTextColor);
+    }
+
+    private void drawIconBitmap(Canvas canvas, float x, int top, int bottom, Paint paint) {
+        int height = calculateChipHeight(top, bottom);
+
+        // Create a scaled down version of the bitmap to fit within the circle (whose diameter == height)
+        Bitmap iconBitmap = Bitmap.createBitmap(mIcon.getIntrinsicWidth(), mIcon.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        Bitmap scaledIconBitMap = scaleDown(iconBitmap, (float) height * SCALE_PERCENT_OF_CHIP_HEIGHT, true);
+        iconBitmap.recycle();
+        Canvas bitmapCanvas = new Canvas(scaledIconBitMap);
+        mIcon.setBounds(0, 0, bitmapCanvas.getWidth(), bitmapCanvas.getHeight());
+        mIcon.draw(bitmapCanvas);
+
+        // We are drawing a square icon inside of a circle
+        // The coordinates we pass to canvas.drawBitmap have to be for the top-left corner of the bitmap
+        // The bitmap should be inset by half of (circle width - bitmap width)
+        // Since it's a circle, the circle's width is equal to it's height which is equal to the chip height
+        float xInsetWithinCircle = (height - bitmapCanvas.getWidth()) / 2;
+
+        // The icon x coordinate is going to be insetWithinCircle pixels away from the left edge of the circle
+        // If the icon is on the left, the left edge of the circle is just x
+        // If the icon is on the right, the left edge of the circle is x + mChipWidth - height
+        float iconX = mShowIconOnLeft ? (x + xInsetWithinCircle) : (x + mChipWidth - height + xInsetWithinCircle);
+
+        // The y coordinate works the same way (only it's always from the top edge)
+        float yInsetWithinCircle = (height - bitmapCanvas.getHeight()) / 2;
+        float iconY = top + yInsetWithinCircle;
+
+        canvas.drawBitmap(scaledIconBitMap, iconX, iconY, paint);
+    }
+
+    private Bitmap scaleDown(Bitmap realImage, float maxImageSize, boolean filter) {
+        float ratio = Math.min(maxImageSize / realImage.getWidth(), maxImageSize / realImage.getHeight());
+        int width = Math.round(ratio * realImage.getWidth());
+        int height = Math.round(ratio * realImage.getHeight());
+        return Bitmap.createScaledBitmap(realImage, width, height, filter);
+    }
+
+    @Override
+    public String toString() {
+        return mText.toString();
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/chip/ChipSpanChipCreator.java

@@ -0,0 +1,60 @@
+package com.hootsuite.nachos.chip;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.Color;
+
+import com.hootsuite.nachos.ChipConfiguration;
+
+import androidx.annotation.NonNull;
+
+public class ChipSpanChipCreator implements ChipCreator<ChipSpan> {
+
+    @Override
+    public ChipSpan createChip(@NonNull Context context, @NonNull CharSequence text, Object data) {
+        return new ChipSpan(context, text, null, data);
+    }
+
+    @Override
+    public ChipSpan createChip(@NonNull Context context, @NonNull ChipSpan existingChip) {
+        return new ChipSpan(context, existingChip);
+    }
+
+    @Override
+    public void configureChip(@NonNull ChipSpan chip, @NonNull ChipConfiguration chipConfiguration) {
+        int chipHorizontalSpacing = chipConfiguration.getChipHorizontalSpacing();
+        ColorStateList chipBackground = chipConfiguration.getChipBackground();
+        int chipCornerRadius = chipConfiguration.getChipCornerRadius();
+        int chipTextColor = chipConfiguration.getChipTextColor();
+        int chipTextSize = chipConfiguration.getChipTextSize();
+        int chipHeight = chipConfiguration.getChipHeight();
+        int chipVerticalSpacing = chipConfiguration.getChipVerticalSpacing();
+        int maxAvailableWidth = chipConfiguration.getMaxAvailableWidth();
+
+        if (chipHorizontalSpacing != -1) {
+            chip.setLeftMargin(chipHorizontalSpacing / 2);
+            chip.setRightMargin(chipHorizontalSpacing / 2);
+        }
+        if (chipBackground != null) {
+            chip.setBackgroundColor(chipBackground);
+        }
+        if (chipCornerRadius != -1) {
+            chip.setCornerRadius(chipCornerRadius);
+        }
+        if (chipTextColor != Color.TRANSPARENT) {
+            chip.setTextColor(chipTextColor);
+        }
+        if (chipTextSize != -1) {
+            chip.setTextSize(chipTextSize);
+        }
+        if (chipHeight != -1) {
+            chip.setChipHeight(chipHeight);
+        }
+        if (chipVerticalSpacing != -1) {
+            chip.setChipVerticalSpacing(chipVerticalSpacing);
+        }
+        if (maxAvailableWidth != -1) {
+            chip.setMaxAvailableWidth(maxAvailableWidth);
+        }
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/terminator/ChipTerminatorHandler.java

@@ -0,0 +1,95 @@
+package com.hootsuite.nachos.terminator;
+
+import android.text.Editable;
+
+import com.hootsuite.nachos.tokenizer.ChipTokenizer;
+
+import java.util.Map;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * This interface is used to handle the management of characters that should trigger the creation of chips in a text view.
+ *
+ * @see ChipTokenizer
+ */
+public interface ChipTerminatorHandler {
+
+    /**
+     * When a chip terminator character is encountered in newly inserted text, all tokens in the whole text view will be chipified
+     */
+    int BEHAVIOR_CHIPIFY_ALL = 0;
+
+    /**
+     * When a chip terminator character is encountered in newly inserted text, only the current token (that in which the chip terminator character
+     * was found) will be chipified. This token may extend beyond where the chip terminator character was located.
+     */
+    int BEHAVIOR_CHIPIFY_CURRENT_TOKEN = 1;
+
+    /**
+     * When a chip terminator character is encountered in newly inserted text, only the text from the previous chip up until the chip terminator
+     * character will be chipified. This may not be an entire token.
+     */
+    int BEHAVIOR_CHIPIFY_TO_TERMINATOR = 2;
+
+    /**
+     * Constant for use with {@link #setPasteBehavior(int)}. Use this if a paste should behave the same as a standard text input (the chip temrinators
+     * will all behave according to their pre-determined behavior set through {@link #addChipTerminator(char, int)} or {@link #setChipTerminators(Map)}).
+     */
+    int PASTE_BEHAVIOR_USE_DEFAULT = -1;
+
+    /**
+     * Sets all the characters that will be marked as chip terminators. This will replace any previously set chip terminators.
+     *
+     * @param chipTerminators a map of characters to be marked as chip terminators to behaviors that describe how to respond to the characters, or null
+     *                        to remove all chip terminators
+     */
+    void setChipTerminators(@Nullable Map<Character, Integer> chipTerminators);
+
+    /**
+     * Adds a character as a chip terminator. When the provided character is encountered in entered text, the nearby text will be chipified according
+     * to the behavior provided here.
+     *     {@code behavior} Must be one of:
+     *     <ul>
+     *         <li>{@link #BEHAVIOR_CHIPIFY_ALL}</li>
+     *         <li>{@link #BEHAVIOR_CHIPIFY_CURRENT_TOKEN}</li>
+     *         <li>{@link #BEHAVIOR_CHIPIFY_TO_TERMINATOR}</li>
+     *     </ul>
+     *
+     * @param character the character to mark as a chip terminator
+     * @param behavior  the behavior describing how to respond to the chip terminator
+     */
+    void addChipTerminator(char character, int behavior);
+
+    /**
+     * Customizes the way paste events are handled.
+     *     If one of:
+     *     <ul>
+     *         <li>{@link #BEHAVIOR_CHIPIFY_ALL}</li>
+     *         <li>{@link #BEHAVIOR_CHIPIFY_CURRENT_TOKEN}</li>
+     *         <li>{@link #BEHAVIOR_CHIPIFY_TO_TERMINATOR}</li>
+     *     </ul>
+     *     is passed, all chip terminators will be handled with that behavior when a paste event occurs.
+     *     If {@link #PASTE_BEHAVIOR_USE_DEFAULT} is passed, whatever behavior is configured for a particular chip terminator
+     *     (through {@link #setChipTerminators(Map)} or {@link #addChipTerminator(char, int)} will be used for that chip terminator
+     *
+     * @param pasteBehavior the behavior to use on a paste event
+     */
+    void setPasteBehavior(int pasteBehavior);
+
+    /**
+     * Parses the provided text looking for characters marked as chip terminators through {@link #addChipTerminator(char, int)} and {@link #setChipTerminators(Map)}.
+     *     The provided {@link Editable} will be modified if chip terminators are encountered.
+     *
+     * @param tokenizer    the {@link ChipTokenizer} to use to identify and chipify tokens in the text
+     * @param text         the text in which to search for chip terminators tokens to be chipped
+     * @param start        the index at which to begin looking for chip terminators (inclusive)
+     * @param end          the index at which to end looking for chip terminators (exclusive)
+     * @param isPasteEvent true if this handling is for a paste event in which case the behavior set in {@link #setPasteBehavior(int)} will be used,
+     *                     otherwise false
+     * @return an non-negative integer indicating the index where the cursor (selection) should be placed once the handling is complete,
+     *         or a negative integer indicating that the cursor should not be moved.
+     */
+    int findAndHandleChipTerminators(@NonNull ChipTokenizer tokenizer, @NonNull Editable text, int start, int end, boolean isPasteEvent);
+}

mastodon/src/main/java/com/hootsuite/nachos/terminator/DefaultChipTerminatorHandler.java

@@ -0,0 +1,115 @@
+package com.hootsuite.nachos.terminator;
+
+import android.text.Editable;
+
+import com.hootsuite.nachos.tokenizer.ChipTokenizer;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class DefaultChipTerminatorHandler implements ChipTerminatorHandler {
+
+    @Nullable
+    private Map<Character, Integer> mChipTerminators;
+    private int mPasteBehavior = BEHAVIOR_CHIPIFY_TO_TERMINATOR;
+
+    @Override
+    public void setChipTerminators(@Nullable Map<Character, Integer> chipTerminators) {
+        mChipTerminators = chipTerminators;
+    }
+
+    @Override
+    public void addChipTerminator(char character, int behavior) {
+        if (mChipTerminators == null) {
+            mChipTerminators = new HashMap<>();
+        }
+
+        mChipTerminators.put(character, behavior);
+    }
+
+    @Override
+    public void setPasteBehavior(int pasteBehavior) {
+        mPasteBehavior = pasteBehavior;
+    }
+
+    @Override
+    public int findAndHandleChipTerminators(@NonNull ChipTokenizer tokenizer, @NonNull Editable text, int start, int end, boolean isPasteEvent) {
+        // If we don't have a tokenizer or any chip terminators, there's nothing to look for
+        if (mChipTerminators == null) {
+            return -1;
+        }
+
+        TextIterator textIterator = new TextIterator(text, start, end);
+        int selectionIndex = -1;
+
+        characterLoop:
+        while (textIterator.hasNextCharacter()) {
+            char theChar = textIterator.nextCharacter();
+            if (isChipTerminator(theChar)) {
+                int behavior = (isPasteEvent && mPasteBehavior != PASTE_BEHAVIOR_USE_DEFAULT) ? mPasteBehavior : mChipTerminators.get(theChar);
+                int newSelection = -1;
+                switch (behavior) {
+                    case BEHAVIOR_CHIPIFY_ALL:
+                        selectionIndex = handleChipifyAll(textIterator, tokenizer);
+                        break characterLoop;
+                    case BEHAVIOR_CHIPIFY_CURRENT_TOKEN:
+                        newSelection = handleChipifyCurrentToken(textIterator, tokenizer);
+                        break;
+                    case BEHAVIOR_CHIPIFY_TO_TERMINATOR:
+                        newSelection = handleChipifyToTerminator(textIterator, tokenizer);
+                        break;
+                }
+
+                if (newSelection != -1) {
+                    selectionIndex = newSelection;
+                }
+            }
+        }
+
+        return selectionIndex;
+    }
+
+    private int handleChipifyAll(TextIterator textIterator, ChipTokenizer tokenizer) {
+        textIterator.deleteCharacter(true);
+        tokenizer.terminateAllTokens(textIterator.getText());
+        return textIterator.totalLength();
+    }
+
+    private int handleChipifyCurrentToken(TextIterator textIterator, ChipTokenizer tokenizer) {
+        textIterator.deleteCharacter(true);
+        Editable text = textIterator.getText();
+        int index = textIterator.getIndex();
+        int tokenStart = tokenizer.findTokenStart(text, index);
+        int tokenEnd = tokenizer.findTokenEnd(text, index);
+        if (tokenStart < tokenEnd) {
+            CharSequence chippedText = tokenizer.terminateToken(text.subSequence(tokenStart, tokenEnd), null);
+            textIterator.replace(tokenStart, tokenEnd, chippedText);
+            return tokenStart + chippedText.length();
+        }
+        return -1;
+    }
+
+    private int handleChipifyToTerminator(TextIterator textIterator, ChipTokenizer tokenizer) {
+        Editable text = textIterator.getText();
+        int index = textIterator.getIndex();
+        if (index > 0) {
+            int tokenStart = tokenizer.findTokenStart(text, index);
+            if (tokenStart < index) {
+                CharSequence chippedText = tokenizer.terminateToken(text.subSequence(tokenStart, index), null);
+                textIterator.replace(tokenStart, index + 1, chippedText);
+            } else {
+                textIterator.deleteCharacter(false);
+            }
+        } else {
+            textIterator.deleteCharacter(false);
+        }
+        return -1;
+    }
+
+    private boolean isChipTerminator(char character) {
+        return mChipTerminators != null && mChipTerminators.keySet().contains(character);
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/terminator/TextIterator.java

@@ -0,0 +1,63 @@
+package com.hootsuite.nachos.terminator;
+
+import android.text.Editable;
+
+public class TextIterator {
+
+    private Editable mText;
+    private int mStart;
+    private int mEnd;
+
+    private int mIndex;
+
+    public TextIterator(Editable text, int start, int end) {
+        mText = text;
+        mStart = start;
+        mEnd = end;
+
+        mIndex = mStart - 1; // Subtract 1 so that the first call to nextCharacter() will return the first character
+    }
+
+    public int totalLength() {
+        return mText.length();
+    }
+
+    public int windowLength() {
+        return mEnd - mStart;
+    }
+
+    public Editable getText() {
+        return mText;
+    }
+
+    public int getIndex() {
+        return mIndex;
+    }
+
+    public boolean hasNextCharacter() {
+        return (mIndex + 1) < mEnd;
+    }
+
+    public char nextCharacter() {
+        mIndex++;
+        return mText.charAt(mIndex);
+    }
+
+    public void deleteCharacter(boolean maintainIndex) {
+        mText.replace(mIndex, mIndex + 1, "");
+        if (!maintainIndex) {
+            mIndex--;
+        }
+        mEnd--;
+    }
+
+    public void replace(int replaceStart, int replaceEnd, CharSequence chippedText) {
+        mText.replace(replaceStart, replaceEnd, chippedText);
+
+        // Update indexes
+        int newLength = chippedText.length();
+        int oldLength = replaceEnd - replaceStart;
+        mIndex = replaceStart + newLength - 1;
+        mEnd += newLength - oldLength;
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/tokenizer/BaseChipTokenizer.java

@@ -0,0 +1,89 @@
+package com.hootsuite.nachos.tokenizer;
+
+import android.text.Editable;
+import android.text.Spanned;
+import android.util.Pair;
+
+import com.hootsuite.nachos.ChipConfiguration;
+import com.hootsuite.nachos.chip.Chip;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * Base implementation of the {@link ChipTokenizer} interface that performs no actions and returns default values.
+ * This class allows for the easy creation of a ChipTokenizer that only implements some of the methods of the interface.
+ */
+public abstract class BaseChipTokenizer implements ChipTokenizer {
+
+    @Override
+    public void applyConfiguration(Editable text, ChipConfiguration chipConfiguration) {
+        // Do nothing
+    }
+
+    @Override
+    public int findTokenStart(CharSequence charSequence, int i) {
+        // Do nothing
+        return 0;
+    }
+
+    @Override
+    public int findTokenEnd(CharSequence charSequence, int i) {
+        // Do nothing
+        return 0;
+    }
+
+    @NonNull
+    @Override
+    public List<Pair<Integer, Integer>> findAllTokens(CharSequence text) {
+        // Do nothing
+        return new ArrayList<>();
+    }
+
+    @Override
+    public CharSequence terminateToken(CharSequence charSequence, @Nullable Object data) {
+        // Do nothing
+        return charSequence;
+    }
+
+    @Override
+    public void terminateAllTokens(Editable text) {
+        // Do nothing
+    }
+
+    @Override
+    public int findChipStart(Chip chip, Spanned text) {
+        // Do nothing
+        return 0;
+    }
+
+    @Override
+    public int findChipEnd(Chip chip, Spanned text) {
+        // Do nothing
+        return 0;
+    }
+
+    @NonNull
+    @Override
+    public Chip[] findAllChips(int start, int end, Spanned text) {
+        return new Chip[]{};
+    }
+
+    @Override
+    public void revertChipToToken(Chip chip, Editable text) {
+        // Do nothing
+    }
+
+    @Override
+    public void deleteChip(Chip chip, Editable text) {
+        // Do nothing
+    }
+
+    @Override
+    public void deleteChipAndPadding(Chip chip, Editable text) {
+        // Do nothing
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/tokenizer/ChipTokenizer.java

@@ -0,0 +1,134 @@
+package com.hootsuite.nachos.tokenizer;
+
+import android.text.Editable;
+import android.text.Spanned;
+import android.util.Pair;
+
+import com.hootsuite.nachos.ChipConfiguration;
+import com.hootsuite.nachos.chip.Chip;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * An extension of {@link android.widget.MultiAutoCompleteTextView.Tokenizer Tokenizer} that provides extra support
+ * for chipification.
+ * <p>
+ *     In the context of this interface, a token is considered to be plain (non-chipped) text. Once a token is terminated it becomes or contains a chip.
+ * </p>
+ * <p>
+ *     The CharSequences passed to the ChipTokenizer methods may contain both chipped text
+ *     and plain text so the tokenizer must have some method of distinguishing between the two (e.g. using a delimeter character.
+ *     The {@link #terminateToken(CharSequence, Object)} method is where a chip can be formed and returned to replace the plain text.
+ *     Whatever class the implementation deems to represent a chip, must implement the {@link Chip} interface.
+ * </p>
+ *
+ * @see SpanChipTokenizer
+ */
+public interface ChipTokenizer {
+
+    /**
+     * Configures this ChipTokenizer to produce chips with the provided attributes. For each of these attributes, {@code -1} or {@code null} may be
+     * passed to indicate that the attribute may be ignored.
+     * <p>
+     *     This will also apply the provided {@link ChipConfiguration} to any existing chips in the provided text.
+     * </p>
+     *
+     * @param text              the text in which to search for existing chips to apply the configuration to
+     * @param chipConfiguration a {@link ChipConfiguration} containing customizations for the chips produced by this class
+     */
+    void applyConfiguration(Editable text, ChipConfiguration chipConfiguration);
+
+    /**
+     * Returns the start of the token that ends at offset
+     * <code>cursor</code> within <code>text</code>.
+     */
+    int findTokenStart(CharSequence text, int cursor);
+
+    /**
+     * Returns the end of the token (minus trailing punctuation)
+     * that begins at offset <code>cursor</code> within <code>text</code>.
+     */
+    int findTokenEnd(CharSequence text, int cursor);
+
+    /**
+     * Searches through {@code text} for any tokens.
+     *
+     * @param text the text in which to search for un-terminated tokens
+     * @return a list of {@link Pair}s of the form (startIndex, endIndex) containing the locations of all
+     * unterminated tokens
+     */
+    @NonNull
+    List<Pair<Integer, Integer>> findAllTokens(CharSequence text);
+
+    /**
+     * Returns <code>text</code>, modified, if necessary, to ensure that
+     * it ends with a token terminator (for example a space or comma).
+     */
+    CharSequence terminateToken(CharSequence text, @Nullable Object data);
+
+    /**
+     * Terminates (converts from token into chip) all unterminated tokens in the provided text.
+     * This method CAN alter the provided text.
+     *
+     * @param text the text in which to terminate all tokens
+     */
+    void terminateAllTokens(Editable text);
+
+    /**
+     * Finds the index of the first character in {@code text} that is a part of {@code chip}
+     *
+     * @param chip the chip whose start should be found
+     * @param text the text in which to search for the start of {@code chip}
+     * @return the start index of the chip
+     */
+    int findChipStart(Chip chip, Spanned text);
+
+    /**
+     * Finds the index of the character after the last character in {@code text} that is a part of {@code chip}
+     *
+     * @param chip the chip whose end should be found
+     * @param text the text in which to search for the end of {@code chip}
+     * @return the end index of the chip
+     */
+    int findChipEnd(Chip chip, Spanned text);
+
+    /**
+     * Searches through {@code text} for any chips
+     *
+     * @param start index to start looking for terminated tokens (inclusive)
+     * @param end   index to end looking for terminated tokens (exclusive)
+     * @param text  the text in which to search for terminated tokens
+     * @return a list of objects implementing the {@link Chip} interface to represent the terminated tokens
+     */
+    @NonNull
+    Chip[] findAllChips(int start, int end, Spanned text);
+
+    /**
+     * Effectively does the opposite of {@link #terminateToken(CharSequence, Object)} by reverting the provided chip back into a token.
+     * This method CAN alter the provided text.
+     *
+     * @param chip the chip to revert into a token
+     * @param text the text in which the chip resides
+     */
+    void revertChipToToken(Chip chip, Editable text);
+
+    /**
+     * Removes a chip and any text it encompasses from {@code text}. This method CAN alter the provided text.
+     *
+     * @param chip the chip to remove
+     * @param text the text to remove the chip from
+     */
+    void deleteChip(Chip chip, Editable text);
+
+    /**
+     * Removes a chip, any text it encompasses AND any padding text (such as spaces) that may have been inserted when the chip was created in
+     * {@link #terminateToken(CharSequence, Object)} or after. This method CAN alter the provided text.
+     *
+     * @param chip the chip to remove
+     * @param text the text to remove the chip and padding from
+     */
+    void deleteChipAndPadding(Chip chip, Editable text);
+}

mastodon/src/main/java/com/hootsuite/nachos/tokenizer/SpanChipTokenizer.java

@@ -0,0 +1,246 @@
+package com.hootsuite.nachos.tokenizer;
+
+import android.content.Context;
+import android.text.Editable;
+import android.text.SpannableString;
+import android.text.Spanned;
+import android.util.Pair;
+
+import com.hootsuite.nachos.ChipConfiguration;
+import com.hootsuite.nachos.chip.Chip;
+import com.hootsuite.nachos.chip.ChipCreator;
+import com.hootsuite.nachos.chip.ChipSpan;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * A default implementation of {@link ChipTokenizer}.
+ *     This implementation does the following:
+ *     <ul>
+ *         <li>Surrounds each token with a space and the Unit Separator ASCII control character (31) - See the diagram below
+ *              <ul>
+ *                  <li>The spaces are included so that android keyboards can distinguish the chips as different words and provide accurate
+ *                  autocorrect suggestions</li>
+ *              </ul>
+ *         </li>
+ *         <li>Replaces each token with a {@link ChipSpan} containing the same text, once the token terminates</li>
+ *         <li>Uses the values passed to {@link #applyConfiguration(Editable, ChipConfiguration)} to configure any ChipSpans that get created</li>
+ *     </ul>
+ * Each terminated token will therefore look like the following (this is what will be returned from {@link #terminateToken(CharSequence, Object)}):
+ * <pre>
+ *  -----------------------------------------------------------
+ *  | SpannableString                                         |
+ *  |   ----------------------------------------------------  |
+ *  |   | ChipSpan                                         |  |
+ *  |   |                                                  |  |
+ *  |   |  space   separator    text    separator   space  |  |
+ *  |   |                                                  |  |
+ *  |   ----------------------------------------------------  |
+ *  -----------------------------------------------------------
+ * </pre>
+ *
+ * @see ChipSpan
+ */
+public class SpanChipTokenizer<C extends Chip> implements ChipTokenizer {
+
+    /**
+     * The character used to separate chips internally is the US (Unit Separator) ASCII control character.
+     * This character is used because it's untypable so we have complete control over when chips are created.
+     */
+    public static final char CHIP_SPAN_SEPARATOR = 31;
+    public static final char AUTOCORRECT_SEPARATOR = ' ';
+
+    private Context mContext;
+
+    @Nullable
+    private ChipConfiguration mChipConfiguration;
+    @NonNull
+    private ChipCreator<C> mChipCreator;
+    @NonNull
+    private Class<C> mChipClass;
+
+    private Comparator<Pair<Integer, Integer>> mReverseTokenIndexesSorter = new Comparator<Pair<Integer, Integer>>() {
+        @Override
+        public int compare(Pair<Integer, Integer> lhs, Pair<Integer, Integer> rhs) {
+            return rhs.first - lhs.first;
+        }
+    };
+
+    public SpanChipTokenizer(Context context, @NonNull ChipCreator<C> chipCreator, @NonNull Class<C> chipClass) {
+        mContext = context;
+        mChipCreator = chipCreator;
+        mChipClass = chipClass;
+    }
+
+    @Override
+    public void applyConfiguration(Editable text, ChipConfiguration chipConfiguration) {
+        mChipConfiguration = chipConfiguration;
+
+        for (C chip : findAllChips(0, text.length(), text)) {
+            // Recreate the chips with the new configuration
+            int chipStart = findChipStart(chip, text);
+            deleteChip(chip, text);
+            text.insert(chipStart, terminateToken(mChipCreator.createChip(mContext, chip)));
+        }
+    }
+
+    @Override
+    public int findTokenStart(CharSequence text, int cursor) {
+        int i = cursor;
+
+        // Work backwards until we find a CHIP_SPAN_SEPARATOR
+        while (i > 0 && text.charAt(i - 1) != CHIP_SPAN_SEPARATOR) {
+            i--;
+        }
+        // Work forwards to skip over any extra whitespace at the beginning of the token
+        while (i > 0 && i < text.length() && Character.isWhitespace(text.charAt(i))) {
+            i++;
+        }
+        return i;
+    }
+
+    @Override
+    public int findTokenEnd(CharSequence text, int cursor) {
+        int i = cursor;
+        int len = text.length();
+
+        // Work forwards till we find a CHIP_SPAN_SEPARATOR
+        while (i < len) {
+            if (text.charAt(i) == CHIP_SPAN_SEPARATOR) {
+                return (i - 1); // subtract one because the CHIP_SPAN_SEPARATOR will be preceded by a space
+            } else {
+                i++;
+            }
+        }
+        return len;
+    }
+
+    @NonNull
+    @Override
+    public List<Pair<Integer, Integer>> findAllTokens(CharSequence text) {
+        List<Pair<Integer, Integer>> unterminatedTokens = new ArrayList<>();
+
+        boolean insideChip = false;
+        // Iterate backwards through the text (to avoid messing up indexes)
+        for (int index = text.length() - 1; index >= 0; index--) {
+            char theCharacter = text.charAt(index);
+
+            // Every time we hit a CHIP_SPAN_SEPARATOR character we switch from being inside to outside
+            // or outside to inside a chip
+            // This check must happen before the whitespace check because CHIP_SPAN_SEPARATOR is considered a whitespace character
+            if (theCharacter == CHIP_SPAN_SEPARATOR) {
+                insideChip = !insideChip;
+                continue;
+            }
+
+            // Completely skip over whitespace
+            if (Character.isWhitespace(theCharacter)) {
+                continue;
+            }
+
+            // If we're ever outside a chip, see if the text we're in is a viable token for chipification
+            if (!insideChip) {
+                int tokenStart = findTokenStart(text, index);
+                int tokenEnd = findTokenEnd(text, index);
+
+                // Can only actually be chipified if there's at least one character between them
+                if (tokenEnd - tokenStart >= 1) {
+                    unterminatedTokens.add(new Pair<>(tokenStart, tokenEnd));
+                    index = tokenStart;
+                }
+            }
+        }
+        return unterminatedTokens;
+    }
+
+    @Override
+    public CharSequence terminateToken(CharSequence text, @Nullable Object data) {
+        // Remove leading/trailing whitespace
+        CharSequence trimmedText = text.toString().trim();
+        return terminateToken(mChipCreator.createChip(mContext, trimmedText, data));
+    }
+
+    private CharSequence terminateToken(C chip) {
+        // Surround the text with CHIP_SPAN_SEPARATOR and spaces
+        // The spaces allow autocorrect to correctly identify words
+        String chipSeparator = Character.toString(CHIP_SPAN_SEPARATOR);
+        String autoCorrectSeparator = Character.toString(AUTOCORRECT_SEPARATOR);
+        CharSequence textWithSeparator = autoCorrectSeparator + chipSeparator + chip.getText() + chipSeparator + autoCorrectSeparator;
+
+        // Build the container object to house the ChipSpan and space
+        SpannableString spannableString = new SpannableString(textWithSeparator);
+
+        // Attach the ChipSpan
+        if (mChipConfiguration != null) {
+            mChipCreator.configureChip(chip, mChipConfiguration);
+        }
+        spannableString.setSpan(chip, 0, textWithSeparator.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+
+        return spannableString;
+    }
+
+    @Override
+    public void terminateAllTokens(Editable text) {
+        List<Pair<Integer, Integer>> unterminatedTokens = findAllTokens(text);
+        // Sort in reverse order (so index changes don't affect anything)
+        Collections.sort(unterminatedTokens, mReverseTokenIndexesSorter);
+        for (Pair<Integer, Integer> indexes : unterminatedTokens) {
+            int start = indexes.first;
+            int end = indexes.second;
+            CharSequence textToChip = text.subSequence(start, end);
+            CharSequence chippedText = terminateToken(textToChip, null);
+            text.replace(start, end, chippedText);
+        }
+    }
+
+    @Override
+    public int findChipStart(Chip chip, Spanned text) {
+        return text.getSpanStart(chip);
+    }
+
+    @Override
+    public int findChipEnd(Chip chip, Spanned text) {
+        return text.getSpanEnd(chip);
+    }
+
+    @SuppressWarnings("unchecked")
+    @NonNull
+    @Override
+    public C[] findAllChips(int start, int end, Spanned text) {
+        C[] spansArray = text.getSpans(start, end, mChipClass);
+        return (spansArray != null) ? spansArray : (C[]) Array.newInstance(mChipClass, 0);
+    }
+
+    @Override
+    public void revertChipToToken(Chip chip, Editable text) {
+        int chipStart = findChipStart(chip, text);
+        int chipEnd = findChipEnd(chip, text);
+        text.removeSpan(chip);
+        text.replace(chipStart, chipEnd, chip.getText());
+    }
+
+    @Override
+    public void deleteChip(Chip chip, Editable text) {
+        int chipStart = findChipStart(chip, text);
+        int chipEnd = findChipEnd(chip, text);
+        text.removeSpan(chip);
+        // On the emulator for some reason the text automatically gets deleted and chipStart and chipEnd end up both being -1, so in that case we
+        // don't need to call text.delete(...)
+        if (chipStart != chipEnd) {
+            text.delete(chipStart, chipEnd);
+        }
+    }
+
+    @Override
+    public void deleteChipAndPadding(Chip chip, Editable text) {
+        // This implementation does not add any extra padding outside of the span so we can just delete the chip normally
+        deleteChip(chip, text);
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/validator/ChipifyingNachoValidator.java

@@ -0,0 +1,32 @@
+package com.hootsuite.nachos.validator;
+
+import android.text.SpannableStringBuilder;
+import android.util.Pair;
+
+import com.hootsuite.nachos.tokenizer.ChipTokenizer;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+
+/**
+ * A {@link NachoValidator} that deems text to be invalid if it contains
+ * unterminated tokens and fixes the text by chipifying all the unterminated tokens.
+ */
+public class ChipifyingNachoValidator implements NachoValidator {
+
+    @Override
+    public boolean isValid(@NonNull ChipTokenizer chipTokenizer, CharSequence text) {
+
+        // The text is considered valid if there are no unterminated tokens (everything is a chip)
+        List<Pair<Integer, Integer>> unterminatedTokens = chipTokenizer.findAllTokens(text);
+        return unterminatedTokens.isEmpty();
+    }
+
+    @Override
+    public CharSequence fixText(@NonNull ChipTokenizer chipTokenizer, CharSequence invalidText) {
+        SpannableStringBuilder newText = new SpannableStringBuilder(invalidText);
+        chipTokenizer.terminateAllTokens(newText);
+        return newText;
+    }
+}

mastodon/src/main/java/com/hootsuite/nachos/validator/IllegalCharacterIdentifier.java

@@ -0,0 +1,5 @@
+package com.hootsuite.nachos.validator;
+
+public interface IllegalCharacterIdentifier {
+	boolean isCharacterIllegal(Character c);
+}

mastodon/src/main/java/com/hootsuite/nachos/validator/NachoValidator.java

@@ -0,0 +1,29 @@
+package com.hootsuite.nachos.validator;
+
+import com.hootsuite.nachos.tokenizer.ChipTokenizer;
+
+import androidx.annotation.NonNull;
+
+/**
+ * Interface used to ensure that a given CharSequence complies to a particular format.
+ */
+public interface NachoValidator {
+
+    /**
+     * Validates the specified text.
+     *
+     * @return true If the text currently in the text editor is valid.
+     * @see #fixText(ChipTokenizer, CharSequence)
+     */
+    boolean isValid(@NonNull ChipTokenizer chipTokenizer, CharSequence text);
+
+    /**
+     * Corrects the specified text to make it valid.
+     *
+     * @param invalidText A string that doesn't pass validation: isValid(invalidText)
+     *                    returns false
+     * @return A string based on invalidText such as invoking isValid() on it returns true.
+     * @see #isValid(ChipTokenizer, CharSequence)
+     */
+    CharSequence fixText(@NonNull ChipTokenizer chipTokenizer, CharSequence invalidText);
+}

mastodon/src/main/java/name/fraser/neil/plaintext/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mastodon/src/main/java/org/joinmastodon/android/GlobalUserPreferences.java

@@ -1,12 +1,19 @@
 package org.joinmastodon.android;
 
+import static org.joinmastodon.android.api.MastodonAPIController.gson;
+
 import android.content.Context;
 import android.content.SharedPreferences;
 
+import com.google.gson.JsonSyntaxException;
+
+import org.joinmastodon.android.api.session.AccountLocalPreferences;
 import org.joinmastodon.android.api.session.AccountSession;
 import org.joinmastodon.android.api.session.AccountSessionManager;
 import org.joinmastodon.android.model.Account;
 
+import java.lang.reflect.Type;
+
 public class GlobalUserPreferences{
 	public static boolean playGifs;
 	public static boolean useCustomTabs;
@@ -18,6 +25,47 @@ public class GlobalUserPreferences{
 	public static boolean showCWs;
 	public static boolean hideSensitiveMedia;
 
+	// MOSHIDON:
+	public static boolean trueBlackTheme;
+	public static boolean loadNewPosts;
+	public static boolean showNewPostsButton;
+	public static boolean toolbarMarquee;
+	public static boolean disableSwipe;
+	public static boolean enableDeleteNotifications;
+	public static boolean translateButtonOpenedOnly;
+	public static boolean uniformNotificationIcon;
+	public static boolean reduceMotion;
+	public static boolean showAltIndicator;
+	public static boolean showNoAltIndicator;
+	public static boolean enablePreReleases;
+	public static PrefixRepliesMode prefixReplies;
+	public static boolean collapseLongPosts;
+	public static boolean spectatorMode;
+	public static boolean autoHideFab;
+	public static boolean allowRemoteLoading;
+	public static AutoRevealMode autoRevealEqualSpoilers;
+	public static boolean disableM3PillActiveIndicator;
+	public static boolean showNavigationLabels;
+	public static boolean displayPronounsInTimelines, displayPronounsInThreads, displayPronounsInUserListings;
+	public static boolean overlayMedia;
+	public static boolean showSuicideHelp;
+	public static boolean underlinedLinks;
+	public static AccountLocalPreferences.ColorPreference color;
+	public static boolean likeIcon;
+	public static boolean showDividers;
+	public static boolean relocatePublishButton;
+	public static boolean defaultToUnlistedReplies;
+	public static boolean doubleTapToSearch;
+	public static boolean doubleTapToSwipe;
+	public static boolean confirmBeforeReblog;
+	public static boolean hapticFeedback;
+	public static boolean replyLineAboveHeader;
+	public static boolean swapBookmarkWithBoostAction;
+	public static boolean mentionRebloggerAutomatically;
+	public static boolean showPostsWithoutAlt;
+	public static boolean showMediaPreview;
+	public static boolean removeTrackingParams;
+
 	private static SharedPreferences getPrefs(){
 		return MastodonApp.context.getSharedPreferences("global", Context.MODE_PRIVATE);
 	}
@@ -110,4 +158,35 @@ public class GlobalUserPreferences{
 		OLD_POST,
 		NON_MUTUAL
 	}
+
+	// MOSHIDON:
+	public enum AutoRevealMode {
+		NEVER,
+		THREADS,
+		DISCUSSIONS
+	}
+
+	// MOSHIDON:
+	public enum PrefixRepliesMode {
+		NEVER,
+		ALWAYS,
+		TO_OTHERS
+	}
+
+	// MOSHIDON: we have jason
+	public static <T> T fromJson(String json, Type type, T orElse){
+		if(json==null) return orElse;
+		try{
+			T value=gson.fromJson(json, type);
+			return value==null ? orElse : value;
+		}catch(JsonSyntaxException ignored){
+			return orElse;
+		}
+	}
+
+	// MOSHIDON: enums too!
+	public static <T extends Enum<T>> T enumValue(Class<T> enumType, String name) {
+		try { return Enum.valueOf(enumType, name); }
+		catch (NullPointerException npe) { return null; }
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/MainActivity.java

@@ -24,6 +24,7 @@ import org.joinmastodon.android.fragments.ProfileFragment;
 import org.joinmastodon.android.fragments.SplashFragment;
 import org.joinmastodon.android.fragments.ThreadFragment;
 import org.joinmastodon.android.fragments.onboarding.AccountActivationFragment;
+import org.joinmastodon.android.fragments.onboarding.CustomWelcomeFragment;
 import org.joinmastodon.android.model.Notification;
 import org.joinmastodon.android.model.SearchResults;
 import org.joinmastodon.android.ui.utils.UiUtils;
@@ -183,7 +184,7 @@ public class MainActivity extends FragmentStackActivity{
 
 	public void restartHomeFragment(){
 		if(AccountSessionManager.getInstance().getLoggedInAccounts().isEmpty()){
-			showFragmentClearingBackStack(new SplashFragment());
+			showFragmentClearingBackStack(new CustomWelcomeFragment());
 		}else{
 			AccountSessionManager.getInstance().maybeUpdateLocalInfo();
 			AccountSession session;

mastodon/src/main/java/org/joinmastodon/android/api/requests/accounts/SetPrivateNote.java

@@ -0,0 +1,19 @@
+package org.joinmastodon.android.api.requests.accounts;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Relationship;
+
+public class SetPrivateNote extends MastodonAPIRequest<Relationship>{
+	public SetPrivateNote(String id, String comment){
+		super(MastodonAPIRequest.HttpMethod.POST, "/accounts/"+id+"/note", Relationship.class);
+		Request req = new Request(comment);
+		setRequestBody(req);
+	}
+
+	private static class Request{
+		public String comment;
+		public Request(String comment){
+			this.comment=comment;
+		}
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/announcements/AddAnnouncementReaction.java

@@ -0,0 +1,10 @@
+package org.joinmastodon.android.api.requests.announcements;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+
+public class AddAnnouncementReaction extends MastodonAPIRequest<Object> {
+	public AddAnnouncementReaction(String id, String emoji) {
+		super(HttpMethod.PUT, "/announcements/" + id + "/reactions/" + emoji, Object.class);
+		setRequestBody(new Object());
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/announcements/DeleteAnnouncementReaction.java

@@ -0,0 +1,9 @@
+package org.joinmastodon.android.api.requests.announcements;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+
+public class DeleteAnnouncementReaction extends MastodonAPIRequest<Object> {
+	public DeleteAnnouncementReaction(String id, String emoji) {
+		super(HttpMethod.DELETE, "/announcements/" + id + "/reactions/" + emoji, Object.class);
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/announcements/DismissAnnouncement.java

@@ -0,0 +1,10 @@
+package org.joinmastodon.android.api.requests.announcements;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+
+public class DismissAnnouncement extends MastodonAPIRequest<Object>{
+	public DismissAnnouncement(String id){
+		super(HttpMethod.POST, "/announcements/" + id + "/dismiss", Object.class);
+		setRequestBody(new Object());
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/announcements/GetAnnouncements.java

@@ -0,0 +1,15 @@
+package org.joinmastodon.android.api.requests.announcements;
+
+import com.google.gson.reflect.TypeToken;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Announcement;
+
+import java.util.List;
+
+public class GetAnnouncements extends MastodonAPIRequest<List<Announcement>> {
+	public GetAnnouncements(boolean withDismissed) {
+		super(MastodonAPIRequest.HttpMethod.GET, "/announcements", new TypeToken<>(){});
+		addQueryParameter("with_dismissed", withDismissed ? "true" : "false");
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/lists/GetList.java

@@ -0,0 +1,10 @@
+package org.joinmastodon.android.api.requests.lists;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.FollowList;
+
+public class GetList extends MastodonAPIRequest<FollowList> {
+	public GetList(String id) {
+		super(HttpMethod.GET, "/lists/" + id, FollowList.class);
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/AddStatusReaction.java

@@ -0,0 +1,11 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Status;
+
+public class AddStatusReaction extends MastodonAPIRequest<Status> {
+	public AddStatusReaction(String id, String emoji) {
+		super(HttpMethod.POST, "/statuses/" + id + "/react/" + emoji, Status.class);
+		setRequestBody(new Object());
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/AkkomaTranslateStatus.java

@@ -0,0 +1,10 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.AkkomaTranslation;
+
+public class AkkomaTranslateStatus extends MastodonAPIRequest<AkkomaTranslation>{
+	public AkkomaTranslateStatus(String id, String lang){
+		super(HttpMethod.GET, "/statuses/"+id+"/translations/"+lang.toLowerCase(), AkkomaTranslation.class);
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/DeleteStatusReaction.java

@@ -0,0 +1,11 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Status;
+
+public class DeleteStatusReaction extends MastodonAPIRequest<Status> {
+	public DeleteStatusReaction(String id, String emoji) {
+		super(HttpMethod.POST, "/statuses/" + id + "/unreact/" + emoji, Status.class);
+		setRequestBody(new Object());
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/GetScheduledStatuses.java

@@ -0,0 +1,16 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import com.google.gson.reflect.TypeToken;
+
+import org.joinmastodon.android.api.requests.HeaderPaginationRequest;
+import org.joinmastodon.android.model.ScheduledStatus;
+
+public class GetScheduledStatuses extends HeaderPaginationRequest<ScheduledStatus>{
+	public GetScheduledStatuses(String maxID, int limit){
+		super(HttpMethod.GET, "/scheduled_statuses", new TypeToken<>(){});
+		if(maxID!=null)
+			addQueryParameter("max_id", maxID);
+		if(limit>0)
+			addQueryParameter("limit", limit+"");
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/PleromaAddStatusReaction.java

@@ -0,0 +1,11 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Status;
+
+public class PleromaAddStatusReaction extends MastodonAPIRequest<Status> {
+    public PleromaAddStatusReaction(String id, String emoji) {
+        super(HttpMethod.PUT, "/pleroma/statuses/" + id + "/reactions/" + emoji, Status.class);
+		setRequestBody(new Object());
+    }
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/PleromaDeleteStatusReaction.java

@@ -0,0 +1,10 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Status;
+
+public class PleromaDeleteStatusReaction extends MastodonAPIRequest<Status> {
+    public PleromaDeleteStatusReaction(String id, String emoji) {
+        super(HttpMethod.DELETE, "/pleroma/statuses/" + id + "/reactions/" + emoji, Status.class);
+    }
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/statuses/PleromaGetStatusReactions.java

@@ -0,0 +1,14 @@
+package org.joinmastodon.android.api.requests.statuses;
+
+import com.google.gson.reflect.TypeToken;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.EmojiReaction;
+
+import java.util.List;
+
+public class PleromaGetStatusReactions extends MastodonAPIRequest<List<EmojiReaction>> {
+    public PleromaGetStatusReactions(String id, String emoji) {
+        super(HttpMethod.GET, "/pleroma/statuses/" + id + "/reactions/" + (emoji != null ? emoji : ""), new TypeToken<>(){});
+    }
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/timelines/GetBubbleTimeline.java

@@ -0,0 +1,22 @@
+package org.joinmastodon.android.api.requests.timelines;
+
+import android.text.TextUtils;
+
+import com.google.gson.reflect.TypeToken;
+
+import org.joinmastodon.android.api.MastodonAPIRequest;
+import org.joinmastodon.android.model.Status;
+
+import java.util.List;
+
+public class GetBubbleTimeline extends MastodonAPIRequest<List<Status>> {
+	public GetBubbleTimeline(String maxID, int limit, String replyVisibility) {
+		super(HttpMethod.GET, "/timelines/bubble", new TypeToken<>(){});
+		if(!TextUtils.isEmpty(maxID))
+			addQueryParameter("max_id", maxID);
+		if(limit>0)
+			addQueryParameter("limit", limit+"");
+		if(replyVisibility != null)
+			addQueryParameter("reply_visibility", replyVisibility);
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/api/requests/timelines/GetListTimeline.java

@@ -8,6 +8,22 @@ import org.joinmastodon.android.model.Status;
 import java.util.List;
 
 public class GetListTimeline extends MastodonAPIRequest<List<Status>>{
+	public GetListTimeline(String listID, String maxID, String minID, int limit, String sinceID, /* MOSHIDON: */ String replyVisibility){
+		super(HttpMethod.GET, "/timelines/list/"+listID, new TypeToken<>(){});
+		if(maxID!=null)
+			addQueryParameter("max_id", maxID);
+		if(minID!=null)
+			addQueryParameter("min_id", minID);
+		if(limit>0)
+			addQueryParameter("limit", ""+limit);
+		if(sinceID!=null)
+			addQueryParameter("since_id", sinceID);
+		// MOSHIDON:
+		if(replyVisibility != null)
+			addQueryParameter("reply_visibility", replyVisibility);
+	}
+
+	// MOSHIDON: I absolutely don't want to touch the upstream implementations of this. Thank you java for overloading :D
 	public GetListTimeline(String listID, String maxID, String minID, int limit, String sinceID){
 		super(HttpMethod.GET, "/timelines/list/"+listID, new TypeToken<>(){});
 		if(maxID!=null)

mastodon/src/main/java/org/joinmastodon/android/api/requests/timelines/GetPublicTimeline.java

@@ -10,7 +10,7 @@ import org.joinmastodon.android.model.Status;
 import java.util.List;
 
 public class GetPublicTimeline extends MastodonAPIRequest<List<Status>>{
-	public GetPublicTimeline(boolean local, boolean remote, String maxID, String minID, int limit, String sinceID){
+	public GetPublicTimeline(boolean local, boolean remote, String maxID, String minID, int limit, String sinceID, String replyVisibility){
 		super(HttpMethod.GET, "/timelines/public", new TypeToken<>(){});
 		if(local)
 			addQueryParameter("local", "true");
@@ -24,5 +24,8 @@ public class GetPublicTimeline extends MastodonAPIRequest<List<Status>>{
 			addQueryParameter("since_id", sinceID);
 		if(limit>0)
 			addQueryParameter("limit", limit+"");
+		// MOSHIDON:
+		if(replyVisibility != null)
+			addQueryParameter("reply_visibility", replyVisibility);
 	}
 }

mastodon/src/main/java/org/joinmastodon/android/api/session/AccountLocalPreferences.java

@@ -1,15 +1,80 @@
 package org.joinmastodon.android.api.session;
 
+import static org.joinmastodon.android.GlobalUserPreferences.enumValue;
+import static org.joinmastodon.android.GlobalUserPreferences.fromJson;
+import static org.joinmastodon.android.api.MastodonAPIController.gson;
+
 import android.content.SharedPreferences;
 
+import androidx.annotation.StringRes;
+
+import com.google.gson.reflect.TypeToken;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.model.ContentType;
+import org.joinmastodon.android.model.Emoji;
+import org.joinmastodon.android.model.PushSubscription;
+import org.joinmastodon.android.model.TimelineDefinition;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+
 public class AccountLocalPreferences{
 	private final SharedPreferences prefs;
 
 	public boolean serverSideFiltersSupported;
 
-	public AccountLocalPreferences(SharedPreferences prefs){
+
+	// MOSHIDON:
+	public boolean showReplies;
+	public boolean showBoosts;
+	public ArrayList<String> recentLanguages;
+	public boolean bottomEncoding;
+	public ContentType defaultContentType;
+	public boolean contentTypesEnabled;
+	public ArrayList<TimelineDefinition> timelines;
+	public boolean localOnlySupported;
+	public boolean glitchInstance;
+	public String publishButtonText;
+	public String timelineReplyVisibility; // akkoma-only
+	public boolean keepOnlyLatestNotification;
+	public boolean emojiReactionsEnabled;
+	public ShowEmojiReactions showEmojiReactions;
+	public ColorPreference color;
+	public ArrayList<Emoji> recentCustomEmoji;
+	public boolean preReplySheet;
+
+	// MOSHIDON: this is also ours
+	private final static Type recentLanguagesType=new TypeToken<ArrayList<String>>() {}.getType();
+	private final static Type timelinesType=new TypeToken<ArrayList<TimelineDefinition>>() {}.getType();
+	private final static Type recentCustomEmojiType=new TypeToken<ArrayList<Emoji>>() {}.getType();
+	private final static Type notificationFiltersType = new TypeToken<PushSubscription.Alerts>() {}.getType();
+	public PushSubscription.Alerts notificationFilters;
+
+
+	public AccountLocalPreferences(SharedPreferences prefs, AccountSession session){
 		this.prefs=prefs;
 		serverSideFiltersSupported=prefs.getBoolean("serverSideFilters", false);
+
+		// MOSHIDON:
+		showReplies=prefs.getBoolean("showReplies", true);
+		showBoosts=prefs.getBoolean("showBoosts", true);
+		recentLanguages=fromJson(prefs.getString("recentLanguages", null), recentLanguagesType, new ArrayList<>());
+		bottomEncoding=prefs.getBoolean("bottomEncoding", false);
+		defaultContentType=enumValue(ContentType .class, prefs.getString("defaultContentType", ContentType.PLAIN.name()));
+		contentTypesEnabled=prefs.getBoolean("contentTypesEnabled", true);
+		timelines=fromJson(prefs.getString("timelines", null), timelinesType, TimelineDefinition.getDefaultTimelines(session.getID()));
+		localOnlySupported=prefs.getBoolean("localOnlySupported", false);
+		glitchInstance=prefs.getBoolean("glitchInstance", false);
+		publishButtonText=prefs.getString("publishButtonText", null);
+		timelineReplyVisibility=prefs.getString("timelineReplyVisibility", null);
+		keepOnlyLatestNotification=prefs.getBoolean("keepOnlyLatestNotification", false);
+		emojiReactionsEnabled=prefs.getBoolean("emojiReactionsEnabled", session.getInstance().isPresent() && session.getInstance().get().isAkkoma());
+		showEmojiReactions=ShowEmojiReactions.valueOf(prefs.getString("showEmojiReactions", ShowEmojiReactions.HIDE_EMPTY.name()));
+		color=prefs.contains("color") ? ColorPreference.valueOf(prefs.getString("color", null)) : null;
+		recentCustomEmoji=fromJson(prefs.getString("recentCustomEmoji", null), recentCustomEmojiType, new ArrayList<>());
+		notificationFilters=fromJson(prefs.getString("notificationFilters", gson.toJson(PushSubscription.Alerts.ofAll())), notificationFiltersType, PushSubscription.Alerts.ofAll());
+
 	}
 
 	public long getNotificationsPauseEndTime(){
@@ -23,6 +88,62 @@ public class AccountLocalPreferences{
 	public void save(){
 		prefs.edit()
 				.putBoolean("serverSideFilters", serverSideFiltersSupported)
+
+				// MOSHIDON:
+				.putBoolean("showReplies", showReplies)
+				.putBoolean("showBoosts", showBoosts)
+				.putString("recentLanguages", gson.toJson(recentLanguages))
+				.putBoolean("bottomEncoding", bottomEncoding)
+				.putString("defaultContentType", defaultContentType==null ? null : defaultContentType.name())
+				.putBoolean("contentTypesEnabled", contentTypesEnabled)
+				.putString("timelines", gson.toJson(timelines))
+				.putBoolean("localOnlySupported", localOnlySupported)
+				.putBoolean("glitchInstance", glitchInstance)
+				.putString("publishButtonText", publishButtonText)
+				.putString("timelineReplyVisibility", timelineReplyVisibility)
+				.putBoolean("keepOnlyLatestNotification", keepOnlyLatestNotification)
+				.putBoolean("emojiReactionsEnabled", emojiReactionsEnabled)
+				.putString("showEmojiReactions", showEmojiReactions.name())
+				.putString("color", color!=null ? color.name() : null)
+				.putString("recentCustomEmoji", gson.toJson(recentCustomEmoji))
+				.putString("notificationFilters", gson.toJson(notificationFilters))
+
 				.apply();
 	}
+
+	// MOSHIDON:
+	public enum ColorPreference{
+		MATERIAL3,
+		PURPLE,
+		PINK,
+		GREEN,
+		BLUE,
+		BROWN,
+		RED,
+		YELLOW,
+		NORD,
+		WHITE;
+
+		public @StringRes int getName() {
+			return switch(this){
+				case MATERIAL3 -> R.string.sk_color_palette_material3;
+				case PINK -> R.string.sk_color_palette_pink;
+				case PURPLE -> R.string.sk_color_palette_purple;
+				case GREEN -> R.string.sk_color_palette_green;
+				case BLUE -> R.string.sk_color_palette_blue;
+				case BROWN -> R.string.sk_color_palette_brown;
+				case RED -> R.string.sk_color_palette_red;
+				case YELLOW -> R.string.sk_color_palette_yellow;
+				case NORD -> R.string.mo_color_palette_nord;
+				case WHITE -> R.string.mo_color_palette_black_and_white;
+			};
+		}
+	}
+
+	// MOSHIDON:
+	public enum ShowEmojiReactions{
+		HIDE_EMPTY,
+		ONLY_OPENED,
+		ALWAYS
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/api/session/AccountSession.java

@@ -4,6 +4,7 @@ import android.app.Activity;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.SharedPreferences;
+import android.net.Uri;
 import android.text.TextUtils;
 import android.util.Log;
 
@@ -44,6 +45,7 @@ import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -303,7 +305,7 @@ public class AccountSession{
 
 	public AccountLocalPreferences getLocalPreferences(){
 		if(localPreferences==null)
-			localPreferences=new AccountLocalPreferences(getRawLocalPreferences());
+			localPreferences=new AccountLocalPreferences(getRawLocalPreferences(), this);
 		return localPreferences;
 	}
 
@@ -350,6 +352,19 @@ public class AccountSession{
 		});
 	}
 
+	// MOSHIDON: there might be a bunch of crashes if I don't put this back here
+	public Optional<Instance> getInstance() {
+		return Optional.ofNullable(AccountSessionManager.getInstance().getInstanceInfo(domain));
+	}
+
+	// MOSHIDON: some weird methods we have ain't we
+	public Uri getInstanceUri() {
+		return new Uri.Builder()
+				.scheme("https")
+				.authority(getInstance().map(i -> i.normalizedUri).orElse(domain))
+				.build();
+	}
+
 	public void updateAccountInfo(){
 		AccountSessionManager.getInstance().updateSessionLocalInfo(this);
 	}

mastodon/src/main/java/org/joinmastodon/android/api/session/AccountSessionManager.java

@@ -384,7 +384,7 @@ public class AccountSessionManager{
 	private void readInstanceInfo(SQLiteDatabase db, Set<String> domains){
 		for(String domain : domains){
 			final int maxEmojiLength=500000;
-			try(Cursor cursor=db.rawQuery("SELECT domain, instance_obj, substring(emojis,0,?) AS emojis, length(emojis) AS emoji_length, last_updated, version FROM instances WHERE `domain` = ?",
+			try(Cursor cursor=db.rawQuery("SELECT domain, instance_obj, substr(emojis,1,?) AS emojis, length(emojis) AS emoji_length, last_updated, version FROM instances WHERE `domain` = ?",
 					new String[]{String.valueOf(maxEmojiLength) , domain})) {
 				ContentValues values=new ContentValues();
 				while(cursor.moveToNext()){
@@ -395,13 +395,19 @@ public class AccountSessionManager{
 						case 2 -> InstanceV2.class;
 						default -> throw new IllegalStateException("Unexpected value: "+version);
 					});
+					instances.put(domain, instance);
 					StringBuilder emojiSB=new StringBuilder();
-					emojiSB.append(values.getAsString("emojis"));
+					String emojiPart=values.getAsString("emojis");
+					if(emojiPart==null){
+						// not putting anything into instancesLastUpdated to force a reload
+						continue;
+					}
+					emojiSB.append(emojiPart);
 					//get emoji in chunks of 1MB if it didn't fit in the first query
 					int emojiStringLength=values.getAsInteger("emoji_length");
 					if(emojiStringLength>maxEmojiLength){
 						final int pagesize=1000000;
-						for(int start=maxEmojiLength; start<emojiStringLength; start+=pagesize){
+						for(int start=maxEmojiLength + 1; start<=emojiStringLength; start+=pagesize){
 							try(Cursor emojiCursor=db.rawQuery("SELECT substr(emojis,?, ?) FROM instances WHERE `domain` = ?", new String[]{String.valueOf(start), String.valueOf(pagesize), domain})){
 								emojiCursor.moveToNext();
 								emojiSB.append(emojiCursor.getString(0));
@@ -409,13 +415,12 @@ public class AccountSessionManager{
 						}
 					}
 					List<Emoji> emojis=MastodonAPIController.gson.fromJson(emojiSB.toString(), new TypeToken<List<Emoji>>(){}.getType());
-					instances.put(domain, instance);
 					customEmojis.put(domain, groupCustomEmojis(emojis));
 					instancesLastUpdated.put(domain, values.getAsLong("last_updated"));
 				}
 			}catch(Exception ex){
 				Log.d(TAG, "readInstanceInfo failed", ex);
-				return;
+				// instancesLastUpdated will not contain that domain, so instance data will be forced to be reloaded
 			}
 		}
 		if(!loadedInstances){

mastodon/src/main/java/org/joinmastodon/android/events/EmojiReactionsUpdatedEvent.java

@@ -0,0 +1,19 @@
+package org.joinmastodon.android.events;
+
+import androidx.recyclerview.widget.RecyclerView;
+import org.joinmastodon.android.model.EmojiReaction;
+import java.util.List;
+
+public class EmojiReactionsUpdatedEvent{
+	public final String id;
+	public final List<EmojiReaction> reactions;
+	public final boolean updateTextPadding;
+	public RecyclerView.ViewHolder viewHolder;
+
+	public EmojiReactionsUpdatedEvent(String id, List<EmojiReaction> reactions, boolean updateTextPadding, RecyclerView.ViewHolder viewHolder){
+		this.id=id;
+		this.reactions=reactions;
+		this.updateTextPadding=updateTextPadding;
+		this.viewHolder=viewHolder;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/events/HashtagUpdatedEvent.java

@@ -0,0 +1,11 @@
+package org.joinmastodon.android.events;
+
+public class HashtagUpdatedEvent {
+	public final String name;
+	public final boolean following;
+
+	public HashtagUpdatedEvent(String name, boolean following) {
+		this.name = name;
+		this.following = following;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/events/ListUpdatedCreatedEvent.java

@@ -0,0 +1,17 @@
+package org.joinmastodon.android.events;
+
+import org.joinmastodon.android.model.FollowList;
+
+public class ListUpdatedCreatedEvent {
+	public final String id;
+	public final String title;
+	public final FollowList.RepliesPolicy repliesPolicy;
+	public final boolean exclusive;
+
+	public ListUpdatedCreatedEvent(String id, String title, boolean exclusive, FollowList.RepliesPolicy repliesPolicy) {
+		this.id = id;
+		this.title = title;
+		this.exclusive = exclusive;
+		this.repliesPolicy = repliesPolicy;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/events/ReblogDeletedEvent.java

@@ -0,0 +1,11 @@
+package org.joinmastodon.android.events;
+
+public class ReblogDeletedEvent{
+	public final String statusID;
+	public final String accountID;
+
+	public ReblogDeletedEvent(String statusID, String accountID){
+		this.statusID=statusID;
+		this.accountID=accountID;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/events/ScheduledStatusCreatedEvent.java

@@ -0,0 +1,13 @@
+package org.joinmastodon.android.events;
+
+import org.joinmastodon.android.model.ScheduledStatus;
+
+public class ScheduledStatusCreatedEvent {
+	public final ScheduledStatus scheduledStatus;
+	public final String accountID;
+
+	public ScheduledStatusCreatedEvent(ScheduledStatus scheduledStatus, String accountID){
+		this.scheduledStatus = scheduledStatus;
+		this.accountID=accountID;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/events/ScheduledStatusDeletedEvent.java

@@ -0,0 +1,11 @@
+package org.joinmastodon.android.events;
+
+public class ScheduledStatusDeletedEvent{
+	public final String id;
+	public final String accountID;
+
+	public ScheduledStatusDeletedEvent(String id, String accountID){
+		this.id=id;
+		this.accountID=accountID;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/events/StatusCountersUpdatedEvent.java

@@ -5,7 +5,7 @@ import org.joinmastodon.android.model.Status;
 public class StatusCountersUpdatedEvent{
 	public String id;
 	public long favorites, reblogs, replies;
-	public boolean favorited, reblogged, bookmarked;
+	public boolean favorited, reblogged, bookmarked, pinned;
 
 	public StatusCountersUpdatedEvent(Status s){
 		id=s.id;
@@ -15,5 +15,7 @@ public class StatusCountersUpdatedEvent{
 		favorited=s.favourited;
 		reblogged=s.reblogged;
 		bookmarked=s.bookmarked;
+		// MOSHIDON:
+		pinned=s.pinned;
 	}
 }

mastodon/src/main/java/org/joinmastodon/android/events/StatusMuteChangedEvent.java

@@ -0,0 +1,15 @@
+package org.joinmastodon.android.events;
+
+import org.joinmastodon.android.model.Status;
+
+public class StatusMuteChangedEvent{
+	public String id;
+	public boolean muted;
+	public Status status;
+
+	public StatusMuteChangedEvent(Status s){
+		id=s.id;
+		muted=s.muted;
+		status=s;
+	}
+}

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

@@ -2,6 +2,7 @@ package org.joinmastodon.android.fragments;
 
 import android.content.res.ColorStateList;
 import android.graphics.drawable.Drawable;
+import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.view.LayoutInflater;
@@ -175,4 +176,10 @@ public class AccountNotificationsListFragment extends BaseNotificationsListFragm
 			item.setIconTintList(ColorStateList.valueOf(tintColor));
 		}
 	}
+
+	// MOSHIDON: what is this file even supposed to be????
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null; // TODO
+	}
 }

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

@@ -1,6 +1,7 @@
 package org.joinmastodon.android.fragments;
 
 import android.app.Activity;
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.View;
 import android.widget.HorizontalScrollView;
@@ -170,4 +171,19 @@ public class AccountTimelineFragment extends StatusListFragment{
 		dataLoading=true;
 		doLoadData();
 	}
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.ACCOUNT;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		// could return different uris based on filter (e.g. media -> "/media"), but i want to
+		// return the remote url to the user, and i don't know whether i'd need to append
+		// '#media' (akkoma/pleroma) or '/media' (glitch/mastodon) since i don't know anything
+		// about the remote instance. so, just returning the base url to the user instead
+		return Uri.parse(user.url);
+	}
 }

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

@@ -0,0 +1,106 @@
+package org.joinmastodon.android.fragments;
+
+import static java.util.stream.Collectors.toList;
+
+import android.app.Activity;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.announcements.GetAnnouncements;
+import org.joinmastodon.android.api.requests.statuses.GetScheduledStatuses;
+import org.joinmastodon.android.api.session.AccountSession;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.events.ScheduledStatusCreatedEvent;
+import org.joinmastodon.android.events.ScheduledStatusDeletedEvent;
+import org.joinmastodon.android.model.Account;
+import org.joinmastodon.android.model.Announcement;
+import org.joinmastodon.android.model.Instance;
+import org.joinmastodon.android.model.ScheduledStatus;
+import org.joinmastodon.android.model.Status;
+import org.joinmastodon.android.ui.displayitems.DummyStatusDisplayItem;
+import org.joinmastodon.android.ui.displayitems.EmojiReactionsStatusDisplayItem;
+import org.joinmastodon.android.ui.displayitems.HeaderStatusDisplayItem;
+import org.joinmastodon.android.ui.displayitems.StatusDisplayItem;
+import org.joinmastodon.android.ui.displayitems.TextStatusDisplayItem;
+import org.joinmastodon.android.ui.text.HtmlParser;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import me.grishka.appkit.api.SimpleCallback;
+
+public class AnnouncementsFragment extends BaseStatusListFragment<Announcement> {
+	private Instance instance;
+	private AccountSession session;
+	private List<String> unreadIDs = null;
+
+	@Override
+	public void onAttach(Activity activity){
+		super.onAttach(activity);
+		setTitle(R.string.sk_announcements);
+		session = AccountSessionManager.getInstance().getAccount(accountID);
+		instance = AccountSessionManager.getInstance().getInstanceInfo(session.domain);
+		loadData();
+	}
+
+	@Override
+	protected List<StatusDisplayItem> buildDisplayItems(Announcement a) {
+		if(TextUtils.isEmpty(a.content)) return List.of();
+		Account instanceUser = new Account();
+		instanceUser.id = instanceUser.acct = instanceUser.username = session.domain;
+		instanceUser.displayName = instance.title;
+		instanceUser.url = "https://"+session.domain+"/about";
+		instanceUser.avatar = instanceUser.avatarStatic = instance.thumbnail;
+		instanceUser.emojis = List.of();
+		Status fakeStatus = a.toStatus();
+		// TODO: readd this later
+//		TextStatusDisplayItem textItem = new TextStatusDisplayItem(a.id, HtmlParser.parse(a.content, a.emojis, a.mentions, a.tags, accountID), this, fakeStatus, true);
+//		textItem.textSelectable = true;
+
+		List<StatusDisplayItem> items=new ArrayList<>();
+		// TODO: add this later
+//		items.add(HeaderStatusDisplayItem.fromAnnouncement(a, fakeStatus, instanceUser, this, accountID, this::onMarkAsRead));
+//		items.add(textItem);
+		if(!isInstanceAkkoma()) items.add(new EmojiReactionsStatusDisplayItem(a.id, this, fakeStatus, accountID, false, true));
+		return items;
+	}
+
+	public void onMarkAsRead(String id) {
+		if (unreadIDs == null) return;
+		unreadIDs.remove(id);
+		if (unreadIDs.isEmpty()) setResult(true, null);
+	}
+
+	@Override
+	protected void addAccountToKnown(Announcement s) {}
+
+	@Override
+	public void onItemClick(String id) {}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest=new GetAnnouncements(true)
+				.setCallback(new SimpleCallback<>(this){
+					@Override
+					public void onSuccess(List<Announcement> result){
+						if(getActivity()==null) return;
+
+						// get unread items first
+						List<Announcement> data = result.stream().filter(a -> !a.read).collect(toList());
+						if (data.isEmpty()) setResult(true, null);
+						else unreadIDs = data.stream().map(a -> a.id).collect(toList());
+
+						// append read items at the end
+						data.addAll(result.stream().filter(a -> a.read).collect(toList()));
+						onDataLoaded(data, false);
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return isInstanceAkkoma() ? base.path("/announcements").build() : null;
+	}
+}

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

@@ -12,7 +12,7 @@ import org.joinmastodon.android.model.viewmodel.NotificationViewModel;
 import org.joinmastodon.android.ui.displayitems.InlineStatusStatusDisplayItem;
 import org.joinmastodon.android.ui.displayitems.NotificationHeaderStatusDisplayItem;
 import org.joinmastodon.android.ui.displayitems.NotificationWithButtonStatusDisplayItem;
-import org.joinmastodon.android.ui.displayitems.ReblogOrReplyLineStatusDisplayItem;
+import org.joinmastodon.android.ui.displayitems.ReblogOrReplyLineCustomStatusDisplayItem;
 import org.joinmastodon.android.ui.displayitems.StatusDisplayItem;
 import org.parceler.Parcels;
 
@@ -32,7 +32,7 @@ public abstract class BaseNotificationsListFragment extends BaseStatusListFragme
 			titleItem=null;
 		}else if(n.notification.type==NotificationType.STATUS){
 			if(n.status!=null)
-				titleItem=new ReblogOrReplyLineStatusDisplayItem(n.getID(), this, getString(R.string.user_just_posted, n.status.account.displayName), n.status.account.emojis, R.drawable.ic_notifications_wght700fill1_20px);
+				titleItem=new ReblogOrReplyLineCustomStatusDisplayItem(n.getID(), this, getString(R.string.user_just_posted, n.status.account.displayName), n.status.account.emojis, R.drawable.ic_notifications_wght700fill1_20px);
 			else
 				titleItem=null;
 		}else{

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

@@ -0,0 +1,56 @@
+package org.joinmastodon.android.fragments;
+
+import android.app.Activity;
+import android.net.Uri;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.statuses.GetBookmarkedStatuses;
+import org.joinmastodon.android.events.RemoveAccountPostsEvent;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.HeaderPaginationList;
+import org.joinmastodon.android.model.Status;
+
+import me.grishka.appkit.api.SimpleCallback;
+
+public class BookmarkedStatusListFragment extends StatusListFragment{
+	private String nextMaxID;
+
+	@Override
+	public void onAttach(Activity activity){
+		super.onAttach(activity);
+		setTitle(R.string.bookmarks);
+		loadData();
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest=new GetBookmarkedStatuses(offset==0 ? null : nextMaxID, count)
+				.setCallback(new SimpleCallback<>(this){
+					@Override
+					public void onSuccess(HeaderPaginationList<Status> result){
+						if(getActivity()==null) return;
+						if(result.nextPageUri!=null)
+							nextMaxID=result.nextPageUri.getQueryParameter("max_id");
+						else
+							nextMaxID=null;
+						onDataLoaded(result, nextMaxID!=null);
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	protected void onRemoveAccountPostsEvent(RemoveAccountPostsEvent ev){
+		// no-op
+	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.ACCOUNT;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path("/bookmarks").build();
+	}
+}

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

@@ -1042,12 +1042,16 @@ public class ComposeFragment extends MastodonToolbarFragment implements ComposeE
 			case UNLISTED -> R.string.visibility_unlisted;
 			case PRIVATE -> R.string.visibility_followers_only;
 			case DIRECT -> R.string.visibility_private;
+			// MOSHIDON:
+			case LOCAL -> R.string.sk_local_only;
 		});
 		Drawable icon=getResources().getDrawable(switch(statusVisibility){
 			case PUBLIC -> R.drawable.ic_public_20px;
 			case UNLISTED -> R.drawable.ic_clear_night_20px;
 			case PRIVATE -> R.drawable.ic_group_20px;
 			case DIRECT -> R.drawable.ic_alternate_email_20px;
+			// MOSHIDON:
+			case LOCAL -> R.drawable.ic_fluent_eye_16_regular;
 		}, getActivity().getTheme()).mutate();
 		icon.setBounds(0, 0, V.dp(18), V.dp(18));
 		icon.setTint(UiUtils.getThemeColor(getActivity(), R.attr.colorM3Primary));

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

@@ -1,6 +1,7 @@
 package org.joinmastodon.android.fragments;
 
 import android.content.res.TypedArray;
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.Gravity;
 import android.view.LayoutInflater;
@@ -312,4 +313,11 @@ public class CreateListAddMembersFragment extends BaseAccountListFragment implem
 	protected void loadRelationships(List<AccountViewModel> accounts){
 		// no-op
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		// TODO this
+		return null;
+	}
 }

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

@@ -0,0 +1,100 @@
+package org.joinmastodon.android.fragments;
+
+import android.app.Activity;
+import android.net.Uri;
+import android.view.Menu;
+import android.view.MenuInflater;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.timelines.GetPublicTimeline;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.Status;
+import org.joinmastodon.android.model.TimelineDefinition;
+import org.joinmastodon.android.ui.utils.UiUtils;
+import org.joinmastodon.android.utils.ProvidesAssistContent;
+
+// MOSHIDON FIXME: readd the google pixel links goodness
+//import org.joinmastodon.android.utils.ProvidesAssistContent;
+
+import java.util.List;
+
+import me.grishka.appkit.api.SimpleCallback;
+
+public class CustomLocalTimelineFragment extends PinnableStatusListFragment implements ProvidesAssistContent.ProvidesWebUri{
+	//    private String name;
+	private String domain;
+
+	private String maxID;
+	@Override
+	protected boolean wantsComposeButton() {
+		return false;
+	}
+
+	@Override
+	public void onAttach(Activity activity){
+		super.onAttach(activity);
+		domain=getArguments().getString("domain");
+		updateTitle(domain);
+
+		setHasOptionsMenu(true);
+	}
+
+	private void updateTitle(String domain) {
+		this.domain = domain;
+		setTitle(this.domain);
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest=new GetPublicTimeline(true, false, refreshing ? null : maxID, null, count, null, getLocalPrefs().timelineReplyVisibility)
+				.setCallback(new SimpleCallback<>(this){
+					@Override
+					public void onSuccess(List<Status> result){
+						if(!result.isEmpty())
+							maxID=result.get(result.size()-1).id;
+						if (getActivity() == null) return;
+						AccountSessionManager.get(accountID).filterStatuses(result, FilterContext.PUBLIC);
+						result.stream().forEach(status -> {
+							status.account.acct += "@"+domain;
+							status.mentions.forEach(mention -> mention.id = null);
+							status.isRemote = true;
+						});
+
+						onDataLoaded(result, !result.isEmpty());
+					}
+				})
+				.execNoAuth(domain);
+	}
+
+	@Override
+	protected void onShown(){
+		super.onShown();
+		if(!getArguments().getBoolean("noAutoLoad") && !loaded && !dataLoading)
+			loadData();
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.custom_local_timelines, menu);
+		super.onCreateOptionsMenu(menu, inflater);
+	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.PUBLIC;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return new Uri.Builder()
+				.scheme("https")
+				.authority(domain)
+				.build();
+	}
+
+	@Override
+	protected TimelineDefinition makeTimelineDefinition() {
+		return TimelineDefinition.ofCustomLocalTimeline(domain);
+	}
+}

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

@@ -0,0 +1,513 @@
+package org.joinmastodon.android.fragments;
+
+import static android.view.Menu.NONE;
+import static com.hootsuite.nachos.terminator.ChipTerminatorHandler.BEHAVIOR_CHIPIFY_ALL;
+import static org.joinmastodon.android.ui.utils.UiUtils.makeBackItem;
+
+import android.annotation.SuppressLint;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.text.InputType;
+import android.text.TextUtils;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.SubMenu;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.PopupMenu;
+import android.widget.Switch;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.annotation.DrawableRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.ItemTouchHelper;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.hootsuite.nachos.NachoTextView;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.lists.GetLists;
+import org.joinmastodon.android.api.requests.tags.GetFollowedTags;
+import org.joinmastodon.android.api.session.AccountLocalPreferences;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.model.CustomLocalTimeline;
+import org.joinmastodon.android.model.FollowList;
+import org.joinmastodon.android.model.Hashtag;
+import org.joinmastodon.android.model.HeaderPaginationList;
+import org.joinmastodon.android.model.TimelineDefinition;
+import org.joinmastodon.android.ui.DividerItemDecoration;
+import org.joinmastodon.android.ui.M3AlertDialogBuilder;
+import org.joinmastodon.android.ui.utils.UiUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+import me.grishka.appkit.api.Callback;
+import me.grishka.appkit.api.ErrorResponse;
+import me.grishka.appkit.utils.BindableViewHolder;
+import me.grishka.appkit.utils.V;
+import me.grishka.appkit.views.UsableRecyclerView;
+
+public class EditTimelinesFragment extends MastodonRecyclerFragment<TimelineDefinition> implements ScrollableToTop{
+	private String accountID;
+	private TimelinesAdapter adapter;
+	private final ItemTouchHelper itemTouchHelper;
+	private Menu optionsMenu;
+	private boolean updated;
+	private final Map<MenuItem, TimelineDefinition> timelineByMenuItem=new HashMap<>();
+	private final List<FollowList> followLists =new ArrayList<>();
+	private final List<Hashtag> hashtags=new ArrayList<>();
+	private MenuItem addHashtagItem;
+	private final List<CustomLocalTimeline> localTimelines = new ArrayList<>();
+
+	public EditTimelinesFragment(){
+		super(10);
+		ItemTouchHelper.SimpleCallback itemTouchCallback=new ItemTouchHelperCallback();
+		itemTouchHelper=new ItemTouchHelper(itemTouchCallback);
+	}
+
+	@Override
+	public void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		setHasOptionsMenu(true);
+		setTitle(R.string.sk_timelines);
+		accountID=getArguments().getString("account");
+
+		new GetLists().setCallback(new Callback<>(){
+			@Override
+			public void onSuccess(List<FollowList> result){
+				followLists.addAll(result);
+				updateOptionsMenu();
+			}
+
+			@Override
+			public void onError(ErrorResponse error){
+				error.showToast(getContext());
+			}
+		}).exec(accountID);
+
+		new GetFollowedTags(null, 200).setCallback(new Callback<>(){
+			@Override
+			public void onSuccess(HeaderPaginationList<Hashtag> result){
+				hashtags.addAll(result);
+				updateOptionsMenu();
+			}
+
+			@Override
+			public void onError(ErrorResponse error){
+				error.showToast(getContext());
+			}
+		}).exec(accountID);
+	}
+
+	@Override
+	protected void onShown(){
+		super.onShown();
+		if(!getArguments().getBoolean("noAutoLoad") && !loaded && !dataLoading) loadData();
+	}
+
+	@Override
+	public void onViewCreated(View view, Bundle savedInstanceState){
+		super.onViewCreated(view, savedInstanceState);
+		itemTouchHelper.attachToRecyclerView(list);
+		refreshLayout.setEnabled(false);
+		list.addItemDecoration(new DividerItemDecoration(getActivity(), R.attr.colorM3OutlineVariant, 0.5f, 56, 16));
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater){
+		this.optionsMenu=menu;
+		updateOptionsMenu();
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item){
+		if(item.getItemId()==R.id.menu_back){
+			updateOptionsMenu();
+			optionsMenu.performIdentifierAction(R.id.menu_add_timeline, 0);
+			return true;
+		}
+		if (item.getItemId() == R.id.menu_add_local_timelines) {
+			addNewLocalTimeline();
+			return true;
+		}
+		TimelineDefinition tl = timelineByMenuItem.get(item);
+		if (tl != null) {
+			addTimeline(tl);
+		} else if (item == addHashtagItem) {
+			makeTimelineEditor(null, (hashtag) -> {
+				if (hashtag != null) addTimeline(hashtag);
+			}, null);
+		}
+		return true;
+	}
+
+	private void addTimeline(TimelineDefinition tl){
+		data.add(tl.copy());
+		adapter.notifyItemInserted(data.size());
+		saveTimelines();
+		updateOptionsMenu();
+	}
+
+	private void addNewLocalTimeline() {
+		FrameLayout inputWrap = new FrameLayout(getContext());
+		EditText input = new EditText(getContext());
+		input.setHint(R.string.sk_example_domain);
+		input.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI);
+		FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+		params.setMargins(V.dp(16), V.dp(4), V.dp(16), V.dp(16));
+		input.setLayoutParams(params);
+		inputWrap.addView(input);
+		new M3AlertDialogBuilder(getContext()).setTitle(R.string.mo_add_custom_server_local_timeline).setView(inputWrap)
+				.setPositiveButton(R.string.save, (d, which) -> {
+					TimelineDefinition tl = TimelineDefinition.ofCustomLocalTimeline(input.getText().toString().trim());
+					data.add(tl);
+					saveTimelines();
+				})
+				.setNegativeButton(R.string.cancel, (d, which) -> {
+				})
+				.show();
+	}
+
+	private void addTimelineToOptions(TimelineDefinition tl, Menu menu) {
+		if (data.contains(tl)) return;
+		MenuItem item = addOptionsItem(menu, tl.getTitle(getContext()), tl.getIcon().iconRes);
+		timelineByMenuItem.put(item, tl);
+	}
+
+	private MenuItem addOptionsItem(Menu menu, String name, @DrawableRes int icon){
+		MenuItem item=menu.add(0, View.generateViewId(), Menu.NONE, name);
+		item.setIcon(icon);
+		return item;
+	}
+
+	private void updateOptionsMenu(){
+		if(getActivity()==null) return;
+		optionsMenu.clear();
+		timelineByMenuItem.clear();
+
+		SubMenu menu=optionsMenu.addSubMenu(0, R.id.menu_add_timeline, NONE, R.string.sk_timelines_add);
+		menu.getItem().setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
+		menu.getItem().setIcon(R.drawable.ic_fluent_add_24_regular);
+
+		SubMenu timelinesMenu=menu.addSubMenu(R.string.sk_timeline);
+		timelinesMenu.getItem().setIcon(R.drawable.ic_fluent_timeline_24_regular);
+		SubMenu listsMenu=menu.addSubMenu(R.string.sk_list);
+		listsMenu.getItem().setIcon(R.drawable.ic_fluent_people_24_regular);
+		SubMenu hashtagsMenu=menu.addSubMenu(R.string.sk_hashtag);
+		hashtagsMenu.getItem().setIcon(R.drawable.ic_fluent_number_symbol_24_regular);
+
+		MenuItem addLocalTimelines = menu.add(0, R.id.menu_add_local_timelines, NONE, R.string.local_timeline);
+		addLocalTimelines.setIcon(R.drawable.ic_fluent_add_24_regular);
+
+		makeBackItem(timelinesMenu);
+		makeBackItem(listsMenu);
+		makeBackItem(hashtagsMenu);
+
+		TimelineDefinition.getAllTimelines(accountID).stream().forEach(tl->addTimelineToOptions(tl, timelinesMenu));
+		followLists.stream().map(TimelineDefinition::ofList).forEach(tl->addTimelineToOptions(tl, listsMenu));
+		addHashtagItem=addOptionsItem(hashtagsMenu, getContext().getString(R.string.sk_timelines_add), R.drawable.ic_fluent_add_24_regular);
+		hashtags.stream().map(TimelineDefinition::ofHashtag).forEach(tl->addTimelineToOptions(tl, hashtagsMenu));
+
+		timelinesMenu.getItem().setVisible(timelinesMenu.size()>0);
+		listsMenu.getItem().setVisible(listsMenu.size()>0);
+		hashtagsMenu.getItem().setVisible(hashtagsMenu.size()>0);
+
+		UiUtils.enableOptionsMenuIcons(getContext(), optionsMenu, R.id.menu_add_timeline);
+	}
+
+	private void saveTimelines(){
+		updated=true;
+		AccountLocalPreferences prefs=AccountSessionManager.get(accountID).getLocalPreferences();
+		if(data.isEmpty()) data.add(TimelineDefinition.HOME_TIMELINE);
+		prefs.timelines=data;
+		prefs.save();
+	}
+
+	private void removeTimeline(int position){
+		data.remove(position);
+		adapter.notifyItemRemoved(position);
+		saveTimelines();
+		updateOptionsMenu();
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		onDataLoaded(AccountSessionManager.get(accountID).getLocalPreferences().timelines);
+		updateOptionsMenu();
+	}
+
+	@Override
+	protected RecyclerView.Adapter<TimelineViewHolder> getAdapter(){
+		return adapter=new TimelinesAdapter();
+	}
+
+	@Override
+	public void scrollToTop(){
+		smoothScrollRecyclerViewToTop(list);
+	}
+
+	@Override
+	public void onDestroy(){
+		super.onDestroy();
+		if(updated) UiUtils.restartApp();
+	}
+
+	private boolean setTagListContent(NachoTextView editText, @Nullable List<String> tags){
+		if(tags==null || tags.isEmpty()) return false;
+		editText.setText(tags);
+		editText.chipifyAllUnterminatedTokens();
+		return true;
+	}
+
+	private NachoTextView prepareChipTextView(NachoTextView nacho){
+		//I’ll Be Back
+		nacho.setChipTerminators(
+				Map.of(
+						',', BEHAVIOR_CHIPIFY_ALL,
+						'\n', BEHAVIOR_CHIPIFY_ALL,
+						' ', BEHAVIOR_CHIPIFY_ALL,
+						';', BEHAVIOR_CHIPIFY_ALL
+				)
+		);
+		nacho.enableEditChipOnTouch(true, true);
+		nacho.setOnFocusChangeListener((v, hasFocus)->nacho.chipifyAllUnterminatedTokens());
+		return nacho;
+	}
+
+	@SuppressLint("ClickableViewAccessibility")
+	protected void makeTimelineEditor(@Nullable TimelineDefinition item, Consumer<TimelineDefinition> onSave, Runnable onRemove){
+		Context ctx=getContext();
+		View view=getActivity().getLayoutInflater().inflate(R.layout.edit_timeline, list, false);
+
+		View divider=view.findViewById(R.id.divider);
+		Button advancedBtn=view.findViewById(R.id.advanced);
+		EditText editText=view.findViewById(R.id.input);
+		if(item!=null) editText.setText(item.getCustomTitle());
+		editText.setHint(item!=null ? item.getDefaultTitle(ctx) : ctx.getString(R.string.sk_hashtag));
+
+		LinearLayout tagWrap=view.findViewById(R.id.tag_wrap);
+		boolean hashtagOptionsAvailable=item==null || item.getType()==TimelineDefinition.TimelineType.HASHTAG;
+		advancedBtn.setVisibility(hashtagOptionsAvailable ? View.VISIBLE : View.GONE);
+		advancedBtn.setOnClickListener(l->{
+			advancedBtn.setSelected(!advancedBtn.isSelected());
+			advancedBtn.setText(advancedBtn.isSelected() ? R.string.sk_advanced_options_hide : R.string.sk_advanced_options_show);
+			divider.setVisibility(advancedBtn.isSelected() ? View.VISIBLE : View.GONE);
+			tagWrap.setVisibility(advancedBtn.isSelected() ? View.VISIBLE : View.GONE);
+			UiUtils.beginLayoutTransition((ViewGroup) view);
+		});
+
+		Switch localOnlySwitch=view.findViewById(R.id.local_only_switch);
+		view.findViewById(R.id.local_only).setOnClickListener(l->localOnlySwitch.setChecked(!localOnlySwitch.isChecked()));
+
+		EditText tagMain=view.findViewById(R.id.tag_main);
+		NachoTextView tagsAny=prepareChipTextView(view.findViewById(R.id.tags_any));
+		NachoTextView tagsAll=prepareChipTextView(view.findViewById(R.id.tags_all));
+		NachoTextView tagsNone=prepareChipTextView(view.findViewById(R.id.tags_none));
+
+		if(item!=null && hashtagOptionsAvailable){
+			tagMain.setText(item.getHashtagName());
+			boolean hasAdvanced=!TextUtils.isEmpty(item.getCustomTitle()) && !Objects.equals(item.getHashtagName(), item.getCustomTitle());
+			hasAdvanced=setTagListContent(tagsAny, item.getHashtagAny()) || hasAdvanced;
+			hasAdvanced=setTagListContent(tagsAll, item.getHashtagAll()) || hasAdvanced;
+			hasAdvanced=setTagListContent(tagsNone, item.getHashtagNone()) || hasAdvanced;
+			if(item.isHashtagLocalOnly()){
+				localOnlySwitch.setChecked(true);
+				hasAdvanced=true;
+			}
+			if(hasAdvanced){
+				advancedBtn.setSelected(true);
+				advancedBtn.setText(R.string.sk_advanced_options_hide);
+				tagWrap.setVisibility(View.VISIBLE);
+				divider.setVisibility(View.VISIBLE);
+			}
+		}
+
+		ImageButton btn=view.findViewById(R.id.button);
+		PopupMenu popup=new PopupMenu(ctx, btn);
+		TimelineDefinition.Icon currentIcon=item!=null ? item.getIcon() : TimelineDefinition.Icon.HASHTAG;
+		btn.setImageResource(currentIcon.iconRes);
+		btn.setTag(currentIcon.ordinal());
+		btn.setContentDescription(ctx.getString(currentIcon.nameRes));
+		btn.setOnTouchListener(popup.getDragToOpenListener());
+		btn.setOnClickListener(l->popup.show());
+
+		Menu menu=popup.getMenu();
+		TimelineDefinition.Icon defaultIcon=item!=null ? item.getDefaultIcon() : TimelineDefinition.Icon.HASHTAG;
+		menu.add(0, currentIcon.ordinal(), NONE, currentIcon.nameRes).setIcon(currentIcon.iconRes);
+		if(!currentIcon.equals(defaultIcon)){
+			menu.add(0, defaultIcon.ordinal(), NONE, defaultIcon.nameRes).setIcon(defaultIcon.iconRes);
+		}
+		for(TimelineDefinition.Icon icon : TimelineDefinition.Icon.values()){
+			if(icon.hidden || icon.ordinal()==(int) btn.getTag()) continue;
+			menu.add(0, icon.ordinal(), NONE, icon.nameRes).setIcon(icon.iconRes);
+		}
+		UiUtils.enablePopupMenuIcons(ctx, popup);
+
+		popup.setOnMenuItemClickListener(menuItem->{
+			TimelineDefinition.Icon icon=TimelineDefinition.Icon.values()[menuItem.getItemId()];
+			btn.setImageResource(icon.iconRes);
+			btn.setTag(menuItem.getItemId());
+			btn.setContentDescription(ctx.getString(icon.nameRes));
+			return true;
+		});
+
+		AlertDialog.Builder builder=new M3AlertDialogBuilder(ctx)
+				.setTitle(item==null ? R.string.sk_add_timeline : R.string.sk_edit_timeline)
+				.setView(view)
+				.setPositiveButton(R.string.save, (d, which)->{
+					String name=editText.getText().toString().trim();
+
+					String mainHashtag=tagMain.getText().toString().trim();
+					if(item != null && item.getType()==TimelineDefinition.TimelineType.HASHTAG){
+						tagsAny.chipifyAllUnterminatedTokens();
+						tagsAll.chipifyAllUnterminatedTokens();
+						tagsNone.chipifyAllUnterminatedTokens();
+						if(TextUtils.isEmpty(mainHashtag)){
+							mainHashtag=name;
+							name=null;
+						}
+						if(TextUtils.isEmpty(mainHashtag) && (item!=null && item.getType()==TimelineDefinition.TimelineType.HASHTAG)){
+							Toast.makeText(ctx, R.string.sk_add_timeline_tag_error_empty, Toast.LENGTH_SHORT).show();
+							onSave.accept(null);
+							return;
+						}
+					}
+
+					TimelineDefinition tl=item!=null ? item : TimelineDefinition.ofHashtag(name);
+					TimelineDefinition.Icon icon=TimelineDefinition.Icon.values()[(int) btn.getTag()];
+					tl.setIcon(icon);
+					tl.setTitle(name);
+					if(item == null || item.getType()==TimelineDefinition.TimelineType.HASHTAG){
+						tl.setTagOptions(
+								TextUtils.isEmpty(mainHashtag) ? name : mainHashtag,
+								tagsAny.getChipValues(),
+								tagsAll.getChipValues(),
+								tagsNone.getChipValues(),
+								localOnlySwitch.isChecked()
+						);
+					}
+					onSave.accept(tl);
+				})
+				.setNegativeButton(R.string.cancel, (d, which)->{});
+
+		if(onRemove!=null) builder.setNeutralButton(R.string.sk_remove, (d, which)->onRemove.run());
+
+		builder.show();
+		btn.requestFocus();
+	}
+
+	private class TimelinesAdapter extends RecyclerView.Adapter<TimelineViewHolder>{
+		@NonNull
+		@Override
+		public TimelineViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType){
+			return new TimelineViewHolder();
+		}
+
+		@Override
+		public void onBindViewHolder(@NonNull TimelineViewHolder holder, int position){
+			holder.bind(data.get(position));
+		}
+
+		@Override
+		public int getItemCount(){
+			return data.size();
+		}
+	}
+
+	private class TimelineViewHolder extends BindableViewHolder<TimelineDefinition> implements UsableRecyclerView.Clickable{
+		private final TextView title;
+		private final ImageView dragger;
+
+		public TimelineViewHolder(){
+			super(getActivity(), R.layout.item_text, list);
+			title=findViewById(R.id.title);
+			dragger=findViewById(R.id.dragger_thingy);
+		}
+
+		@SuppressLint("ClickableViewAccessibility")
+		@Override
+		public void onBind(TimelineDefinition item){
+			title.setText(item.getTitle(getContext()));
+			title.setCompoundDrawablesRelativeWithIntrinsicBounds(itemView.getContext().getDrawable(item.getIcon().iconRes), null, null, null);
+			dragger.setVisibility(View.VISIBLE);
+			dragger.setOnTouchListener((View v, MotionEvent event)->{
+				if(event.getAction()==MotionEvent.ACTION_DOWN){
+					itemTouchHelper.startDrag(this);
+					return true;
+				}
+				return false;
+			});
+		}
+
+		private void onSave(TimelineDefinition tl){
+			saveTimelines();
+			rebind();
+		}
+
+		private void onRemove(){
+			removeTimeline(getAbsoluteAdapterPosition());
+		}
+
+		@SuppressLint("ClickableViewAccessibility")
+		@Override
+		public void onClick(){
+			makeTimelineEditor(item, this::onSave, this::onRemove);
+		}
+	}
+
+	private class ItemTouchHelperCallback extends ItemTouchHelper.SimpleCallback{
+		public ItemTouchHelperCallback(){
+			super(ItemTouchHelper.UP|ItemTouchHelper.DOWN, ItemTouchHelper.LEFT|ItemTouchHelper.RIGHT);
+		}
+
+		@Override
+		public boolean onMove(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder, @NonNull RecyclerView.ViewHolder target){
+			int fromPosition=viewHolder.getAbsoluteAdapterPosition();
+			int toPosition=target.getAbsoluteAdapterPosition();
+			if(Math.max(fromPosition, toPosition)>=data.size() || Math.min(fromPosition, toPosition)<0){
+				return false;
+			}else{
+				Collections.swap(data, fromPosition, toPosition);
+				adapter.notifyItemMoved(fromPosition, toPosition);
+				saveTimelines();
+				return true;
+			}
+		}
+
+		@Override
+		public void onSelectedChanged(@Nullable RecyclerView.ViewHolder viewHolder, int actionState){
+			if(actionState==ItemTouchHelper.ACTION_STATE_DRAG && viewHolder!=null){
+				viewHolder.itemView.animate().alpha(0.65f);
+			}
+		}
+
+		@Override
+		public void clearView(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder){
+			super.clearView(recyclerView, viewHolder);
+			viewHolder.itemView.animate().alpha(1f);
+		}
+
+		@Override
+		public void onSwiped(@NonNull RecyclerView.ViewHolder viewHolder, int direction){
+			int position=viewHolder.getAbsoluteAdapterPosition();
+			removeTimeline(position);
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+package org.joinmastodon.android.fragments;
+
+import android.app.Activity;
+import android.net.Uri;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.statuses.GetFavoritedStatuses;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.HeaderPaginationList;
+import org.joinmastodon.android.model.Status;
+
+import me.grishka.appkit.api.SimpleCallback;
+
+public class FavoritedStatusListFragment extends StatusListFragment{
+	private String nextMaxID;
+
+	@Override
+	public void onAttach(Activity activity){
+		super.onAttach(activity);
+		setTitle(R.string.your_favorites);
+		loadData();
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest=new GetFavoritedStatuses(offset==0 ? null : nextMaxID, count)
+				.setCallback(new SimpleCallback<>(this){
+					@Override
+					public void onSuccess(HeaderPaginationList<Status> result){
+						if(getActivity()==null) return;
+						if(result.nextPageUri!=null)
+							nextMaxID=result.nextPageUri.getQueryParameter("max_id");
+						else
+							nextMaxID=null;
+						onDataLoaded(result, nextMaxID!=null);
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.ACCOUNT;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.encodedPath(isInstanceAkkoma()
+				? '/' + getSession().self.username + "#favorites"
+				: "/favourites").build();
+	}
+}

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

@@ -2,6 +2,7 @@ package org.joinmastodon.android.fragments;
 
 import android.graphics.Canvas;
 import android.graphics.Paint;
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.View;
 
@@ -10,6 +11,7 @@ import org.joinmastodon.android.model.Account;
 import org.joinmastodon.android.model.Hashtag;
 import org.joinmastodon.android.ui.displayitems.HashtagStatusDisplayItem;
 import org.joinmastodon.android.ui.displayitems.StatusDisplayItem;
+import org.joinmastodon.android.ui.utils.UiUtils;
 import org.parceler.Parcels;
 
 import java.util.Collections;
@@ -18,7 +20,6 @@ import java.util.Objects;
 import java.util.stream.Collectors;
 
 import androidx.recyclerview.widget.RecyclerView;
-import me.grishka.appkit.Nav;
 
 public class FeaturedHashtagsListFragment extends BaseStatusListFragment<Hashtag>{
 	private Account account;
@@ -45,11 +46,7 @@ public class FeaturedHashtagsListFragment extends BaseStatusListFragment<Hashtag
 
 	@Override
 	public void onItemClick(String id){
-		Bundle args=new Bundle();
-		args.putParcelable("targetAccount", Parcels.wrap(account));
-		args.putParcelable("hashtag", Parcels.wrap(Objects.requireNonNull(findItemOfType(id, HashtagStatusDisplayItem.class)).tag));
-		args.putString("account", accountID);
-		Nav.go(getActivity(), HashtagFeaturedTimelineFragment.class, args);
+		UiUtils.openHashtagTimeline(getActivity(), accountID, Objects.requireNonNull(findItemOfType(id, HashtagStatusDisplayItem.class)).tag);
 	}
 
 	@Override
@@ -59,4 +56,9 @@ public class FeaturedHashtagsListFragment extends BaseStatusListFragment<Hashtag
 	protected void drawDivider(View child, View bottomSibling, RecyclerView.ViewHolder holder, RecyclerView.ViewHolder siblingHolder, RecyclerView parent, Canvas c, Paint paint){
 		// no-op
 	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null; // TODO
+	}
 }

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

@@ -0,0 +1,32 @@
+package org.joinmastodon.android.fragments;
+
+import org.joinmastodon.android.api.session.AccountLocalPreferences;
+import org.joinmastodon.android.api.session.AccountSession;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.model.Instance;
+
+import java.util.Optional;
+
+public interface HasAccountID {
+	String getAccountID();
+
+	default AccountSession getSession() {
+		return AccountSessionManager.getInstance().getAccount(getAccountID());
+	}
+
+	default boolean isInstanceAkkoma() {
+		return getInstance().map(Instance::isAkkoma).orElse(false);
+	}
+
+	default boolean isInstancePixelfed() {
+		return getInstance().map(Instance::isPixelfed).orElse(false);
+	}
+
+	default Optional<Instance> getInstance() {
+		return getSession().getInstance();
+	}
+
+	default AccountLocalPreferences getLocalPrefs() {
+		return AccountSessionManager.get(getAccountID()).getLocalPreferences();
+	}
+}

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

@@ -0,0 +1,7 @@
+package org.joinmastodon.android.fragments;
+
+import org.joinmastodon.android.utils.ElevationOnScrollListener;
+
+public interface HasElevationOnScrollListener {
+	ElevationOnScrollListener getElevationOnScrollListener();
+}

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

@@ -0,0 +1,10 @@
+package org.joinmastodon.android.fragments;
+
+import android.view.View;
+
+public interface HasFab {
+	View getFab();
+	void showFab();
+	void hideFab();
+	boolean isScrolling();
+}

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

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.api.requests.accounts.GetAccountStatuses;
@@ -44,4 +45,15 @@ public class HashtagFeaturedTimelineFragment extends StatusListFragment{
 				})
 				.exec(accountID);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null; // TODO
+	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return null;
+	}
 }

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

@@ -1,7 +1,7 @@
 package org.joinmastodon.android.fragments;
 
 import android.app.Activity;
-import android.content.res.TypedArray;
+import android.content.res.TypedArray;import android.net.Uri;
 import android.os.Bundle;
 import android.text.SpannableStringBuilder;
 import android.view.Menu;
@@ -118,7 +118,9 @@ public class HashtagTimelineFragment extends StatusListFragment{
 		});
 	}
 
-	private void onFabClick(View v){
+	// MOSHIDON:
+	@Override
+	public void onFabClick(View v){
 		Bundle args=new Bundle();
 		args.putString("account", accountID);
 		args.putString("prefilledText", '#'+hashtagName+' ');
@@ -279,4 +281,16 @@ public class HashtagTimelineFragment extends StatusListFragment{
 	public String getHashtagName(){
 		return hashtagName;
 	}
+
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.PUBLIC;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path((isInstanceAkkoma() ? "/tag/" : "/tags/") + hashtagName).build();
+	}
 }

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

@@ -60,7 +60,7 @@ import me.grishka.appkit.views.FragmentRootLinearLayout;
 
 public class HomeFragment extends AppKitFragment implements AssistContentProviderFragment{
 	private FragmentRootLinearLayout content;
-	private HomeTimelineFragment homeTimelineFragment;
+	private HomeTabFragment homeTabFragment;
 	private NotificationsListFragment notificationsFragment;
 	private DiscoverFragment searchFragment;
 	private ProfileFragment profileFragment;
@@ -85,8 +85,8 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 		if(savedInstanceState==null){
 			Bundle args=new Bundle();
 			args.putString("account", accountID);
-			homeTimelineFragment=new HomeTimelineFragment();
-			homeTimelineFragment.setArguments(args);
+			homeTabFragment=new HomeTabFragment();
+			homeTabFragment.setArguments(args);
 			args=new Bundle(args);
 			args.putBoolean("noAutoLoad", true);
 			searchFragment=new DiscoverFragment();
@@ -135,7 +135,7 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 
 		if(savedInstanceState==null){
 			getChildFragmentManager().beginTransaction()
-					.add(me.grishka.appkit.R.id.fragment_wrap, homeTimelineFragment)
+					.add(me.grishka.appkit.R.id.fragment_wrap, homeTabFragment)
 					.add(me.grishka.appkit.R.id.fragment_wrap, searchFragment).hide(searchFragment)
 					.add(me.grishka.appkit.R.id.fragment_wrap, notificationsFragment).hide(notificationsFragment)
 					.add(me.grishka.appkit.R.id.fragment_wrap, profileFragment).hide(profileFragment)
@@ -162,9 +162,9 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 	@Override
 	public void onViewStateRestored(Bundle savedInstanceState){
 		super.onViewStateRestored(savedInstanceState);
-		if(savedInstanceState==null || homeTimelineFragment!=null)
+		if(savedInstanceState==null || homeTabFragment!=null)
 			return;
-		homeTimelineFragment=(HomeTimelineFragment) getChildFragmentManager().getFragment(savedInstanceState, "homeTimelineFragment");
+		homeTabFragment=(HomeTabFragment) getChildFragmentManager().getFragment(savedInstanceState, "homeTimelineFragment");
 		searchFragment=(DiscoverFragment) getChildFragmentManager().getFragment(savedInstanceState, "searchFragment");
 		notificationsFragment=(NotificationsListFragment) getChildFragmentManager().getFragment(savedInstanceState, "notificationsFragment");
 		profileFragment=(ProfileFragment) getChildFragmentManager().getFragment(savedInstanceState, "profileFragment");
@@ -172,7 +172,7 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 		tabBar.selectTab(currentTab);
 		Fragment current=fragmentForTab(currentTab);
 		getChildFragmentManager().beginTransaction()
-				.hide(homeTimelineFragment)
+				.hide(homeTabFragment)
 				.hide(searchFragment)
 				.hide(notificationsFragment)
 				.hide(profileFragment)
@@ -207,7 +207,7 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 			super.onApplyWindowInsets(insets.replaceSystemWindowInsets(insets.getSystemWindowInsetLeft(), 0, insets.getSystemWindowInsetRight(), insets.getSystemWindowInsetBottom()));
 		}
 		WindowInsets topOnlyInsets=insets.replaceSystemWindowInsets(0, insets.getSystemWindowInsetTop(), 0, 0);
-		homeTimelineFragment.onApplyWindowInsets(topOnlyInsets);
+		homeTabFragment.onApplyWindowInsets(topOnlyInsets);
 		searchFragment.onApplyWindowInsets(topOnlyInsets);
 		notificationsFragment.onApplyWindowInsets(topOnlyInsets);
 		profileFragment.onApplyWindowInsets(topOnlyInsets);
@@ -215,7 +215,7 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 
 	private Fragment fragmentForTab(@IdRes int tab){
 		if(tab==R.id.tab_home){
-			return homeTimelineFragment;
+			return homeTabFragment;
 		}else if(tab==R.id.tab_search){
 			return searchFragment;
 		}else if(tab==R.id.tab_notifications){
@@ -235,6 +235,12 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 
 	private void onTabSelected(@IdRes int tab){
 		Fragment newFragment=fragmentForTab(tab);
+
+		// MOSHIDON:
+		if(tab==R.id.tab_search && R.id.tab_search==currentTab){
+			searchFragment.openSearch();
+		}
+
 		if(tab==currentTab){
 			if(newFragment instanceof ScrollableToTop scrollable)
 				scrollable.scrollToTop();
@@ -260,6 +266,17 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 	}
 
 	private boolean onTabLongClick(@IdRes int tab){
+		if(tab==R.id.tab_search){
+			if(currentTab!=R.id.tab_search){
+				// MOSHIDON: I don't know why using setCurrentTab leads to visual glitches
+				// when initially loading the fragment. This solves it somehow
+				onTabSelected(R.id.tab_search);
+				tabBar.selectTab(R.id.tab_search);
+			}
+			searchFragment.openSearch();
+			return true;
+		}
+
 		if(tab==R.id.tab_profile){
 			ArrayList<String> options=new ArrayList<>();
 			for(AccountSession session:AccountSessionManager.getInstance().getLoggedInAccounts()){
@@ -280,7 +297,7 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 	public void onSaveInstanceState(Bundle outState){
 		super.onSaveInstanceState(outState);
 		outState.putInt("selectedTab", currentTab);
-		getChildFragmentManager().putFragment(outState, "homeTimelineFragment", homeTimelineFragment);
+		getChildFragmentManager().putFragment(outState, "homeTimelineFragment", homeTabFragment);
 		getChildFragmentManager().putFragment(outState, "searchFragment", searchFragment);
 		getChildFragmentManager().putFragment(outState, "notificationsFragment", notificationsFragment);
 		getChildFragmentManager().putFragment(outState, "profileFragment", profileFragment);
@@ -375,8 +392,10 @@ public class HomeFragment extends AppKitFragment implements AssistContentProvide
 	public void onStatusDisplaySettingsChanged(StatusDisplaySettingsChangedEvent ev){
 		if(!ev.accountID.equals(accountID))
 			return;
-		if(homeTimelineFragment.loaded)
-			homeTimelineFragment.rebuildAllDisplayItems();
+
+		// FIXME: figure this out
+//		if(homeTabFragment.loaded)
+//			homeTabFragment.rebuildAllDisplayItems();
 		if(notificationsFragment.loaded)
 			notificationsFragment.rebuildAllDisplayItems();
 	}

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

@@ -0,0 +1,805 @@
+package org.joinmastodon.android.fragments;
+
+import static org.joinmastodon.android.GlobalUserPreferences.reduceMotion;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.Fragment;
+import android.app.FragmentTransaction;
+import android.app.assist.AssistContent;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.SubMenu;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.view.ViewTreeObserver;
+import android.widget.Button;
+import android.widget.FrameLayout;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.PopupMenu;
+import android.widget.TextView;
+import android.widget.Toolbar;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.viewpager2.widget.ViewPager2;
+
+import com.squareup.otto.Subscribe;
+
+import org.joinmastodon.android.E;
+import org.joinmastodon.android.GlobalUserPreferences;
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.announcements.GetAnnouncements;
+import org.joinmastodon.android.api.requests.lists.GetLists;
+import org.joinmastodon.android.api.requests.tags.GetFollowedTags;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.events.HashtagUpdatedEvent;
+import org.joinmastodon.android.events.ListCreatedEvent;
+import org.joinmastodon.android.events.ListDeletedEvent;
+import org.joinmastodon.android.events.ListUpdatedEvent;
+import org.joinmastodon.android.events.SelfUpdateStateChangedEvent;
+import org.joinmastodon.android.fragments.settings.SettingsMainFragment;
+import org.joinmastodon.android.model.Announcement;
+import org.joinmastodon.android.model.Hashtag;
+import org.joinmastodon.android.model.HeaderPaginationList;
+import org.joinmastodon.android.model.FollowList;
+import org.joinmastodon.android.model.StatusPrivacy;
+import org.joinmastodon.android.model.TimelineDefinition;
+import org.joinmastodon.android.model.viewmodel.ListItem;
+import org.joinmastodon.android.ui.ExtendedPopupMenu;
+import org.joinmastodon.android.ui.SimpleViewHolder;
+import org.joinmastodon.android.ui.utils.UiUtils;
+import org.joinmastodon.android.updater.GithubSelfUpdater;
+import org.joinmastodon.android.utils.ElevationOnScrollListener;
+import org.joinmastodon.android.utils.ProvidesAssistContent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+import me.grishka.appkit.Nav;
+import me.grishka.appkit.api.Callback;
+import me.grishka.appkit.api.ErrorResponse;
+import me.grishka.appkit.fragments.BaseRecyclerFragment;
+import me.grishka.appkit.utils.CubicBezierInterpolator;
+import me.grishka.appkit.utils.V;
+import me.grishka.appkit.views.FragmentRootLinearLayout;
+
+public class HomeTabFragment extends MastodonToolbarFragment implements ScrollableToTop, HasFab, ProvidesAssistContent, HasElevationOnScrollListener {
+	private static final int ANNOUNCEMENTS_RESULT = 654;
+
+	private String accountID;
+	private MenuItem announcements, announcementsAction, settings, settingsAction;
+	//	private ImageView toolbarLogo;
+	private Button toolbarShowNewPostsBtn;
+	private boolean newPostsBtnShown;
+	private AnimatorSet currentNewPostsAnim;
+	private ViewPager2 pager;
+	private View switcher;
+	private FrameLayout toolbarFrame;
+	private ImageView timelineIcon;
+	private ImageView collapsedChevron;
+	private TextView timelineTitle;
+	private PopupMenu switcherPopup;
+	private final Map<Integer, FollowList> listItems = new HashMap<>();
+	private final Map<Integer, Hashtag> hashtagsItems = new HashMap<>();
+	private List<TimelineDefinition> timelinesList;
+	private int count;
+	private Fragment[] fragments;
+	private FrameLayout[] tabViews;
+	private TimelineDefinition[] timelines;
+	private final Map<Integer, TimelineDefinition> timelinesByMenuItem = new HashMap<>();
+	private SubMenu hashtagsMenu, listsMenu;
+	private PopupMenu overflowPopup;
+	private View overflowActionView = null;
+	private boolean announcementsBadged, settingsBadged;
+	private ImageButton fab;
+	private ElevationOnScrollListener elevationOnScrollListener;
+
+	// TODO: rename this
+	private Runnable returnToBeginningOfPager=this::returnToBeginningOfPager;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		E.register(this);
+		accountID = getArguments().getString("account");
+		timelinesList=AccountSessionManager.get(accountID).getLocalPreferences().timelines;
+		assert timelinesList!=null;
+		if(timelinesList.isEmpty()) timelinesList=List.of(TimelineDefinition.HOME_TIMELINE);
+		count=timelinesList.size();
+		fragments=new Fragment[count];
+		tabViews=new FrameLayout[count];
+		timelines=new TimelineDefinition[count];
+		if(GlobalUserPreferences.toolbarMarquee){
+			setTitleMarqueeEnabled(false);
+			setSubtitleMarqueeEnabled(false);
+		}
+	}
+
+	private void returnToBeginningOfPager() {
+		pager.setCurrentItem(0);
+	}
+
+	@Override
+	public void onAttach(Activity activity) {
+		super.onAttach(activity);
+		setHasOptionsMenu(true);
+	}
+
+	@Override
+	public View onCreateContentView(LayoutInflater inflater, ViewGroup container, Bundle bundle) {
+		FragmentRootLinearLayout rootView = new FragmentRootLinearLayout(getContext());
+		rootView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+		FrameLayout view = new FrameLayout(getContext());
+		view.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+		rootView.addView(view);
+		inflater.inflate(R.layout.compose_fab, view);
+		fab = view.findViewById(R.id.fab);
+		fab.setOnClickListener(this::onFabClick);
+		fab.setOnLongClickListener(this::onFabLongClick);
+		pager = new ViewPager2(getContext());
+		toolbarFrame = (FrameLayout) LayoutInflater.from(getContext()).inflate(R.layout.home_toolbar, getToolbar(), false);
+
+		if (fragments[0] == null) {
+			Bundle args = new Bundle();
+			args.putString("account", accountID);
+			args.putBoolean("__is_tab", true);
+			args.putBoolean("__disable_fab", true);
+			args.putBoolean("onlyPosts", true);
+
+			for (int i=0; i < timelinesList.size(); i++) {
+				TimelineDefinition tl = timelinesList.get(i);
+				fragments[i] = tl.getFragment();
+				timelines[i] = tl;
+			}
+
+			FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
+			for (int i = 0; i < count; i++) {
+				fragments[i].setArguments(timelines[i].populateArguments(new Bundle(args)));
+				FrameLayout tabView = new FrameLayout(getActivity());
+				tabView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+				tabView.setVisibility(View.GONE);
+				tabView.setId(i + 1);
+				transaction.add(i + 1, fragments[i]);
+				view.addView(tabView);
+				tabViews[i] = tabView;
+			}
+			transaction.commit();
+		}
+
+		view.addView(pager, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+		overflowActionView = UiUtils.makeOverflowActionView(getContext());
+		overflowPopup = new PopupMenu(getContext(), overflowActionView);
+		overflowPopup.setOnMenuItemClickListener(this::onOptionsItemSelected);
+		overflowActionView.setOnClickListener(l -> overflowPopup.show());
+		overflowActionView.setOnTouchListener(overflowPopup.getDragToOpenListener());
+
+		return rootView;
+	}
+
+	@SuppressLint("ClickableViewAccessibility")
+	@Override
+	public void onViewCreated(View view, Bundle savedInstanceState){
+		super.onViewCreated(view, savedInstanceState);
+
+		timelineIcon = toolbarFrame.findViewById(R.id.timeline_icon);
+		timelineTitle = toolbarFrame.findViewById(R.id.timeline_title);
+		collapsedChevron = toolbarFrame.findViewById(R.id.collapsed_chevron);
+		switcher = toolbarFrame.findViewById(R.id.switcher_btn);
+		switcherPopup = new PopupMenu(getContext(), switcher);
+		switcherPopup.setOnMenuItemClickListener(this::onSwitcherItemSelected);
+		UiUtils.enablePopupMenuIcons(getContext(), switcherPopup);
+		switcher.setOnClickListener(v->switcherPopup.show());
+		switcher.setOnTouchListener(switcherPopup.getDragToOpenListener());
+		updateSwitcherMenu();
+
+		UiUtils.reduceSwipeSensitivity(pager);
+		pager.setUserInputEnabled(!GlobalUserPreferences.disableSwipe);
+		pager.setAdapter(new HomePagerAdapter());
+		pager.registerOnPageChangeCallback(new ViewPager2.OnPageChangeCallback() {
+			@Override
+			public void onPageSelected(int position){
+				if(position!=0) {
+					addBackCallback(returnToBeginningOfPager);
+				} else {
+					removeBackCallback(returnToBeginningOfPager);
+				}
+
+				if (!reduceMotion) {
+					// setting this here because page transformer appears to fire too late so the
+					// animation can appear bumpy, especially when navigating to a further-away tab
+					switcher.setScaleY(0.85f);
+					switcher.setScaleX(0.85f);
+					switcher.setAlpha(0.65f);
+				}
+				updateSwitcherIcon(position);
+				if (!timelines[position].equals(TimelineDefinition.HOME_TIMELINE)) hideNewPostsButton();
+				if (fragments[position] instanceof BaseRecyclerFragment<?> page){
+					if(!page.loaded && !page.isDataLoading()) page.loadData();
+				}
+			}
+		});
+
+		if (!reduceMotion) {
+			pager.setPageTransformer((v, pos) -> {
+				if (reduceMotion || tabViews[pager.getCurrentItem()] != v) return;
+				float scaleFactor = Math.max(0.85f, 1 - Math.abs(pos) * 0.06f);
+				switcher.setScaleY(scaleFactor);
+				switcher.setScaleX(scaleFactor);
+				switcher.setAlpha(Math.max(0.65f, 1 - Math.abs(pos)));
+			});
+		}
+
+		updateToolbarLogo();
+
+		ViewTreeObserver vto = getToolbar().getViewTreeObserver();
+		if (vto.isAlive()) {
+			vto.addOnGlobalLayoutListener(()->{
+				Toolbar t=getToolbar();
+				if(t==null) return;
+				int toolbarWidth=t.getWidth();
+				if(toolbarWidth==0) return;
+
+				int toolbarFrameWidth=toolbarFrame.getWidth();
+				int actionsWidth=toolbarWidth-toolbarFrameWidth;
+				// margin (4) + padding (12) + icon (24) + margin (8) + chevron (16) + padding (12)
+				int switcherWidth=V.dp(76);
+				FrameLayout parent=((FrameLayout) toolbarShowNewPostsBtn.getParent());
+				if(actionsWidth==parent.getPaddingStart()) return;
+				int paddingMax=Math.max(actionsWidth, switcherWidth);
+				int paddingEnd=(Math.max(0, switcherWidth-actionsWidth));
+
+				// toolbar frame goes from screen edge to beginning of right-aligned option buttons.
+				// centering button by applying the same space on the left
+				parent.setPaddingRelative(paddingMax, 0, paddingEnd, 0);
+				toolbarShowNewPostsBtn.setMaxWidth(toolbarWidth-paddingMax*2);
+
+				switcher.setPivotX(V.dp(28)); // padding + half of icon
+				switcher.setPivotY(switcher.getHeight() / 2f);
+			});
+		}
+
+		elevationOnScrollListener = new ElevationOnScrollListener((FragmentRootLinearLayout) view, getToolbar());
+
+		if(GithubSelfUpdater.needSelfUpdating()){
+			updateUpdateState(GithubSelfUpdater.getInstance().getState());
+		}
+
+		new GetLists().setCallback(new Callback<>() {
+			@Override
+			public void onSuccess(List<FollowList> lists) {
+				updateList(lists, listItems);
+			}
+
+			@Override
+			public void onError(ErrorResponse error) {
+				error.showToast(getContext());
+			}
+		}).exec(accountID);
+
+		new GetFollowedTags(null, 200).setCallback(new Callback<>() {
+			@Override
+			public void onSuccess(HeaderPaginationList<Hashtag> hashtags) {
+				updateList(hashtags, hashtagsItems);
+			}
+
+			@Override
+			public void onError(ErrorResponse error) {
+				error.showToast(getContext());
+			}
+		}).exec(accountID);
+
+		new GetAnnouncements(false).setCallback(new Callback<>() {
+			@Override
+			public void onSuccess(List<Announcement> result) {
+				if(getActivity()==null) return;
+				if (result.stream().anyMatch(a -> !a.read)) {
+					announcementsBadged = true;
+					announcements.setVisible(false);
+					announcementsAction.setVisible(true);
+				}
+			}
+
+			@Override
+			public void onError(ErrorResponse error) {
+				error.showToast(getActivity());
+			}
+		}).exec(accountID);
+	}
+
+	public ElevationOnScrollListener getElevationOnScrollListener() {
+		return elevationOnScrollListener;
+	}
+
+	private void onFabClick(View v){
+		if (fragments[pager.getCurrentItem()] instanceof BaseStatusListFragment<?> l) {
+			l.onFabClick(v);
+		}
+	}
+
+	private boolean onFabLongClick(View v) {
+		if (fragments[pager.getCurrentItem()] instanceof BaseStatusListFragment<?> l) {
+			return l.onFabLongClick(v);
+		} else {
+			return false;
+		}
+	}
+
+	private void addListsToOverflowMenu() {
+		Context ctx = getContext();
+		listsMenu.clear();
+		listsMenu.getItem().setVisible(listItems.size() > 0);
+		UiUtils.insetPopupMenuIcon(ctx, UiUtils.makeBackItem(listsMenu));
+		listItems.forEach((id, list) -> {
+			MenuItem item = listsMenu.add(Menu.NONE, id, Menu.NONE, list.title);
+			item.setIcon(R.drawable.ic_fluent_people_24_regular);
+			UiUtils.insetPopupMenuIcon(ctx, item);
+		});
+	}
+
+	private void addHashtagsToOverflowMenu() {
+		Context ctx = getContext();
+		hashtagsMenu.clear();
+		hashtagsMenu.getItem().setVisible(hashtagsItems.size() > 0);
+		UiUtils.insetPopupMenuIcon(ctx, UiUtils.makeBackItem(hashtagsMenu));
+		hashtagsItems.entrySet().stream()
+				.sorted(Comparator.comparing(x -> x.getValue().name, String.CASE_INSENSITIVE_ORDER))
+				.forEach(entry -> {
+					MenuItem item = hashtagsMenu.add(Menu.NONE, entry.getKey(), Menu.NONE, entry.getValue().name);
+					item.setIcon(R.drawable.ic_fluent_number_symbol_24_regular);
+					UiUtils.insetPopupMenuIcon(ctx, item);
+				});
+	}
+
+	public void updateToolbarLogo(){
+		Toolbar toolbar = getToolbar();
+		ViewParent parentView = toolbarFrame.getParent();
+		if (parentView == toolbar) return;
+		if (parentView instanceof Toolbar parentToolbar) parentToolbar.removeView(toolbarFrame);
+		toolbar.addView(toolbarFrame, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
+		toolbar.setOnClickListener(v->scrollToTop());
+		toolbar.setNavigationContentDescription(R.string.back);
+		toolbar.setContentInsetsAbsolute(0, toolbar.getContentInsetRight());
+
+		updateSwitcherIcon(pager.getCurrentItem());
+
+		toolbarShowNewPostsBtn=toolbarFrame.findViewById(R.id.show_new_posts_btn);
+		toolbarShowNewPostsBtn.setCompoundDrawableTintList(toolbarShowNewPostsBtn.getTextColors());
+		if(Build.VERSION.SDK_INT<Build.VERSION_CODES.N) UiUtils.fixCompoundDrawableTintOnAndroid6(toolbarShowNewPostsBtn);
+		toolbarShowNewPostsBtn.setOnClickListener(this::onNewPostsBtnClick);
+
+		if(newPostsBtnShown){
+			toolbarShowNewPostsBtn.setVisibility(View.VISIBLE);
+			collapsedChevron.setVisibility(View.VISIBLE);
+			collapsedChevron.setAlpha(1f);
+			timelineTitle.setVisibility(View.GONE);
+			timelineTitle.setAlpha(0f);
+		}else{
+			toolbarShowNewPostsBtn.setVisibility(View.INVISIBLE);
+			toolbarShowNewPostsBtn.setAlpha(0f);
+			collapsedChevron.setVisibility(View.GONE);
+			collapsedChevron.setAlpha(0f);
+			toolbarShowNewPostsBtn.setScaleX(.8f);
+			toolbarShowNewPostsBtn.setScaleY(.8f);
+			timelineTitle.setVisibility(View.VISIBLE);
+		}
+	}
+
+	private void updateOverflowMenu() {
+		if(getActivity()==null) return;
+		Menu m = overflowPopup.getMenu();
+		m.clear();
+		overflowPopup.inflate(R.menu.home_overflow);
+		announcements = m.findItem(R.id.announcements);
+		settings = m.findItem(R.id.settings);
+		hashtagsMenu = m.findItem(R.id.hashtags).getSubMenu();
+		listsMenu = m.findItem(R.id.lists).getSubMenu();
+
+//		announcements.setVisible(!announcementsBadged);
+//		announcementsAction.setVisible(announcementsBadged);
+//		settings.setVisible(!settingsBadged);
+//		settingsAction.setVisible(settingsBadged);
+
+		UiUtils.enablePopupMenuIcons(getContext(), overflowPopup);
+
+		addListsToOverflowMenu();
+		addHashtagsToOverflowMenu();
+
+		if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.P && !UiUtils.isEMUI() && !UiUtils.isMagic())
+			m.setGroupDividerEnabled(true);
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater){
+		inflater.inflate(R.menu.home, menu);
+
+//		menu.findItem(R.id.overflow).setActionView(overflowActionView);
+		announcementsAction = menu.findItem(R.id.announcements_action);
+		settingsAction = menu.findItem(R.id.settings_action);
+
+		updateOverflowMenu();
+	}
+
+	private <T> void updateList(List<T> addItems, Map<Integer, T> items) {
+		if (addItems.size() == 0 || getActivity() == null) return;
+		for (int i = 0; i < addItems.size(); i++) items.put(View.generateViewId(), addItems.get(i));
+		updateOverflowMenu();
+	}
+
+	private void updateSwitcherMenu() {
+		Menu switcherMenu = switcherPopup.getMenu();
+		switcherMenu.clear();
+		timelinesByMenuItem.clear();
+
+		for (TimelineDefinition tl : timelines) {
+			int menuItemId = View.generateViewId();
+			timelinesByMenuItem.put(menuItemId, tl);
+			MenuItem item = switcherMenu.add(0, menuItemId, 0, tl.getTitle(getContext()));
+			item.setIcon(tl.getIcon().iconRes);
+		}
+
+		UiUtils.enablePopupMenuIcons(getContext(), switcherPopup);
+	}
+
+	private boolean onSwitcherItemSelected(MenuItem item) {
+		int id = item.getItemId();
+
+		Bundle args = new Bundle();
+		args.putString("account", accountID);
+
+		if (id == R.id.menu_back) {
+			switcher.post(() -> switcherPopup.show());
+			return true;
+		}
+
+		TimelineDefinition tl = timelinesByMenuItem.get(id);
+		if (tl != null) {
+			for (int i = 0; i < timelines.length; i++) {
+				if (timelines[i] == tl) {
+					navigateTo(i);
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	private void navigateTo(int i) {
+		navigateTo(i, !reduceMotion);
+	}
+
+	private void navigateTo(int i, boolean smooth) {
+		pager.setCurrentItem(i, smooth);
+		updateSwitcherIcon(i);
+	}
+
+	@Override
+	public void showFab() {
+		if (fragments[pager.getCurrentItem()] instanceof BaseStatusListFragment<?> l) l.showFab();
+	}
+
+	@Override
+	public void hideFab() {
+		if (fragments[pager.getCurrentItem()] instanceof BaseStatusListFragment<?> l) l.hideFab();
+	}
+
+	@Override
+	public boolean isScrolling() {
+		return (fragments[pager.getCurrentItem()] instanceof HasFab fabulous)
+				&& fabulous.isScrolling();
+	}
+
+	@Override
+	public void onConfigurationChanged(Configuration newConfig) {
+		super.onConfigurationChanged(newConfig);
+		if (elevationOnScrollListener != null) elevationOnScrollListener.setViews(getToolbar());
+	}
+
+	private void updateSwitcherIcon(int i) {
+		timelineIcon.setImageResource(timelines[i].getIcon().iconRes);
+		timelineTitle.setText(timelines[i].getTitle(getContext()));
+		showFab();
+		if (elevationOnScrollListener != null && getCurrentFragment() instanceof IsOnTop f) {
+			// FIXME: make this work again
+//			elevationOnScrollListener.handleScroll(getContext(), f.isOnTop());
+		}
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item){
+		Bundle args=new Bundle();
+		args.putString("account", accountID);
+		int id = item.getItemId();
+		FollowList list;
+		Hashtag hashtag;
+
+		if (item.getItemId() == R.id.menu_back) {
+			getToolbar().post(() -> overflowPopup.show());
+			return true;
+		} else if (id == R.id.settings || id == R.id.settings_action) {
+			Nav.go(getActivity(), SettingsMainFragment.class, args);
+		} else if (id == R.id.announcements || id == R.id.announcements_action) {
+			Nav.goForResult(getActivity(), AnnouncementsFragment.class, args, ANNOUNCEMENTS_RESULT, this);
+		} else if (id == R.id.edit_timelines) {
+			Nav.go(getActivity(), EditTimelinesFragment.class, args);
+		} else if ((list = listItems.get(id)) != null) {
+			args.putString("listID", list.id);
+			args.putString("listTitle", list.title);
+			args.putBoolean("listIsExclusive", list.exclusive);
+			if (list.repliesPolicy != null) args.putInt("repliesPolicy", list.repliesPolicy.ordinal());
+			Nav.go(getActivity(), ListTimelineFragment.class, args);
+		} else if ((hashtag = hashtagsItems.get(id)) != null) {
+			UiUtils.openHashtagTimeline(getContext(), accountID, hashtag);
+		}
+		return true;
+	}
+
+	@Override
+	public void scrollToTop(){
+		if (((IsOnTop) fragments[pager.getCurrentItem()]).isOnTop() &&
+				GlobalUserPreferences.doubleTapToSwipe && !newPostsBtnShown) {
+			int nextPage = (pager.getCurrentItem() + 1) % count;
+			navigateTo(nextPage);
+			return;
+		}
+		((ScrollableToTop) fragments[pager.getCurrentItem()]).scrollToTop();
+	}
+
+	public void hideNewPostsButton(){
+		if(!newPostsBtnShown)
+			return;
+		newPostsBtnShown=false;
+		if(currentNewPostsAnim!=null){
+			currentNewPostsAnim.cancel();
+		}
+		timelineTitle.setVisibility(View.VISIBLE);
+		AnimatorSet set=new AnimatorSet();
+		set.playTogether(
+				ObjectAnimator.ofFloat(timelineTitle, View.ALPHA, 1f),
+				ObjectAnimator.ofFloat(timelineTitle, View.SCALE_X, 1f),
+				ObjectAnimator.ofFloat(timelineTitle, View.SCALE_Y, 1f),
+				ObjectAnimator.ofFloat(toolbarShowNewPostsBtn, View.ALPHA, 0f),
+				ObjectAnimator.ofFloat(toolbarShowNewPostsBtn, View.SCALE_X, .8f),
+				ObjectAnimator.ofFloat(toolbarShowNewPostsBtn, View.SCALE_Y, .8f),
+				ObjectAnimator.ofFloat(collapsedChevron, View.ALPHA, 0f)
+		);
+		set.setDuration(reduceMotion ? 0 : 300);
+		set.setInterpolator(CubicBezierInterpolator.DEFAULT);
+		set.addListener(new AnimatorListenerAdapter(){
+			@Override
+			public void onAnimationEnd(Animator animation){
+				toolbarShowNewPostsBtn.setVisibility(View.INVISIBLE);
+				collapsedChevron.setVisibility(View.GONE);
+				currentNewPostsAnim=null;
+			}
+		});
+		currentNewPostsAnim=set;
+		set.start();
+	}
+
+	public void showNewPostsButton(){
+		if(newPostsBtnShown || pager == null || !timelines[pager.getCurrentItem()].equals(TimelineDefinition.HOME_TIMELINE))
+			return;
+		newPostsBtnShown=true;
+		if(currentNewPostsAnim!=null){
+			currentNewPostsAnim.cancel();
+		}
+		toolbarShowNewPostsBtn.setVisibility(View.VISIBLE);
+		collapsedChevron.setVisibility(View.VISIBLE);
+		AnimatorSet set=new AnimatorSet();
+		set.playTogether(
+				ObjectAnimator.ofFloat(timelineTitle, View.ALPHA, 0f),
+				ObjectAnimator.ofFloat(timelineTitle, View.SCALE_X, .8f),
+				ObjectAnimator.ofFloat(timelineTitle, View.SCALE_Y, .8f),
+				ObjectAnimator.ofFloat(toolbarShowNewPostsBtn, View.ALPHA, 1f),
+				ObjectAnimator.ofFloat(toolbarShowNewPostsBtn, View.SCALE_X, 1f),
+				ObjectAnimator.ofFloat(toolbarShowNewPostsBtn, View.SCALE_Y, 1f),
+				ObjectAnimator.ofFloat(collapsedChevron, View.ALPHA, 1f)
+		);
+		set.setDuration(reduceMotion ? 0 : 300);
+		set.setInterpolator(CubicBezierInterpolator.DEFAULT);
+		set.addListener(new AnimatorListenerAdapter(){
+			@Override
+			public void onAnimationEnd(Animator animation){
+				timelineTitle.setVisibility(View.GONE);
+				currentNewPostsAnim=null;
+			}
+		});
+		currentNewPostsAnim=set;
+		set.start();
+	}
+
+	public boolean isNewPostsBtnShown() {
+		return newPostsBtnShown;
+	}
+
+	private void onNewPostsBtnClick(View view) {
+		if(newPostsBtnShown){
+			scrollToTop();
+			hideNewPostsButton();
+		}
+	}
+
+	@Override
+	public void onFragmentResult(int reqCode, boolean success, Bundle result){
+		if (reqCode == ANNOUNCEMENTS_RESULT && success) {
+			announcementsBadged = false;
+			announcements.setVisible(true);
+			announcementsAction.setVisible(false);
+		}
+	}
+
+	private void updateUpdateState(GithubSelfUpdater.UpdateState state){
+		if(state!=GithubSelfUpdater.UpdateState.NO_UPDATE && state!=GithubSelfUpdater.UpdateState.CHECKING) {
+			settingsBadged = true;
+			settingsAction.setVisible(true);
+			settings.setVisible(false);
+		}
+	}
+
+	@Subscribe
+	public void onSelfUpdateStateChanged(SelfUpdateStateChangedEvent ev){
+		updateUpdateState(ev.state);
+	}
+
+//	@Override
+//	public boolean onBackPressed(){
+//		if(pager.getCurrentItem() > 0){
+//			navigateTo(0);
+//			return true;
+//		}
+//		return false;
+//	}
+
+	@Override
+	public void onDestroyView(){
+		super.onDestroyView();
+		if (overflowPopup != null) {
+			overflowPopup.dismiss();
+			overflowPopup = null;
+		}
+		if (switcherPopup != null) {
+			switcherPopup.dismiss();
+			switcherPopup = null;
+		}
+		if(GithubSelfUpdater.needSelfUpdating()){
+			E.unregister(this);
+		}
+	}
+
+	@Override
+	protected void onShown() {
+		super.onShown();
+		Object timelines = AccountSessionManager.get(accountID).getLocalPreferences().timelines;
+		if (timelines != null && timelinesList!= timelines) UiUtils.restartApp();
+	}
+
+	@Override
+	public void onViewStateRestored(Bundle savedInstanceState) {
+		super.onViewStateRestored(savedInstanceState);
+		if (savedInstanceState == null) return;
+		navigateTo(savedInstanceState.getInt("selectedTab"), false);
+	}
+
+	@Override
+	public void onSaveInstanceState(Bundle outState) {
+		super.onSaveInstanceState(outState);
+		outState.putInt("selectedTab", pager.getCurrentItem());
+	}
+
+	@Subscribe
+	public void onHashtagUpdatedEvent(HashtagUpdatedEvent event) {
+		handleListEvent(hashtagsItems, h -> h.name.equalsIgnoreCase(event.name), event.following, () -> {
+			Hashtag hashtag = new Hashtag();
+			hashtag.name = event.name;
+			hashtag.following = true;
+			return hashtag;
+		});
+	}
+
+	@Subscribe
+	public void onListDeletedEvent(ListDeletedEvent event) {
+		handleListEvent(listItems, l -> l.id.equals(event.listID), false, null);
+	}
+
+	@Subscribe
+	public void onListCreatedEvent(ListCreatedEvent event) {
+		handleListEvent(listItems, l -> l.id.equals(event.list.id), true, () -> {
+			FollowList list = new FollowList();
+			list.id = event.list.id;
+			list.title = event.list.title;
+			list.repliesPolicy = event.list.repliesPolicy;
+			return list;
+		});
+	}
+
+	private <T> void handleListEvent(
+			Map<Integer, T> existingThings,
+			Predicate<T> matchExisting,
+			boolean shouldBeInList,
+			Supplier<T> makeNewThing
+	) {
+		Optional<Map.Entry<Integer, T>> existingThing = existingThings.entrySet().stream()
+				.filter(e -> matchExisting.test(e.getValue())).findFirst();
+		if (shouldBeInList) {
+			existingThings.put(existingThing.isPresent()
+					? existingThing.get().getKey() : View.generateViewId(), makeNewThing.get());
+			updateOverflowMenu();
+		} else if (existingThing.isPresent() && !shouldBeInList) {
+			existingThings.remove(existingThing.get().getKey());
+			updateOverflowMenu();
+		}
+	}
+
+//	public void rebuildAllDisplayItems(){
+//		displayItems.clear();
+//		for(T item:data){
+//			displayItems.addAll(buildDisplayItems(item));
+//		}
+//		adapter.notifyDataSetChanged();
+//	}
+
+	public Collection<Hashtag> getHashtags() {
+		return hashtagsItems.values();
+	}
+
+	public Fragment getCurrentFragment() {
+		return fragments[pager.getCurrentItem()];
+	}
+
+	public ImageButton getFab() {
+		return fab;
+	}
+
+	@Override
+	public void onProvideAssistContent(AssistContent assistContent) {
+		callFragmentToProvideAssistContent(fragments[pager.getCurrentItem()], assistContent);
+	}
+
+	private class HomePagerAdapter extends RecyclerView.Adapter<SimpleViewHolder> {
+		@NonNull
+		@Override
+		public SimpleViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+			FrameLayout tabView = tabViews[viewType % getItemCount()];
+			ViewGroup tabParent = (ViewGroup) tabView.getParent();
+			if (tabParent != null) tabParent.removeView(tabView);
+			tabView.setVisibility(View.VISIBLE);
+			return new SimpleViewHolder(tabView);
+		}
+
+		@Override
+		public void onBindViewHolder(@NonNull SimpleViewHolder holder, int position){}
+
+		@Override
+		public int getItemCount(){
+			return count;
+		}
+
+		@Override
+		public int getItemViewType(int position){
+			return position;
+		}
+	}
+}

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

@@ -0,0 +1,13 @@
+package org.joinmastodon.android.fragments;
+
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.RecyclerView;
+
+public interface IsOnTop {
+	boolean isOnTop();
+
+	default boolean isRecyclerViewOnTop(@Nullable RecyclerView list) {
+		if (list == null) return true;
+		return !list.canScrollVertically(-1);
+	}
+}

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

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments;
 
+import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.view.ActionMode;
@@ -401,4 +402,10 @@ public class ListMembersFragment extends PaginatedAccountListFragment implements
 	protected void setNavigationBarColor(int color){
 		rootView.setNavigationBarColor(color);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null;
+	}
 }

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

@@ -0,0 +1,178 @@
+package org.joinmastodon.android.fragments;
+
+import android.app.Activity;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.Nullable;
+
+import org.joinmastodon.android.E;
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.lists.GetList;
+import org.joinmastodon.android.api.requests.timelines.GetListTimeline;
+import org.joinmastodon.android.api.requests.lists.UpdateList;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.events.ListDeletedEvent;
+import org.joinmastodon.android.events.ListUpdatedCreatedEvent;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.FollowList;
+import org.joinmastodon.android.model.Status;
+import org.joinmastodon.android.model.TimelineDefinition;
+import org.joinmastodon.android.ui.M3AlertDialogBuilder;
+import org.joinmastodon.android.ui.utils.UiUtils;
+import org.joinmastodon.android.ui.views.ListEditor;
+
+import java.util.List;
+
+import me.grishka.appkit.Nav;
+import me.grishka.appkit.api.Callback;
+import me.grishka.appkit.api.ErrorResponse;
+import me.grishka.appkit.api.SimpleCallback;
+import me.grishka.appkit.utils.V;
+
+public class ListTimelineCustomFragment extends PinnableStatusListFragment {
+	private String listID;
+	private String listTitle;
+	@Nullable
+	private FollowList.RepliesPolicy repliesPolicy;
+	private boolean exclusive;
+
+	@Override
+	protected boolean wantsComposeButton() {
+		return true;
+	}
+
+	@Override
+	public void onAttach(Activity activity){
+		super.onAttach(activity);
+		Bundle args = getArguments();
+		listID = args.getString("listID");
+		listTitle = args.getString("listTitle");
+		exclusive = args.getBoolean("listIsExclusive");
+		repliesPolicy = FollowList.RepliesPolicy.values()[args.getInt("repliesPolicy", 0)];
+
+		setTitle(listTitle);
+		setHasOptionsMenu(true);
+
+		new GetList(listID).setCallback(new Callback<>() {
+			@Override
+			public void onSuccess(FollowList followList) {
+				if(getActivity()==null) return;
+				// TODO: save updated info
+				if (!followList.title.equals(listTitle)) setTitle(followList.title);
+				if (followList.repliesPolicy != null && !followList.repliesPolicy.equals(repliesPolicy)) {
+					repliesPolicy = followList.repliesPolicy;
+				}
+			}
+
+			@Override
+			public void onError(ErrorResponse error) {
+				error.showToast(getContext());
+			}
+		});
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.list, menu);
+		super.onCreateOptionsMenu(menu, inflater);
+		UiUtils.enableOptionsMenuIcons(getContext(), menu, R.id.pin);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		if (super.onOptionsItemSelected(item)) return true;
+		if (item.getItemId() == R.id.edit) {
+			ListEditor editor = new ListEditor(getContext());
+			editor.applyList(listTitle, exclusive, repliesPolicy);
+			new M3AlertDialogBuilder(getActivity())
+					.setTitle(R.string.sk_edit_list_title)
+					.setIcon(R.drawable.ic_fluent_people_28_regular)
+					.setView(editor)
+					.setPositiveButton(R.string.save, (d, which) -> {
+						String newTitle = editor.getTitle().trim();
+						setTitle(newTitle);
+						new UpdateList(listID, newTitle, editor.getRepliesPolicy(), editor.isExclusive()).setCallback(new Callback<>() {
+							@Override
+							public void onSuccess(FollowList list) {
+								if(getActivity()==null) return;
+								setTitle(list.title);
+								listTitle = list.title;
+								repliesPolicy = list.repliesPolicy;
+								exclusive = list.exclusive;
+								E.post(new ListUpdatedCreatedEvent(listID, listTitle, exclusive, repliesPolicy));
+							}
+
+							@Override
+							public void onError(ErrorResponse error) {
+								setTitle(listTitle);
+								error.showToast(getContext());
+							}
+						}).exec(accountID);
+					})
+					.setNegativeButton(R.string.cancel, (d, which) -> {})
+					.show();
+		} else if (item.getItemId() == R.id.delete) {
+			UiUtils.confirmDeleteList(getActivity(), accountID, listID, listTitle, () -> {
+				E.post(new ListDeletedEvent(accountID, listID));
+				Nav.finish(this);
+			});
+		}
+		return true;
+	}
+
+	@Override
+	protected TimelineDefinition makeTimelineDefinition() {
+		return TimelineDefinition.ofList(listID, listTitle, exclusive);
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count) {
+		currentRequest=new GetListTimeline(listID, getMaxID(), null, count, null, getLocalPrefs().timelineReplyVisibility)
+				.setCallback(new SimpleCallback<>(this) {
+					@Override
+					public void onSuccess(List<Status> result) {
+						if(getActivity()==null) return;
+						boolean more=applyMaxID(result);
+						AccountSessionManager.get(accountID).filterStatuses(result, getFilterContext());
+						onDataLoaded(result, more);
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	protected void onShown() {
+		super.onShown();
+		if(!getArguments().getBoolean("noAutoLoad") && !loaded && !dataLoading)
+			loadData();
+	}
+
+	@Override
+	public void onFabClick(View v){
+		Bundle args=new Bundle();
+		args.putString("account", accountID);
+		Nav.go(getActivity(), ComposeFragment.class, args);
+	}
+
+	@Override
+	protected void onSetFabBottomInset(int inset) {
+		((ViewGroup.MarginLayoutParams) fab.getLayoutParams()).bottomMargin=V.dp(24)+inset;
+	}
+
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.HOME;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path("/lists/" + listID).build();
+	}
+}

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

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments;
 
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -7,6 +8,7 @@ import android.view.MenuItem;
 
 import org.joinmastodon.android.R;
 import org.joinmastodon.android.api.requests.timelines.GetListTimeline;
+import org.joinmastodon.android.model.FilterContext;
 import org.joinmastodon.android.model.FollowList;
 import org.joinmastodon.android.model.Status;
 import org.parceler.Parcels;
@@ -58,4 +60,16 @@ public class ListTimelineFragment extends StatusListFragment{
 		}
 		return true;
 	}
+
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.HOME;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path("/lists/" + followList.id).build();
+	}
 }

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

@@ -6,6 +6,7 @@ import android.app.Dialog;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
+import android.net.Uri;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.view.Menu;
@@ -403,4 +404,12 @@ public class NotificationsListFragment extends BaseNotificationsListFragment{
 		args.putString("account", accountID);
 		Nav.go(getActivity(), NotificationRequestsFragment.class, args);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path(isInstanceAkkoma()
+				? "/users/" + getSession().self.username + "/interactions"
+				: "/notifications").build();
+	}
 }

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

@@ -0,0 +1,71 @@
+package org.joinmastodon.android.fragments;
+
+import android.os.Bundle;
+import android.view.HapticFeedbackConstants;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.widget.Toast;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.session.AccountLocalPreferences;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.model.TimelineDefinition;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class PinnableStatusListFragment extends StatusListFragment {
+    protected List<TimelineDefinition> timelines;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        timelines=new ArrayList<>(AccountSessionManager.get(accountID).getLocalPreferences().timelines);
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        super.onCreateOptionsMenu(menu, inflater);
+        updatePinButton(menu.findItem(R.id.pin));
+    }
+
+    protected boolean isPinned() {
+        return timelines.contains(makeTimelineDefinition());
+    }
+
+    protected void updatePinButton(MenuItem pin) {
+        boolean pinned = isPinned();
+        pin.setIcon(pinned ?
+                R.drawable.ic_fluent_pin_24_filled :
+                R.drawable.ic_fluent_pin_24_regular);
+        pin.setTitle(pinned ? R.string.sk_unpin_timeline : R.string.sk_pin_timeline);
+    }
+
+    protected abstract TimelineDefinition makeTimelineDefinition();
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        if (item.getItemId() == R.id.pin) {
+            togglePin(item);
+            return true;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    protected void togglePin(MenuItem pin) {
+        onPinnedUpdated(true);
+        getToolbar().performHapticFeedback(HapticFeedbackConstants.CONTEXT_CLICK);
+        TimelineDefinition def = makeTimelineDefinition();
+        boolean pinned = isPinned();
+        if (pinned) timelines.remove(def);
+        else timelines.add(def);
+        Toast.makeText(getContext(), pinned ? R.string.sk_unpinned_timeline : R.string.sk_pinned_timeline, Toast.LENGTH_SHORT).show();
+		AccountLocalPreferences prefs=AccountSessionManager.get(accountID).getLocalPreferences();
+		prefs.timelines=new ArrayList<>(timelines);
+        prefs.save();
+        updatePinButton(pin);
+    }
+
+    public void onPinnedUpdated(boolean pinned) {}
+}

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

@@ -1,10 +1,12 @@
 package org.joinmastodon.android.fragments;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.R;
 import org.joinmastodon.android.api.requests.accounts.GetAccountStatuses;
 import org.joinmastodon.android.model.Account;
+import org.joinmastodon.android.model.FilterContext;
 import org.joinmastodon.android.model.Status;
 import org.parceler.Parcels;
 
@@ -33,4 +35,15 @@ public class PinnedPostsListFragment extends StatusListFragment{
 					}
 				}).exec(accountID);
 	}
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.ACCOUNT;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return Uri.parse(account.url);
+	}
 }

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

@@ -2,6 +2,7 @@ package org.joinmastodon.android.fragments;
 
 import android.graphics.Canvas;
 import android.graphics.Paint;
+import android.net.Uri;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.view.View;
@@ -207,4 +208,10 @@ public class ProfileFeaturedFragment extends BaseStatusListFragment<SearchResult
 	private void showAllEndorsedAccounts(){
 
 	}
+
+	// MOSHIDON: FIXME: this should be doing something
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null;
+	}
 }

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

@@ -20,6 +20,7 @@ import android.graphics.drawable.LayerDrawable;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
+import android.text.InputType;
 import android.text.SpannableString;
 import android.text.SpannableStringBuilder;
 import android.text.TextUtils;
@@ -50,11 +51,13 @@ import android.widget.Toolbar;
 
 import org.joinmastodon.android.GlobalUserPreferences;
 import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.MastodonAPIRequest;
 import org.joinmastodon.android.api.requests.accounts.GetAccountByID;
 import org.joinmastodon.android.api.requests.accounts.GetAccountFamiliarFollowers;
 import org.joinmastodon.android.api.requests.accounts.GetAccountRelationships;
 import org.joinmastodon.android.api.requests.accounts.GetOwnAccount;
 import org.joinmastodon.android.api.requests.accounts.SetAccountFollowed;
+import org.joinmastodon.android.api.requests.accounts.SetPrivateNote;
 import org.joinmastodon.android.api.requests.accounts.UpdateAccountCredentials;
 import org.joinmastodon.android.api.session.AccountSessionManager;
 import org.joinmastodon.android.fragments.account_list.FamiliarFollowerListFragment;
@@ -95,6 +98,7 @@ import java.time.format.DateTimeFormatter;
 import java.time.format.FormatStyle;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -104,6 +108,7 @@ import androidx.recyclerview.widget.RecyclerView;
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
 import androidx.viewpager2.widget.ViewPager2;
 import me.grishka.appkit.Nav;
+import me.grishka.appkit.api.APIRequest;
 import me.grishka.appkit.api.Callback;
 import me.grishka.appkit.api.ErrorResponse;
 import me.grishka.appkit.api.SimpleCallback;
@@ -172,6 +177,11 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 	private MenuItem editSaveMenuItem;
 	private boolean savingEdits;
 	private Runnable editModeBackCallback=this::onEditModeBackCallback;
+	private HashSet<APIRequest<?>> relationshipRequests=new HashSet<>();
+
+	// MOSHIDON: profile note
+	private FrameLayout noteWrap;
+	private EditText noteEdit;
 
 	@Override
 	public void onCreate(Bundle savedInstanceState){
@@ -200,6 +210,14 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 		setHasOptionsMenu(true);
 	}
 
+	@Override
+	public void onDestroy(){
+		super.onDestroy();
+		for(APIRequest<?> req:relationshipRequests)
+			req.cancel();
+		relationshipRequests.clear();
+	}
+
 	@Override
 	public View onCreateContentView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState){
 		View content=inflater.inflate(R.layout.fragment_profile, container, false);
@@ -247,6 +265,19 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 		avatar.setOutlineProvider(OutlineProviders.roundedRect(24));
 		avatar.setClipToOutline(true);
 
+		noteEdit=content.findViewById(R.id.note_edit);
+		noteWrap=content.findViewById(R.id.note_edit_wrap);
+
+		noteEdit.setOnFocusChangeListener((v, hasFocus)->{
+			if(hasFocus){
+//				hideFab();
+				noteEdit.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_MULTI_LINE | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
+			}else{
+//				showFab();
+				savePrivateNote(noteEdit.getText().toString());
+			}
+		});
+
 		FrameLayout sizeWrapper=new FrameLayout(getActivity()){
 			@Override
 			protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
@@ -416,9 +447,45 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 		if(refreshing)
 			return;
 		refreshing=true;
+
+		// MOSHIDON: save private note on refresh
+		if(!isOwnProfile){
+			savePrivateNote(noteEdit.getText().toString());
+		}
+
 		doLoadData();
 	}
 
+	private void showPrivateNote(){
+		noteWrap.setVisibility(View.VISIBLE);
+		noteEdit.setText(relationship.note);
+	}
+
+	private void hidePrivateNote(){
+		noteWrap.setVisibility(View.GONE);
+		noteEdit.setText(null);
+	}
+
+	private void savePrivateNote(String note){
+		if(note!=null && note.equals(relationship.note)){
+			updateRelationship();
+			invalidateOptionsMenu();
+			return;
+		}
+		new SetPrivateNote(profileAccountID, note).setCallback(new Callback<>() {
+			@Override
+			public void onSuccess(Relationship result) {
+				updateRelationship(result);
+				invalidateOptionsMenu();
+			}
+
+			@Override
+			public void onError(ErrorResponse error) {
+				error.showToast(getContext());
+			}
+		}).exec(accountID);
+	}
+
 	@Override
 	public void dataLoaded(){
 		if(getActivity()==null)
@@ -801,10 +868,13 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 	}
 
 	private void loadRelationship(){
-		new GetAccountRelationships(Collections.singletonList(account.id))
-				.setCallback(new Callback<>(){
+		MastodonAPIRequest<List<Relationship>> relReq=new GetAccountRelationships(Collections.singletonList(account.id));
+		relReq.setCallback(new Callback<>(){
 					@Override
 					public void onSuccess(List<Relationship> result){
+						relationshipRequests.remove(relReq);
+						if(getActivity()==null)
+							return;
 						if(!result.isEmpty()){
 							relationship=result.get(0);
 							updateRelationship();
@@ -813,14 +883,17 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 
 					@Override
 					public void onError(ErrorResponse error){
-
+						relationshipRequests.remove(relReq);
 					}
 				})
 				.exec(accountID);
-		new GetAccountFamiliarFollowers(Set.of(account.id))
-				.setCallback(new Callback<>(){
+		MastodonAPIRequest<List<FamiliarFollowers>> followersReq=new GetAccountFamiliarFollowers(Set.of(account.id));
+		followersReq.setCallback(new Callback<>(){
 					@Override
 					public void onSuccess(List<FamiliarFollowers> result){
+						relationshipRequests.remove(followersReq);
+						if(getActivity()==null)
+							return;
 						for(FamiliarFollowers ff:result){
 							if(ff.id.equals(account.id)){
 								familiarFollowers=ff.accounts;
@@ -832,10 +905,12 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 
 					@Override
 					public void onError(ErrorResponse error){
-
+						relationshipRequests.remove(followersReq);
 					}
 				})
 				.exec(accountID);
+		relationshipRequests.add(relReq);
+		relationshipRequests.add(followersReq);
 	}
 
 	private void updateRelationship(){
@@ -844,6 +919,10 @@ public class ProfileFragment extends LoaderFragment implements ScrollableToTop,
 		UiUtils.setRelationshipToActionButtonM3(relationship, actionButton);
 		actionProgress.setIndeterminateTintList(actionButton.getTextColors());
 		followsYouView.setVisibility(relationship.followedBy ? View.VISIBLE : View.GONE);
+
+		// MOSHIDON: private note stuff!
+		showPrivateNote();
+		UiUtils.beginLayoutTransition(scrollableContent);
 	}
 
 	private void updateFamiliarFollowers(){

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

@@ -1,6 +1,7 @@
 package org.joinmastodon.android.fragments;
 
 import android.app.Activity;
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.View;
 import android.widget.FrameLayout;
@@ -15,6 +16,7 @@ import org.joinmastodon.android.api.requests.statuses.GetFavoritedStatuses;
 import org.joinmastodon.android.api.session.AccountSessionManager;
 import org.joinmastodon.android.events.RemoveAccountPostsEvent;
 import org.joinmastodon.android.model.Account;
+import org.joinmastodon.android.model.FilterContext;
 import org.joinmastodon.android.model.HeaderPaginationList;
 import org.joinmastodon.android.model.Status;
 import org.joinmastodon.android.ui.drawables.EmptyDrawable;
@@ -166,4 +168,30 @@ public class SavedPostsTimelineFragment extends StatusListFragment{
 		FAVORITES,
 		BOOKMARKS
 	}
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.ACCOUNT;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		// May someone forgive me for writing this if statement
+		if(mode==null)
+			return base.path("/bookmarks").build();
+
+		switch(mode) {
+			case FAVORITES -> {
+				return base.encodedPath(isInstanceAkkoma()
+						? '/' + getSession().self.username + "#favorites"
+						: "/favourites").build();
+			}
+			case BOOKMARKS -> {
+				return base.path("/bookmarks").build();
+			}
+		}
+
+		return null;
+	}
 }

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

@@ -11,6 +11,7 @@ import org.joinmastodon.android.events.StatusCountersUpdatedEvent;
 import org.joinmastodon.android.events.StatusCreatedEvent;
 import org.joinmastodon.android.events.StatusDeletedEvent;
 import org.joinmastodon.android.events.StatusUpdatedEvent;
+import org.joinmastodon.android.model.FilterContext;
 import org.joinmastodon.android.model.Status;
 import org.joinmastodon.android.ui.displayitems.ExtendedFooterStatusDisplayItem;
 import org.joinmastodon.android.ui.displayitems.FooterStatusDisplayItem;
@@ -32,6 +33,9 @@ public abstract class StatusListFragment extends BaseStatusListFragment<Status>{
 		return StatusDisplayItem.buildItems(this, s, accountID, s, knownAccounts, true);
 	}
 
+	protected abstract FilterContext getFilterContext();
+
+
 	@Override
 	protected void addAccountToKnown(Status s){
 		if(!knownAccounts.containsKey(s.account.id))

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

@@ -317,4 +317,15 @@ public class ThreadFragment extends StatusListFragment implements AssistContentP
 			}
 		}
 	}
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.THREAD;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return Uri.parse(mainStatus.url);
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/AccountRelatedAccountListFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.model.Account;
@@ -14,4 +15,12 @@ public abstract class AccountRelatedAccountListFragment extends PaginatedAccount
 		account=Parcels.unwrap(getArguments().getParcelable("targetAccount"));
 		setTitle("@"+account.acct);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path(isInstanceAkkoma()
+				? "/users/" + account.id
+				: '@' + account.acct).build();
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/AccountSearchFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.view.View;
@@ -106,4 +107,10 @@ public class AccountSearchFragment extends BaseAccountListFragment{
 		if(!TextUtils.isEmpty(currentQuery))
 			loadData();
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return null;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/BaseAccountListFragment.java

@@ -16,6 +16,7 @@ import org.joinmastodon.android.model.viewmodel.AccountViewModel;
 import org.joinmastodon.android.ui.DividerItemDecoration;
 import org.joinmastodon.android.ui.utils.UiUtils;
 import org.joinmastodon.android.ui.viewholders.AccountViewHolder;
+import org.joinmastodon.android.utils.ProvidesAssistContent;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -34,7 +35,7 @@ import me.grishka.appkit.imageloader.requests.ImageLoaderRequest;
 import me.grishka.appkit.utils.V;
 import me.grishka.appkit.views.UsableRecyclerView;
 
-public abstract class BaseAccountListFragment extends MastodonRecyclerFragment<AccountViewModel>{
+public abstract class BaseAccountListFragment extends MastodonRecyclerFragment<AccountViewModel> implements ProvidesAssistContent.ProvidesWebUri{
 	protected HashMap<String, Relationship> relationships=new HashMap<>();
 	protected String accountID;
 	protected ArrayList<APIRequest<?>> relationshipsRequests=new ArrayList<>();
@@ -180,4 +181,10 @@ public abstract class BaseAccountListFragment extends MastodonRecyclerFragment<A
 			return image==0 ? item.avaRequest : item.emojiHelper.getImageRequest(image-1);
 		}
 	}
+
+	// MOSHIDON:
+	@Override
+	public String getAccountID() {
+		return accountID;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/FamiliarFollowerListFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.R;
@@ -45,4 +46,10 @@ public class FamiliarFollowerListFragment extends BaseAccountListFragment{
 		if(!loaded && !dataLoading)
 			loadData();
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return null;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/FollowerListFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.R;
@@ -19,4 +20,10 @@ public class FollowerListFragment extends AccountRelatedAccountListFragment{
 	public HeaderPaginationRequest<Account> onCreateRequest(String maxID, int count){
 		return new GetAccountFollowers(account.id, maxID, count);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return null;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/FollowingListFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.R;
@@ -19,4 +20,11 @@ public class FollowingListFragment extends AccountRelatedAccountListFragment{
 	public HeaderPaginationRequest<Account> onCreateRequest(String maxID, int count){
 		return new GetAccountFollowing(account.id, maxID, count);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return super.getWebUri(base).buildUpon()
+				.appendPath(isInstanceAkkoma() ? "#followees" : "/following").build();
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/StatusEmojiReactionsListFragment.java

@@ -0,0 +1,97 @@
+package org.joinmastodon.android.fragments.account_list;
+
+import android.net.Uri;
+import android.os.Bundle;
+import android.text.SpannableStringBuilder;
+import android.view.View;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.requests.statuses.PleromaGetStatusReactions;
+import org.joinmastodon.android.model.Emoji;
+import org.joinmastodon.android.model.EmojiReaction;
+import org.joinmastodon.android.model.viewmodel.AccountViewModel;
+import org.joinmastodon.android.ui.text.HtmlParser;
+import org.joinmastodon.android.ui.utils.UiUtils;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import me.grishka.appkit.api.ErrorResponse;
+import me.grishka.appkit.api.SimpleCallback;
+
+public class StatusEmojiReactionsListFragment extends BaseAccountListFragment {
+	private String id;
+	private String emojiName;
+	private String url;
+	private int count;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		id = getArguments().getString("statusID");
+		emojiName = getArguments().getString("emoji");
+		url = getArguments().getString("url");
+		count = getArguments().getInt("count");
+
+		SpannableStringBuilder title = new SpannableStringBuilder(getResources().getQuantityString(R.plurals.sk_users_reacted_with, count,
+				count, url == null ? emojiName : ":"+emojiName+":"));
+		if (url != null) {
+			Emoji emoji = new Emoji();
+			emoji.shortcode = emojiName;
+			emoji.url = url;
+			HtmlParser.parseCustomEmoji(title, Collections.singletonList(emoji));
+		}
+		setTitle(title);
+	}
+
+	@Override
+	public void onViewCreated(View view, Bundle savedInstanceState) {
+		super.onViewCreated(view, savedInstanceState);
+		if (url != null) {
+			UiUtils.loadCustomEmojiInTextView(toolbarTitleView);
+		}
+	}
+
+	@Override
+	public void dataLoaded() {
+		super.dataLoaded();
+		footerProgress.setVisibility(View.GONE);
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest = new PleromaGetStatusReactions(id, emojiName)
+				.setCallback(new SimpleCallback<>(StatusEmojiReactionsListFragment.this){
+					@Override
+					public void onSuccess(List<EmojiReaction> result) {
+						if (getActivity() == null)
+							return;
+
+						List<AccountViewModel> items = result.get(0).accounts.stream()
+								.map(a -> new AccountViewModel(a, accountID, false, getContext()))
+								.collect(Collectors.toList());
+
+						onDataLoaded(items);
+					}
+
+					@Override
+					public void onError(ErrorResponse error) {
+						super.onError(error);
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	public void onResume(){
+		super.onResume();
+		if(!loaded && !dataLoading)
+			loadData();
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return null;
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/StatusFavoritesListFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.R;
@@ -18,4 +19,13 @@ public class StatusFavoritesListFragment extends StatusRelatedAccountListFragmen
 	public HeaderPaginationRequest<Account> onCreateRequest(String maxID, int count){
 		return new GetStatusFavorites(status.id, maxID, count);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		Uri statusUri = super.getWebUri(base);
+		return isInstanceAkkoma()
+				? statusUri
+				: statusUri.buildUpon().appendPath("favourites").build();
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/account_list/StatusRelatedAccountListFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.account_list;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.model.Status;
@@ -14,4 +15,13 @@ public abstract class StatusRelatedAccountListFragment extends PaginatedAccountL
 		status=Parcels.unwrap(getArguments().getParcelable("status"));
 	}
 
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base
+				.encodedPath(isInstanceAkkoma()
+						? "/notice/" + status.id
+						: '@' + status.account.acct + '/' + status.id)
+				.build();
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/BubbleTimelineFragment.java

@@ -0,0 +1,68 @@
+package org.joinmastodon.android.fragments.discover;
+
+import android.net.Uri;
+import android.os.Bundle;
+
+import androidx.recyclerview.widget.RecyclerView;
+
+import org.joinmastodon.android.api.requests.timelines.GetBubbleTimeline;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.fragments.StatusListFragment;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.Status;
+import org.joinmastodon.android.ui.utils.DiscoverInfoBannerHelper;
+
+import java.util.List;
+
+import me.grishka.appkit.api.SimpleCallback;
+import me.grishka.appkit.utils.MergeRecyclerAdapter;
+
+public class BubbleTimelineFragment extends StatusListFragment {
+    private DiscoverInfoBannerHelper bannerHelper;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		bannerHelper=new DiscoverInfoBannerHelper(DiscoverInfoBannerHelper.BannerType.BUBBLE_TIMELINE, accountID);
+	}
+
+
+	@Override
+    protected boolean wantsComposeButton() {
+        return true;
+    }
+
+	@Override
+    protected void doLoadData(int offset, int count){
+        currentRequest=new GetBubbleTimeline(getMaxID(), count, getLocalPrefs().timelineReplyVisibility)
+                .setCallback(new SimpleCallback<>(this){
+                    @Override
+                    public void onSuccess(List<Status> result){
+						if(getActivity()==null) return;
+						boolean more=applyMaxID(result);
+						AccountSessionManager.get(accountID).filterStatuses(result, getFilterContext());
+						onDataLoaded(result, more);
+						bannerHelper.onBannerBecameVisible();
+                    }
+                })
+                .exec(accountID);
+    }
+
+	@Override
+	protected RecyclerView.Adapter<?> getAdapter(){
+		MergeRecyclerAdapter adapter=new MergeRecyclerAdapter();
+		bannerHelper.maybeAddBanner(list, adapter);
+		adapter.addAdapter(super.getAdapter());
+		return adapter;
+	}
+
+	@Override
+    protected FilterContext getFilterContext() {
+        return FilterContext.PUBLIC;
+    }
+
+    @Override
+    public Uri getWebUri(Uri.Builder base) {
+        return isInstanceAkkoma() ? base.path("/main/bubble").build() : null;
+    }
+}

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/DiscoverAccountsFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.discover;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.api.requests.accounts.GetFollowSuggestions;
@@ -51,4 +52,10 @@ public class DiscoverAccountsFragment extends BaseAccountListFragment implements
 	public void scrollToTop(){
 		smoothScrollRecyclerViewToTop(list);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return isInstanceAkkoma() ? null : base.path("/explore/suggestions").build();
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/DiscoverFragment.java

@@ -248,6 +248,16 @@ public class DiscoverFragment extends AppKitFragment implements ScrollableToTop{
 			postsFragment.loadData();
 	}
 
+	// MOSHIDON: this is the method that works, enterSearch does not open search :D
+	public void openSearch(){
+		Bundle args=new Bundle();
+		args.putString("account", accountID);
+		if(!TextUtils.isEmpty(currentQuery)){
+			args.putString("query", currentQuery);
+		}
+		Nav.goForResult(getActivity(), SearchQueryFragment.class, args, QUERY_RESULT, DiscoverFragment.this);
+	}
+
 	private void enterSearch(){
 		if(!searchActive){
 			searchActive=true;

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/DiscoverPostsFragment.java

@@ -1,5 +1,6 @@
 package org.joinmastodon.android.fragments.discover;
 
+import android.net.Uri;
 import android.os.Bundle;
 
 import org.joinmastodon.android.api.requests.trends.GetTrendingStatuses;
@@ -46,4 +47,14 @@ public class DiscoverPostsFragment extends StatusListFragment{
 		adapter.addAdapter(super.getAdapter());
 		return adapter;
 	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.PUBLIC;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return isInstanceAkkoma() ? null : base.path("/explore/posts").build();
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/FederatedTimelineFragment.java

@@ -0,0 +1,64 @@
+package org.joinmastodon.android.fragments.discover;
+
+import android.net.Uri;
+import android.os.Bundle;
+
+import org.joinmastodon.android.api.requests.timelines.GetPublicTimeline;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.fragments.StatusListFragment;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.Status;
+import org.joinmastodon.android.ui.utils.DiscoverInfoBannerHelper;
+import org.joinmastodon.android.utils.ProvidesAssistContent;
+
+import java.util.List;
+
+import androidx.recyclerview.widget.RecyclerView;
+import me.grishka.appkit.api.SimpleCallback;
+import me.grishka.appkit.utils.MergeRecyclerAdapter;
+
+public class FederatedTimelineFragment extends StatusListFragment implements ProvidesAssistContent.ProvidesWebUri{
+	private DiscoverInfoBannerHelper bannerHelper;
+
+	private String maxID;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		bannerHelper=new DiscoverInfoBannerHelper(DiscoverInfoBannerHelper.BannerType.FEDERATED_TIMELINE, accountID);
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest=new GetPublicTimeline(false, false, getMaxID(), null, count, null, getLocalPrefs().timelineReplyVisibility)
+				.setCallback(new SimpleCallback<>(this){
+					@Override
+					public void onSuccess(List<Status> result){
+						if(getActivity()==null) return;
+						boolean more=applyMaxID(result);
+						AccountSessionManager.get(accountID).filterStatuses(result, getFilterContext());
+						onDataLoaded(result, more);
+						bannerHelper.onBannerBecameVisible();
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	protected RecyclerView.Adapter<?> getAdapter(){
+		MergeRecyclerAdapter adapter=new MergeRecyclerAdapter();
+		bannerHelper.maybeAddBanner(list, adapter);
+		adapter.addAdapter(super.getAdapter());
+		return adapter;
+	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.PUBLIC;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base) {
+		return base.path(isInstanceAkkoma() ? "/main/all" : "/public").build();
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/LocalTimelineFragment.java

@@ -0,0 +1,64 @@
+package org.joinmastodon.android.fragments.discover;
+
+import android.net.Uri;
+import android.os.Bundle;
+
+import org.joinmastodon.android.api.requests.timelines.GetPublicTimeline;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.fragments.StatusListFragment;
+import org.joinmastodon.android.model.FilterContext;
+import org.joinmastodon.android.model.Status;
+import org.joinmastodon.android.ui.utils.DiscoverInfoBannerHelper;
+import org.joinmastodon.android.utils.ProvidesAssistContent;
+
+import java.util.List;
+
+import androidx.recyclerview.widget.RecyclerView;
+import me.grishka.appkit.api.SimpleCallback;
+import me.grishka.appkit.utils.MergeRecyclerAdapter;
+
+public class LocalTimelineFragment extends StatusListFragment implements ProvidesAssistContent.ProvidesWebUri{
+	private DiscoverInfoBannerHelper bannerHelper;
+
+	private String maxID;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		bannerHelper=new DiscoverInfoBannerHelper(DiscoverInfoBannerHelper.BannerType.LOCAL_TIMELINE, accountID);
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count){
+		currentRequest=new GetPublicTimeline(true, false, getMaxID(), null, count, null, getLocalPrefs().timelineReplyVisibility)
+				.setCallback(new SimpleCallback<>(this){
+					@Override
+					public void onSuccess(List<Status> result){
+						if(getActivity()==null) return;
+						boolean more=applyMaxID(result);
+						AccountSessionManager.get(accountID).filterStatuses(result, getFilterContext());
+						onDataLoaded(result, more);
+						bannerHelper.onBannerBecameVisible();
+					}
+				})
+				.exec(accountID);
+	}
+
+	@Override
+	protected RecyclerView.Adapter<?> getAdapter(){
+		MergeRecyclerAdapter adapter=new MergeRecyclerAdapter();
+		bannerHelper.maybeAddBanner(list, adapter);
+		adapter.addAdapter(super.getAdapter());
+		return adapter;
+	}
+
+	@Override
+	protected FilterContext getFilterContext() {
+		return FilterContext.PUBLIC;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return base.path(isInstanceAkkoma() ? "/main/public" : "/public/local").build();
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/fragments/discover/SearchFragment.java

@@ -1,6 +1,7 @@
 package org.joinmastodon.android.fragments.discover;
 
 import android.app.Activity;
+import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.view.inputmethod.InputMethodManager;
@@ -230,4 +231,11 @@ public class SearchFragment extends BaseStatusListFragment<SearchResult>{
 	public interface ProgressVisibilityListener{
 		void onProgressVisibilityChanged(boolean visible);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		// TODO this
+		return null;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/onboarding/CustomWelcomeFragment.java

@@ -0,0 +1,251 @@
+package org.joinmastodon.android.fragments.onboarding;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.RadioButton;
+import android.widget.Space;
+import android.widget.TextView;
+import android.widget.Toolbar;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import org.joinmastodon.android.R;
+import org.joinmastodon.android.api.session.AccountSessionManager;
+import org.joinmastodon.android.model.Instance;
+import org.joinmastodon.android.model.catalog.CatalogInstance;
+import org.joinmastodon.android.ui.BetterItemAnimator;
+import org.joinmastodon.android.ui.utils.UiUtils;
+
+import java.util.ArrayList;
+import java.util.Objects;
+
+import me.grishka.appkit.FragmentStackActivity;
+import me.grishka.appkit.utils.BindableViewHolder;
+import me.grishka.appkit.utils.MergeRecyclerAdapter;
+import me.grishka.appkit.utils.SingleViewRecyclerAdapter;
+import me.grishka.appkit.utils.V;
+import me.grishka.appkit.views.UsableRecyclerView;
+
+public class CustomWelcomeFragment extends InstanceCatalogFragment {
+	private View headerView;
+	protected MergeRecyclerAdapter mergeAdapter;
+
+	public CustomWelcomeFragment() {
+		super(R.layout.fragment_welcome_custom, 1);
+	}
+
+	@Override
+	public void onAttach(Context context){
+		super.onAttach(context);
+		setRefreshEnabled(false);
+	}
+
+	@Override
+	public void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		dataLoaded();
+	}
+
+	@Override
+	protected void onUpdateToolbar(){
+		super.onUpdateToolbar();
+
+		if (!canGoBack()) {
+			ImageView toolbarLogo=new ImageView(getActivity());
+			toolbarLogo.setScaleType(ImageView.ScaleType.CENTER);
+			toolbarLogo.setImageResource(R.drawable.logo);
+			toolbarLogo.setImageTintList(ColorStateList.valueOf(UiUtils.getThemeColor(getActivity(), android.R.attr.textColorPrimary)));
+
+			FrameLayout logoWrap=new FrameLayout(getActivity());
+			FrameLayout.LayoutParams logoParams=new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.CENTER);
+			logoParams.setMargins(0, V.dp(2), 0, 0);
+			logoWrap.addView(toolbarLogo, logoParams);
+
+			getToolbar().addView(logoWrap, new Toolbar.LayoutParams(Gravity.CENTER));
+		} else {
+			setTitle(R.string.add_account);
+		}
+	}
+
+	@Override
+	protected void proceedWithAuthOrSignup(Instance instance) {
+		AccountSessionManager.getInstance().authenticate(getActivity(), instance);
+	}
+
+	@Override
+	protected void updateFilteredList(){
+		String query=getCurrentSearchQuery();
+		boolean addFakeInstance=query.length()>0 && query.matches("^\\S+\\.[^\\.]+$");
+		if(addFakeInstance){
+			fakeInstance.domain=fakeInstance.normalizedDomain=query;
+			fakeInstance.description=getString(R.string.loading_instance);
+			if(filteredData.size()>0 && filteredData.get(0)==fakeInstance){
+				if(list.findViewHolderForAdapterPosition(1) instanceof InstanceViewHolder ivh){
+					ivh.rebind();
+				}
+			}
+			if(filteredData.isEmpty()){
+				filteredData.add(fakeInstance);
+				adapter.notifyItemInserted(0);
+			}
+		}
+		ArrayList<CatalogInstance> prevData=new ArrayList<>(filteredData);
+		filteredData.clear();
+		if(query.length()>0){
+			boolean foundExactMatch=false;
+			for(CatalogInstance inst:data){
+				if(inst.normalizedDomain.contains(query)){
+					filteredData.add(inst);
+					if(inst.normalizedDomain.equals(query))
+						foundExactMatch=true;
+				}
+			}
+			if(!foundExactMatch && addFakeInstance) {
+				filteredData.add(0, fakeInstance);
+				adapter.notifyItemChanged(0);
+			}
+		}
+		UiUtils.updateList(prevData, filteredData, list, adapter, Objects::equals);
+		for(int i=0;i<list.getChildCount();i++){
+			list.getChildAt(i).invalidateOutline();
+		}
+	}
+
+	protected String getCurrentSearchQuery(){
+		String[] parts=currentSearchQuery.split("@");
+		return parts.length>0 ? parts[parts.length-1] : "";
+	}
+
+	@Override
+	public void onViewCreated(View view, Bundle savedInstanceState) {
+		super.onViewCreated(view, savedInstanceState);
+		view.setBackgroundColor(UiUtils.getThemeColor(getActivity(), R.attr.colorM3Surface));
+		list.setItemAnimator(new BetterItemAnimator());
+		((UsableRecyclerView) list).setSelector(null);
+	}
+
+	@Override
+	protected void doLoadData(int offset, int count) {}
+
+	@Override
+	protected RecyclerView.Adapter<?> getAdapter(){
+		headerView=getActivity().getLayoutInflater().inflate(R.layout.header_welcome_custom, list, false);
+		searchEdit=headerView.findViewById(R.id.search_edit);
+		searchEdit.setOnEditorActionListener(this::onSearchEnterPressed);
+
+		headerView.findViewById(R.id.more).setVisibility(View.GONE);
+//		headerView.findViewById(R.id.visibility).setVisibility(View.GONE);
+//		headerView.findViewById(R.id.unread_indicator).setVisibility(View.GONE);
+//		headerView.findViewById(R.id.separator).setVisibility(View.GONE);
+//		headerView.findViewById(R.id.time).setVisibility(View.GONE);
+		// FIXME: make a custom header
+		((TextView) headerView.findViewById(R.id.time_and_username)).setText(R.string.mo_app_username);
+		((TextView) headerView.findViewById(R.id.name)).setText(R.string.mo_app_name);
+		((ImageView) headerView.findViewById(R.id.avatar)).setImageDrawable(getActivity().getDrawable(R.mipmap.ic_launcher));
+		((FragmentStackActivity) getActivity()).invalidateSystemBarColors(this);
+
+		searchEdit.addTextChangedListener(new TextWatcher(){
+			@Override
+			public void beforeTextChanged(CharSequence s, int start, int count, int after){}
+
+			@Override
+			public void onTextChanged(CharSequence s, int start, int before, int count){
+				nextButton.setEnabled(false);
+				chosenInstance = null;
+				searchEdit.removeCallbacks(searchDebouncer);
+				searchEdit.postDelayed(searchDebouncer, 300);
+			}
+
+			@Override
+			public void afterTextChanged(Editable s){}
+		});
+
+		mergeAdapter=new MergeRecyclerAdapter();
+		mergeAdapter.addAdapter(new SingleViewRecyclerAdapter(headerView));
+		mergeAdapter.addAdapter(adapter=new InstancesAdapter());
+		View spacer = new Space(getActivity());
+		spacer.setMinimumHeight(V.dp(8));
+		mergeAdapter.addAdapter(new SingleViewRecyclerAdapter(spacer));
+		return mergeAdapter;
+	}
+
+	private class InstancesAdapter extends UsableRecyclerView.Adapter<InstanceViewHolder> {
+		public InstancesAdapter(){
+			super(imgLoader);
+		}
+
+		@NonNull
+		@Override
+		public InstanceViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType){
+			return new InstanceViewHolder();
+		}
+
+		@Override
+		public void onBindViewHolder(InstanceViewHolder holder, int position){
+			holder.bind(filteredData.get(position));
+			chosenInstance = filteredData.get(position);
+			if (chosenInstance != fakeInstance) nextButton.setEnabled(true);
+			super.onBindViewHolder(holder, position);
+		}
+
+		@Override
+		public int getItemCount(){
+			return filteredData.size();
+		}
+
+		@Override
+		public int getItemViewType(int position){
+			return -1;
+		}
+	}
+
+	private class InstanceViewHolder extends BindableViewHolder<CatalogInstance> implements UsableRecyclerView.Clickable{
+		private final TextView title, description, userCount, lang;
+
+		public InstanceViewHolder(){
+			super(getActivity(), R.layout.item_instance_custom, list);
+			title=findViewById(R.id.title);
+			description=findViewById(R.id.description);
+			userCount=findViewById(R.id.user_count);
+			lang=findViewById(R.id.lang);
+			if(Build.VERSION.SDK_INT<Build.VERSION_CODES.N){
+				UiUtils.fixCompoundDrawableTintOnAndroid6(userCount);
+				UiUtils.fixCompoundDrawableTintOnAndroid6(lang);
+			}
+		}
+
+		@Override
+		public void onBind(CatalogInstance item){
+			title.setText(item.normalizedDomain);
+			description.setText(item.description);
+			if (item == fakeInstance) {
+				userCount.setVisibility(View.GONE);
+				lang.setVisibility(View.GONE);
+			} else {
+				userCount.setVisibility(View.VISIBLE);
+				lang.setVisibility(View.VISIBLE);
+				userCount.setText(UiUtils.abbreviateNumber(item.totalUsers));
+				lang.setText(item.language.toUpperCase());
+			}
+		}
+
+		@Override
+		public void onClick(){
+			if(chosenInstance==null)
+				nextButton.setEnabled(true);
+			chosenInstance=item;
+			loadInstanceInfo(chosenInstance.domain, false);
+			onNextClick(null);
+		}
+	}
+}

mastodon/src/main/java/org/joinmastodon/android/fragments/onboarding/InstanceCatalogFragment.java

@@ -82,7 +82,7 @@ abstract class InstanceCatalogFragment extends BaseRecyclerFragment<CatalogInsta
 	@Override
 	public void onCreate(Bundle savedInstanceState){
 		super.onCreate(savedInstanceState);
-		isSignup=getArguments().getBoolean("signup");
+		isSignup=getArguments() != null && getArguments().getBoolean("signup");
 	}
 
 	protected abstract void proceedWithAuthOrSignup(Instance instance);

mastodon/src/main/java/org/joinmastodon/android/fragments/onboarding/OnboardingFollowSuggestionsFragment.java

@@ -1,6 +1,7 @@
 package org.joinmastodon.android.fragments.onboarding;
 
 import android.app.ProgressDialog;
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.View;
 import android.view.WindowInsets;
@@ -171,4 +172,10 @@ public class OnboardingFollowSuggestionsFragment extends BaseAccountListFragment
 		holder.setStyle(AccountViewHolder.AccessoryType.BUTTON, true);
 		holder.avatar.setOutlineProvider(OutlineProviders.roundedRect(8));
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/report/ReportAddPostsChoiceFragment.java

@@ -4,6 +4,7 @@ import android.app.Activity;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
+import android.net.Uri;
 import android.os.Bundle;
 import android.view.View;
 import android.view.WindowInsets;
@@ -19,6 +20,7 @@ import org.joinmastodon.android.api.requests.accounts.GetAccountStatuses;
 import org.joinmastodon.android.events.FinishReportFragmentsEvent;
 import org.joinmastodon.android.fragments.StatusListFragment;
 import org.joinmastodon.android.model.Account;
+import org.joinmastodon.android.model.FilterContext;
 import org.joinmastodon.android.model.Status;
 import org.joinmastodon.android.ui.OutlineProviders;
 import org.joinmastodon.android.ui.displayitems.AudioStatusDisplayItem;
@@ -218,4 +220,15 @@ public class ReportAddPostsChoiceFragment extends StatusListFragment{
 	private boolean isChecked(CheckableHeaderStatusDisplayItem.Holder holder){
 		return selectedIDs.contains(holder.getItem().parentID);
 	}
+
+	// MOSHIDON:
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null;
+	}
+
+	@Override
+	protected FilterContext getFilterContext(){
+		return null;
+	}
 }

mastodon/src/main/java/org/joinmastodon/android/fragments/report/ReportReasonChoiceFragment.java

@@ -4,6 +4,7 @@ import android.app.Activity;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
+import android.net.Uri;
 import android.os.Bundle;
 import android.util.Log;
 import android.view.LayoutInflater;
@@ -21,6 +22,7 @@ import org.joinmastodon.android.api.session.AccountSessionManager;
 import org.joinmastodon.android.events.FinishReportFragmentsEvent;
 import org.joinmastodon.android.fragments.StatusListFragment;
 import org.joinmastodon.android.model.Account;
+import org.joinmastodon.android.model.FilterContext;
 import org.joinmastodon.android.model.Instance;
 import org.joinmastodon.android.model.Relationship;
 import org.joinmastodon.android.model.ReportReason;
@@ -81,7 +83,7 @@ public class ReportReasonChoiceFragment extends StatusListFragment{
 		reportStatus=Parcels.unwrap(getArguments().getParcelable("status"));
 		if(reportStatus!=null){
 			Status hiddenStatus=reportStatus.clone();
-			hiddenStatus.spoilerText=getString(R.string.post_hidden);
+			if(hiddenStatus.spoilerText==null) hiddenStatus.spoilerText=getString(R.string.post_hidden);
 			onDataLoaded(Collections.singletonList(hiddenStatus));
 			setTitle(R.string.report_title_post);
 		}else{
@@ -166,17 +168,6 @@ public class ReportReasonChoiceFragment extends StatusListFragment{
 		((UsableRecyclerView)list).setIncludeMarginsInItemHitbox(false);
 
 		if(reportStatus!=null){
-			list.addItemDecoration(new RecyclerView.ItemDecoration(){
-				@Override
-				public void getItemOffsets(@NonNull Rect outRect, @NonNull View view, @NonNull RecyclerView parent, @NonNull RecyclerView.State state){
-					RecyclerView.ViewHolder holder=parent.getChildViewHolder(view);
-					if(holder instanceof LinkCardStatusDisplayItem.Holder || holder instanceof MediaGridStatusDisplayItem.Holder){
-						outRect.left=V.dp(16);
-						outRect.right=V.dp(16);
-					}
-				}
-			});
-
 			list.addItemDecoration(new RecyclerView.ItemDecoration(){
 				private Paint paint=new Paint(Paint.ANTI_ALIAS_FLAG);
 				{
@@ -213,18 +204,6 @@ public class ReportReasonChoiceFragment extends StatusListFragment{
 					float off=paint.getStrokeWidth()/2f;
 					c.drawRoundRect(V.dp(16)-off, top-off, parent.getWidth()-V.dp(16)+off, bottom+off, V.dp(12), V.dp(12), paint);
 				}
-
-				@Override
-				public void getItemOffsets(@NonNull Rect outRect, @NonNull View view, @NonNull RecyclerView parent, @NonNull RecyclerView.State state){
-					RecyclerView.ViewHolder holder=parent.getChildViewHolder(view);
-					if(holder instanceof StatusDisplayItem.Holder<?>){
-						outRect.left=outRect.right=V.dp(16);
-					}
-					int index=holder.getAbsoluteAdapterPosition()-mergeAdapter.getPositionForAdapter(adapter);
-					if(index==displayItems.size()){
-						outRect.top=V.dp(32);
-					}
-				}
 			});
 		}
 	}
@@ -241,19 +220,7 @@ public class ReportReasonChoiceFragment extends StatusListFragment{
 
 	@Override
 	protected List<StatusDisplayItem> buildDisplayItems(Status s){
-		return StatusDisplayItem.buildItems(this, s, accountID, s, knownAccounts, StatusDisplayItem.FLAG_NO_FOOTER);
-	}
-
-	@Override
-	protected void onModifyItemViewHolder(BindableViewHolder<StatusDisplayItem> holder){
-		if((Object)holder instanceof MediaGridStatusDisplayItem.Holder h){
-			View layout=h.getLayout();
-			layout.setOutlineProvider(OutlineProviders.roundedRect(8));
-			layout.setClipToOutline(true);
-			View overlay=h.getSensitiveOverlay();
-			overlay.setOutlineProvider(OutlineProviders.roundedRect(8));
-			overlay.setClipToOutline(true);
-		}
+		return StatusDisplayItem.buildItems(this, s, accountID, s, knownAccounts, getFilterContext(), StatusDisplayItem.FLAG_INSET | StatusDisplayItem.FLAG_NO_FOOTER);
 	}
 
 	@Override
@@ -262,4 +229,15 @@ public class ReportReasonChoiceFragment extends StatusListFragment{
 		if(id.equals(reportAccount.id))
 			relationship=rel;
 	}
+
+	// MOSHIDON:
+	@Override
+	protected FilterContext getFilterContext(){
+		return null;
+	}
+
+	@Override
+	public Uri getWebUri(Uri.Builder base){
+		return null;
+	}
 }