Merge remote-tracking branch 'NekoX/dev' into dev

.github/scripts/upload.py

@@ -0,0 +1,163 @@
+import requests
+import sys
+import os
+
+def read_env(key):
+    if key in os.environ:
+        return os.environ[key]
+    else:
+        print(f"failed to read env {key}")
+        return ""
+
+APK_FOLDER = "apks"
+API_PREFIX = "http://127.0.0.1:38118/bot" + os.environ["BOT_TOKEN"] + "/"
+
+BOT_TARGET = read_env("BOT_TARGET")
+ADMIN_USERID = BOT_TARGET.replace("-100","")
+
+VERSION_NAME = read_env("VERSION_NAME")
+VERSION_CODE = read_env("VERSION_CODE")
+COMMIT_HASH = read_env("GITHUB_SHA")
+COMMIT_MESSAGE = read_env("COMMIT_MESSAGE")
+
+APK_CHANNEL_ID = "@NekoXApks"
+UPDATE_CHANNEL_ID = "@NekogramX"
+UPDATE_METADATA_CHANNEL_ID = "@nekox_update_metadata"
+CI_CHANNEL_ID = "@NekoX_CI"
+
+
+def addEntity(entities, origin_str, en_type, content, url = None) -> str:
+    origin_len = len(origin_str)
+    entity = {
+        "type": en_type,
+        "offset": origin_len,
+        "length": len(content)
+    }
+    if url:
+        entity["url"] = url
+    entities.append(entity)
+    return content
+
+
+def waitReply(mid):
+    last_update = 0
+    while True:
+        print(f"Waiting reply for {mid} offset {last_update}...")
+        resp = requests.post(API_PREFIX + "getUpdates", json={"allowed_updates":["message"], "timeout": 20, "offset": last_update + 1})
+        resp = resp.json()
+        if not resp["ok"]:
+            continue
+        resp = resp["result"]
+        for update in resp:
+            if 'message' in update:
+                msg = update["message"]
+                if 'from' in msg and str(msg['from']["id"]) == ADMIN_USERID:
+                    if 'reply_to_message' in msg and str(msg["reply_to_message"]["message_id"]) == str(mid):
+                        return msg
+        for update in resp:
+            last_update = max(last_update, update["update_id"])
+
+
+def sendMessage(message, user_id = BOT_TARGET, entities = None) -> int:
+    data = {
+        "chat_id" : user_id,
+        "text": message,
+        "entities": entities
+    }
+    resp = requests.post(API_PREFIX + "sendMessage", json=data).json()
+    print(resp)
+    return int(resp["result"]["message_id"])
+
+
+def sendDocument(user_id, path, message = "", entities = None):
+    files = {'document': open(path, 'rb')}
+    data = {'chat_id': user_id,
+            'caption': message,
+            'parse_mode': 'Markdown',
+            'caption_entities': entities}
+    response = requests.post(API_PREFIX + "sendDocument", files=files, data=data)
+    print(response.json())
+
+
+def sendRelease():
+    apks = os.listdir(APK_FOLDER)
+    apks.sort()
+    print(apks)
+
+    # read message from admin
+    mid = sendMessage(f"Please reply the release message for the version {VERSION_NAME},{VERSION_CODE}:", user_id=BOT_TARGET)
+    admin_resp = waitReply(mid)
+
+    # send message and apks to APK channel
+    message = f"=== {VERSION_NAME} ==="
+    apk_channel_first_id = sendMessage(message, user_id=APK_CHANNEL_ID)
+
+    for apk in apks:
+        path = os.path.join(APK_FOLDER, apk)
+        sendDocument(user_id=APK_CHANNEL_ID, path=path)
+
+    # generate release message and send to update channel
+    entities = []
+    text = ""
+    text += addEntity(entities, text, "hashtag", f"#{'PRE_RELEASE' if 'preview' in VERSION_NAME else 'RELEASE'}")
+    text += " "
+    text += addEntity(entities, text, "text_link", " ", f'https://t.me/{APK_CHANNEL_ID.replace("@","")}/{apk_channel_first_id + 1}')
+    text += " "
+    text += addEntity(entities, text, "bold", VERSION_NAME)
+    text += "\n\n"
+    resp_entities = admin_resp["entities"]
+    for en in resp_entities:
+        copy = en.copy()
+        copy["offset"] += len(text)
+        entities.append(copy)
+    text += admin_resp["text"]
+    text += "\n\n"
+    text += addEntity(entities, text, "text_link", "GitHub Release", f"https://github.com/NekoX-Dev/NekoX/releases/{VERSION_NAME}")
+    text += " | "
+    text += addEntity(entities, text, "text_link", "Apks", f'https://t.me/{APK_CHANNEL_ID.replace("@","")}/{apk_channel_first_id}')
+    text += " | "
+    text += addEntity(entities, text, "text_link", "Check Update", "tg://update/")
+
+    sendMessage(text, user_id=UPDATE_CHANNEL_ID, entities=entities)
+
+    # send release message to metadata channel
+    mid = sendMessage(admin_resp["text"], user_id=UPDATE_METADATA_CHANNEL_ID, entities=admin_resp["entities"])
+    meta_msg = f"{VERSION_NAME},{VERSION_CODE},{apk_channel_first_id},{mid}"
+    sendMessage(meta_msg, user_id=UPDATE_METADATA_CHANNEL_ID)
+
+
+def sendCIRelease():
+    apks = os.listdir(APK_FOLDER)
+    apks.sort()
+    apk = os.path.join(APK_FOLDER, apks[0])
+    entities = []
+    message = f"CI Build\n\n{COMMIT_MESSAGE}\n\n"
+    message += addEntity(entities, message, "text_link", COMMIT_HASH[0:8], f"https://github.com/NekoX-Dev/NekoX/commit/{COMMIT_HASH}")
+    sendDocument(user_id=CI_CHANNEL_ID, path = apk, message=message, )
+
+
+if __name__ == '__main__':
+    print(sys.argv)
+    if len(sys.argv) != 2:
+        print("Run Type: release, ci, debug")
+        exit(1)
+    mode = sys.argv[1]
+    try:
+        if mode == "release":
+            sendRelease()
+        elif mode == "ci":
+            if COMMIT_MESSAGE.startswith("ci"):
+                CI_CHANNEL_ID = BOT_TARGET
+            sendCIRelease()
+        elif mode == "debug":
+            APK_CHANNEL_ID = "@test_channel_nekox"
+            UPDATE_CHANNEL_ID = "@test_channel_nekox"
+            UPDATE_METADATA_CHANNEL_ID = "@test_channel_nekox"
+            sendRelease()
+        else:
+            print("unknown mode")
+            exit(1)
+    except Exception as e:
+        print(e)
+        exit(1)
+

.github/workflows/release.yml

@@ -345,7 +345,9 @@ jobs:
       - build
       - telegram-bot-api
     steps:
-      - name: Donwload Artifacts
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Download Artifacts
         uses: actions/download-artifact@v2
         with:
           path: artifacts

TMessagesProj/build.gradle

@@ -82,8 +82,12 @@ android {
                 enable false
                 universalApk true
             } else {
-                enable true
-                if (!nativeTarget.isBlank()) {
+                if (nativeTarget.toLowerCase().equals("universal")) {
+                    enable false
+                    universalApk true
+                } else if (!nativeTarget.isBlank()) {
+                    enable true
+                    universalApk false
                     reset()
                     include nativeTarget
                     universalApk false

TMessagesProj/src/main/java/org/telegram/ui/ActionBar/BottomSheet.java

@@ -60,13 +60,17 @@
 import org.telegram.messenger.R;
 import org.telegram.messenger.UserConfig;
 import org.telegram.messenger.camera.CameraView;
+import org.telegram.ui.Cells.HeaderCell;
 import org.telegram.ui.Components.AnimationProperties;
 import org.telegram.ui.Components.Bulletin;
 import org.telegram.ui.Components.CubicBezierInterpolator;
 import org.telegram.ui.Components.LayoutHelper;
 
 import java.util.ArrayList;
 
+import kotlin.Unit;
+import tw.nekomimi.nekogram.ui.BottomBuilder;
+
 public class BottomSheet extends Dialog {
     private final static boolean AVOID_SYSTEM_CUTOUT_FULLSCREEN = false;
 
@@ -1748,6 +1752,131 @@ public Builder setOnPreDismissListener(OnDismissListener onDismissListener) {
         }
     }
 
+    public static class NekoXBuilder {
+        // do the same thing as BottomBuilder
+        private final BottomBuilder nekoxBuilder;
+
+        private HeaderCell title;
+
+        private final BottomSheet bottomSheet;
+        // in Telegram interface, BottomSheet only have one title
+
+        public NekoXBuilder(Context context) {
+            this(context, false);
+        }
+
+        public NekoXBuilder(Context context, int bgColor) {
+            this(context, false, bgColor);
+        }
+
+        public NekoXBuilder(Context context, boolean needFocus) {
+            this(context, needFocus, Theme.getColor(Theme.key_dialogBackground));
+        }
+        public NekoXBuilder(Context context, boolean needFocus, int bgColor) {
+            this.nekoxBuilder = new BottomBuilder(context, needFocus, bgColor);
+            this.bottomSheet = nekoxBuilder.getBuilder().bottomSheet;
+        }
+        public NekoXBuilder setItems(CharSequence[] items, final OnClickListener onClickListener) {
+            nekoxBuilder.addItems(items, null, (index, text, cell) -> {
+                onClickListener.onClick(null, index);
+                return Unit.INSTANCE;
+            });
+            return this;
+        }
+
+        public NekoXBuilder setItems(CharSequence[] items, int[] icons, final OnClickListener onClickListener) {
+            nekoxBuilder.addItems(items, icons, (index, text, cell) -> {
+                onClickListener.onClick(null, index);
+                return Unit.INSTANCE;
+            });
+            return this;
+        }
+
+        public NekoXBuilder setTitle(CharSequence title) {
+            return setTitle(title, false);
+        }
+
+        public NekoXBuilder setTitle(CharSequence title, boolean big) {
+            this.title = nekoxBuilder.addTitle(title, big);
+            return this;
+        }
+
+        public NekoXBuilder setTitleMultipleLines(boolean allowMultipleLines) {
+            if (this.title != null) {
+                var textView = this.title.getTextView();
+                if (allowMultipleLines) {
+                    textView.setSingleLine(false);
+                    textView.setMaxLines(5);
+                    textView.setEllipsize(TextUtils.TruncateAt.END);
+                } else {
+                    textView.setLines(1);
+                    textView.setSingleLine(true);
+                    textView.setEllipsize(TextUtils.TruncateAt.MIDDLE);
+                }
+            }
+            return this;
+        }
+
+        public BottomSheet create() {
+            return nekoxBuilder.create();
+        }
+
+        public BottomSheet setDimBehind(boolean value) {
+            bottomSheet.dimBehind = value;
+            return bottomSheet;
+        }
+
+        public BottomSheet show() {
+            bottomSheet.show();
+            return bottomSheet;
+        }
+
+        public NekoXBuilder setTag(int tag) {
+            bottomSheet.tag = tag;
+            return this;
+        }
+
+        public NekoXBuilder setUseHardwareLayer(boolean value) {
+            bottomSheet.useHardwareLayer = value;
+            return this;
+        }
+
+        public NekoXBuilder setDelegate(BottomSheetDelegate delegate) {
+            bottomSheet.setDelegate(delegate);
+            return this;
+        }
+
+        public NekoXBuilder setApplyTopPadding(boolean value) {
+            bottomSheet.applyTopPadding = value;
+            return this;
+        }
+
+        public NekoXBuilder setApplyBottomPadding(boolean value) {
+            bottomSheet.applyBottomPadding = value;
+            return this;
+        }
+
+        public Runnable getDismissRunnable() {
+            return bottomSheet.dismissRunnable;
+        }
+
+        public BottomSheet setUseFullWidth(boolean value) {
+            bottomSheet.fullWidth = value;
+            return bottomSheet;
+        }
+
+        public BottomSheet setUseFullscreen(boolean value) {
+            bottomSheet.isFullscreen = value;
+            return bottomSheet;
+        }
+
+        public NekoXBuilder setOnPreDismissListener(OnDismissListener onDismissListener) {
+            nekoxBuilder.getBuilder().bottomSheet.setOnHideListener(onDismissListener);
+            return this;
+        }
+
+    }
+
     public int getLeftInset() {
         if (lastInsets != null && Build.VERSION.SDK_INT >= 21) {
             float inset;