list = Arrays.asList("Rikka", "haoye");
46 |
47 | @Override
48 | public boolean equals(Object o) {
49 | if (this == o) return true;
50 | if (o == null || getClass() != o.getClass()) return false;
51 | SampleObject that = (SampleObject) o;
52 | return integer == that.integer &&
53 | Objects.equals(string, that.string) &&
54 | Objects.equals(map, that.map) &&
55 | Objects.equals(list, that.list);
56 | }
57 |
58 | @Override
59 | public int hashCode() {
60 | return Objects.hash(string, integer, map, list);
61 | }
62 | }
63 |
64 | @Test
65 | public void objectToJson() throws IOException {
66 | assertEquals(ApiUtils.objectToJson(new SampleObject()).trim(), SampleObject.TARGET_JSON.trim());
67 | }
68 |
69 | @Test
70 | public void tryObjectToJson() {
71 | String validResponse = ApiUtils.tryObjectToJson(new SampleObject());
72 | assertNotNull(validResponse);
73 | assertEquals(SampleObject.TARGET_JSON, validResponse.trim());
74 | }
75 |
76 | @Test
77 | public void jsonToObject() throws IOException {
78 | assertEquals(ApiUtils.jsonToObject(SampleObject.TARGET_JSON, SampleObject.class), new SampleObject());
79 | }
80 |
81 | @Test
82 | public void jsonToObject1() {
83 | }
84 | }
--------------------------------------------------------------------------------
/app/src/main/res/layout/item_account_alias.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
8 |
16 |
19 |
30 |
31 |
43 |
44 |
52 |
60 |
61 |
62 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 | 
4 | 
5 | 
6 | 
7 | 
8 | 
9 | 
10 | 
11 | 
12 | 
13 |
14 |
15 | # MiPush Tester (Alpha)
16 |
17 | Simplified Chinese document（简体中文文档）: [README](README_zh-rCN.md)
18 |
19 | Want to build it yourself? Please read [Build guides](BUILD.md)
20 |
21 | Want to contribute this project? Please read [Contribution guide](CONTRIBUTION.md)
22 |
23 | ## Usage
24 | 1. Download and install the APK [here](https://github.com/MiPushFramework/MiPushTester/releases)
25 | 2. Register push by clicking `Not registered` button
26 | 3. Click `Create a push` and edit the push profile
27 | 4. Click `send` button on the right top corner
28 | 5. Check if the push is received correctly
29 |
30 | ## If not...
31 | If your push (message) is not received or display an error, you can feedback [here](https://github.com/MiPushFramework/MiPushTester/issues/new/choose) (Choose `Bug report`).
32 |
33 | Don't forget to attach your logs by sharing logs zip (Main → Menu → Share logs) and your steps.
34 |
35 | # Licenses
36 | ## The license for this project
37 | GPL v3.0
38 | ## Licenses for third-party resources
39 | Licenses of libraries are used in Android client is attached into the app, you can go to Main Menu Open Source Licenses to view them.
40 |
41 | Some icons and pictures comes from [icons8.com](https://icons8.com/license), which are free to use for Open Source (Established projects should get the icons for free.)
42 |
43 | Licenses of libraries are used in the server:
44 |
45 | * Vertx - Eclipse Public License 2.0 and Apache License 2.0
46 | * JUnit - EPL 1.0
47 | * Mockito - MIT
48 | * Power Mockito - Apache 2.0
--------------------------------------------------------------------------------
/server/src/main/kotlin/moe/yuuta/server/mipush/Message.kt:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.mipush
2 |
3 | import moe.yuuta.server.formprocessor.FormData
4 |
5 | @SuppressWarnings("unused")
6 | data class Message(@FormData("title") var title: String = "",
7 | @FormData(name = "payload", urlEncode = true) var payload: String = "",
8 | @FormData("restricted_package_name") var restrictedPackageName: String = "",
9 | @FormData("pass_through") var passThrough: Int = PASS_THROUGH_DISABLED,
10 | @FormData("description") var description: String = "",
11 | @FormData("time_to_live") var timeToLive: Long = 0,
12 | @FormData("time_to_send") var timeToSend: Long = 0,
13 | @FormData("notify_id") var notifyId: Int = 0,
14 | @FormData("extra.sound_uri") var soundUri: String? = null,
15 | @FormData("extra.ticker") var ticker: String? = null,
16 | @FormData(name = "extra.notify_foreground", ignorable = false) var notifyForeground: Int = NOTIFY_FOREGROUND_ENABLE,
17 | @FormData("extra.notify_effect") var notifyEffect: String = NOTIFY_NOTIFY_EFFECT_LAUNCHER_APP,
18 | @FormData("extra.flow_control") var flowControl: Int = FLOW_CONTROL_DISABLE,
19 | @FormData("extra.layout_name") var layoutName: Int = 0,
20 | @FormData("extra.jobkey") var jobKey: String = "",
21 | @FormData("extra.callback") var callback: String = "",
22 | @FormData("extra.locale") var locale: String = "",
23 | @FormData("extra.locale_not_in") var localeNotIn: String = "",
24 | @FormData("extra.model") var model: String = "",
25 | @FormData("extra.model_not_in") var modelNotIn: String = "",
26 | @FormData("extra.app_version") var appVersion: String = "",
27 | @FormData("extra.app_version_not_in") var appVersionNotIn: String = "",
28 | @FormData("extra.connpt") var connpt: String? = null,
29 | @FormData("notify_type") var notifyType: Int = NOTIFY_TYPE_DEFAULT_ALL,
30 | @FormData("extra.intent_uri") var intentUrl: String = "",
31 | @FormData("extra.web_uri") var webUri: String? = null,
32 | @FormData("registration_id") var regId: String? = null,
33 | @FormData("alias") var alias: String? = null,
34 | @FormData("user_account") var account: String? = null) {
35 | companion object {
36 | const val PASS_THROUGH_DISABLED = 0
37 | const val PASS_THROUGH_ENABLED = 1
38 |
39 | const val NOTIFY_TYPE_DEFAULT_ALL = -1
40 | const val NOTIFY_TYPE_DEFAULT_SOUND = 1
41 | const val NOTIFY_TYPE_DEFAULT_VIBRATE = 2
42 | const val NOTIFY_TYPE_DEFAULT_LIGHTS = 4
43 |
44 | const val NOTIFY_FOREGROUND_DISABLE = 0
45 | const val NOTIFY_FOREGROUND_ENABLE = 1
46 |
47 | const val NOTIFY_NOTIFY_EFFECT_LAUNCHER_APP = "1"
48 | const val NOTIFY_NOTIFY_EFFECT_SPECIFIED_ACTIVITY = "2"
49 | const val NOTIFY_NOTIFY_EFFECT_URL = "3"
50 |
51 | const val FLOW_CONTROL_DISABLE = 0
52 | const val FLOW_CONTROL_ENABLE = 1
53 |
54 | const val CONNPT_WIFI = "wifi"
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/server/src/test/java/moe/yuuta/server/dataverify/DataVerifierTest.java:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.dataverify;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.junit.Assert.assertFalse;
7 | import static org.junit.Assert.assertTrue;
8 |
9 | public class DataVerifierTest {
10 | private SampleObject objectToBeTested;
11 |
12 | @Before
13 | public void setUp() {
14 | resetObject();
15 | }
16 |
17 | @Test
18 | public void shouldVerify () {
19 | // Original object which should pass
20 | assertTrue(DataVerifier.verify(objectToBeTested));
21 |
22 | objectToBeTested.equalZero = 2333;
23 | assertFalse(DataVerifier.verify(objectToBeTested));
24 | resetObject();
25 |
26 | objectToBeTested.greaterZero = 0;
27 | assertFalse(DataVerifier.verify(objectToBeTested));
28 | resetObject();
29 |
30 | objectToBeTested.greaterOrEqualZero = -1;
31 | assertFalse(DataVerifier.verify(objectToBeTested));
32 | resetObject();
33 |
34 | objectToBeTested.lesserZero = 0;
35 | assertFalse(DataVerifier.verify(objectToBeTested));
36 | resetObject();
37 |
38 | objectToBeTested.lesserOrEqualZero = 1;
39 | assertFalse(DataVerifier.verify(objectToBeTested));
40 | resetObject();
41 |
42 | objectToBeTested.lesserOrEqualInvalidNonNumber = "abc";
43 | // Invalid value will be ignored
44 | assertTrue(DataVerifier.verify(objectToBeTested));
45 | resetObject();
46 |
47 | objectToBeTested.nonNullButCanEmptyString = null;
48 | assertFalse(DataVerifier.verify(objectToBeTested));
49 | resetObject();
50 |
51 | objectToBeTested.nonNullObject = null;
52 | assertFalse(DataVerifier.verify(objectToBeTested));
53 | resetObject();
54 |
55 | objectToBeTested.nonNullCannotEmptyString = "";
56 | assertFalse(DataVerifier.verify(objectToBeTested));
57 | resetObject();
58 |
59 | objectToBeTested.nonNullCannotEmptyString = null;
60 | assertFalse(DataVerifier.verify(objectToBeTested));
61 | resetObject();
62 |
63 | objectToBeTested.nonNullCannotEmptyObject = new Double(1.0);
64 | assertTrue(DataVerifier.verify(objectToBeTested));
65 | resetObject();
66 |
67 | objectToBeTested.nonNullCannotEmptyObject = null;
68 | assertFalse(DataVerifier.verify(objectToBeTested));
69 | resetObject();
70 |
71 | objectToBeTested.mustIn123Int = 0;
72 | assertFalse(DataVerifier.verify(objectToBeTested));
73 | resetObject();
74 |
75 | objectToBeTested.mustInApplePearRikkaString = "233";
76 | assertFalse(DataVerifier.verify(objectToBeTested));
77 | resetObject();
78 |
79 | objectToBeTested.mustInApplePearRikkaString = null;
80 | assertFalse(DataVerifier.verify(objectToBeTested));
81 | resetObject();
82 |
83 | objectToBeTested.shouldGreaterThanN10AndLesserThan0Int = -10;
84 | assertFalse(DataVerifier.verify(objectToBeTested));
85 | resetObject();
86 |
87 | objectToBeTested.shouldGreaterThanN10AndLesserThan0Int = 10;
88 | assertFalse(DataVerifier.verify(objectToBeTested));
89 | resetObject();
90 | }
91 |
92 | private void resetObject () {
93 | objectToBeTested = new SampleObject();
94 | }
95 | }
--------------------------------------------------------------------------------
/server/src/main/kotlin/moe/yuuta/server/api/PushRequest.kt:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.api
2 |
3 | import com.fasterxml.jackson.annotation.JsonProperty
4 | import moe.yuuta.common.Constants.DISPLAY_ALL
5 | import moe.yuuta.common.Constants.DISPLAY_LIGHTS
6 | import moe.yuuta.common.Constants.DISPLAY_SOUND
7 | import moe.yuuta.common.Constants.DISPLAY_VIBRATE
8 | import moe.yuuta.common.Constants.PUSH_DELAY_MS_MAX
9 | import moe.yuuta.common.Constants.REG_ID_TYPE_ACCOUNT
10 | import moe.yuuta.common.Constants.REG_ID_TYPE_ALIAS
11 | import moe.yuuta.common.Constants.REG_ID_TYPE_REG_ID
12 | import moe.yuuta.server.dataverify.GreatLess
13 | import moe.yuuta.server.dataverify.GreatLessGroup
14 | import moe.yuuta.server.dataverify.Nonnull
15 | import moe.yuuta.server.dataverify.NumberIn
16 |
17 | @SuppressWarnings("unused")
18 | data class PushRequest(
19 | @JsonProperty("registration_id")
20 | @Nonnull(nonEmpty = true)
21 | var registrationId: String? = null,
22 | @JsonProperty("reg_id_type")
23 | @NumberIn([REG_ID_TYPE_REG_ID.toDouble(), REG_ID_TYPE_ACCOUNT.toDouble(), REG_ID_TYPE_ALIAS.toDouble()])
24 | var regIdType: Int = REG_ID_TYPE_REG_ID,
25 | @JsonProperty("delay_ms")
26 | @GreatLessGroup([GreatLess(targetValue = 0, greater = true, equal = true),
27 | GreatLess(targetValue = PUSH_DELAY_MS_MAX.toLong(), lesser = true, equal = true)])
28 | var delayMs: Int = 0,
29 | @JsonProperty("pass_through")
30 | var passThrough: Boolean = false,
31 | @JsonProperty("notify_foreground")
32 | var notifyForeground: Boolean = true,
33 | @JsonProperty("enforce_wifi")
34 | var enforceWifi: Boolean = false,
35 | @JsonProperty("display")
36 | @NumberIn([DISPLAY_ALL.toDouble(), DISPLAY_LIGHTS.toDouble(), DISPLAY_SOUND.toDouble(), DISPLAY_VIBRATE.toDouble()])
37 | var display: Int = DISPLAY_ALL,
38 | @GreatLess(targetValue = 0, greater = true, equal = true)
39 | @JsonProperty("notify_id")
40 | var notifyId: Int = 0,
41 | @JsonProperty("sound_uri")
42 | var soundUri: String? = null,
43 | @JsonProperty("callback")
44 | var callback: String? = null,
45 | /**
46 | * The action when the notification is clicked.
47 | * Null - Launch app
48 | * else - Launch URL
49 | * intent: - Launch Intent
50 | */
51 | @JsonProperty("click_action")
52 | var clickAction: String? = null,
53 | @JsonProperty("locales")
54 | var locales: MutableList? = null,
55 | @JsonProperty("locales_except")
56 | var localesExcept: MutableList? = null,
57 | @JsonProperty("models")
58 | var models: MutableList? = null,
59 | @JsonProperty("models_except")
60 | var modelsExcept: MutableList? = null,
61 | @JsonProperty("versions")
62 | var versions: MutableList? = null /* Version name */,
63 | @JsonProperty("versions_except")
64 | var versionsExcept: MutableList? = null /* Version name */,
65 | @JsonProperty("extras")
66 | var extras: MutableMap? = null,
67 | @JsonProperty("global")
68 | var global: Boolean = false,
69 | @JsonProperty("pass_through_notification")
70 | var passThroughNotification: Boolean = false
71 | )
--------------------------------------------------------------------------------
/server/src/test/java/moe/yuuta/server/topic/TopicRegistryTest.java:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.topic;
2 |
3 | import org.junit.After;
4 | import org.junit.Before;
5 | import org.junit.Test;
6 | import org.junit.runner.RunWith;
7 | import org.mockito.Mockito;
8 |
9 | import java.util.ArrayList;
10 | import java.util.Arrays;
11 |
12 | import io.vertx.core.Future;
13 | import io.vertx.core.Vertx;
14 | import io.vertx.ext.unit.Async;
15 | import io.vertx.ext.unit.TestContext;
16 | import io.vertx.ext.unit.junit.VertxUnitRunner;
17 |
18 | import static org.junit.Assert.assertEquals;
19 | import static org.junit.Assert.assertNotNull;
20 | import static org.junit.Assert.assertNull;
21 | import static org.junit.Assert.assertTrue;
22 |
23 | @RunWith(VertxUnitRunner.class)
24 | public class TopicRegistryTest {
25 | private Vertx vertx;
26 | private TopicRegistry registry;
27 |
28 | private TopicExecuteVerticle mockVerticle;
29 |
30 | @Before
31 | public void setUp(TestContext testContext) {
32 | vertx = Vertx.vertx();
33 | registry = new TopicRegistry();
34 | registry = Mockito.spy(registry);
35 | mockVerticle = Mockito.spy(new TopicExecuteVerticle() {
36 | });
37 | Mockito.when(registry.getDefaultTopics()).thenReturn(Arrays.asList(new Topic("title", "description",
38 | "mock_topic", mockVerticle, null, null, null)));
39 |
40 | Async async = testContext.async();
41 | // Registering topic & unregistering topic and some stuff about Topic/register/unregister and TopicExecuteVerticle
42 | // will be tested here and tearDown(). So we needn't to test again.
43 | registry.init(vertx, ar -> {
44 | assertTrue(ar.succeeded());
45 | assertNull(ar.cause());
46 | try {
47 | Mockito.verify(mockVerticle, Mockito.times(1)).onRegister(Mockito.any(Future.class));
48 | } catch (Exception e) {
49 | testContext.fail(e);
50 | }
51 | async.complete();
52 | });
53 | }
54 |
55 | @After
56 | public void tearDown(TestContext testContext) {
57 | Async async = testContext.async();
58 | registry.clear(vertx, ar -> {
59 | assertTrue(ar.succeeded());
60 | assertNull(ar.cause());
61 | try {
62 | Mockito.verify(mockVerticle, Mockito.times(1)).onUnRegister(Mockito.any(Future.class));
63 | } catch (Exception e) {
64 | testContext.fail(e);
65 | }
66 | assertEquals(0, registry.allTopics().size());
67 | async.complete();
68 | });
69 | }
70 |
71 | @Test
72 | public void values() {
73 | assertNotNull(registry.values());
74 | assertEquals(1, registry.values().size());
75 | assertNotNull(registry.values().get("mock_topic"));
76 | }
77 |
78 | @Test
79 | public void allIds() {
80 | assertNotNull(registry.allIds());
81 | assertEquals(1, registry.allIds().size());
82 | assertEquals("mock_topic", registry.allIds().iterator().next());
83 | }
84 |
85 | @Test
86 | public void allTopics() {
87 | assertNotNull(registry.allIds());
88 | assertEquals(1, registry.allTopics().size());
89 | assertNotNull(new ArrayList<>(registry.allTopics()).get(0));
90 | }
91 |
92 | @Test
93 | public void getTopic() {
94 | assertNotNull(registry.getTopic("mock_topic"));
95 | assertEquals("mock_topic", registry.getTopic("mock_topic").getId());
96 | }
97 | }
--------------------------------------------------------------------------------
/server/src/main/kotlin/moe/yuuta/server/res/Resources.kt:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.res
2 |
3 | import io.vertx.core.http.HttpServerRequest
4 | import io.vertx.ext.web.LanguageHeader
5 | import io.vertx.ext.web.RoutingContext
6 | import moe.yuuta.common.Constants.HEADER_LOCALE
7 | import java.nio.charset.StandardCharsets
8 | import java.util.*
9 |
10 | object Resources {
11 | @JvmStatic
12 | fun getBundle(locale: Locale): ResourceBundle =
13 | ResourceBundle.getBundle("strings", locale)
14 |
15 | @JvmStatic
16 | fun isDefaultLocale(key: String, requestLocale: Locale): Boolean {
17 | try {
18 | return getStringInBundleInUTF8(key, getBundle(requestLocale)) == ""
19 | } catch (e: MissingResourceException) {
20 | return true
21 | }
22 | }
23 |
24 | @JvmStatic
25 | fun getString(key: String, locale: Locale, vararg formatArgs: Any): String {
26 | val strings = getBundle(locale)
27 | return String.format(getStringInBundleInUTF8(key, strings), formatArgs)
28 | }
29 |
30 | @JvmStatic
31 | private fun getStringInBundleInUTF8(key: String, resourceBundle: ResourceBundle): String {
32 | return String(resourceBundle.getString(key).toByteArray(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8)
33 | }
34 |
35 | private val CHINESE_COUNTRY_AND_REGIONS = arrayOf(
36 | "CN", // 大陆
37 | "HK", // 香港
38 | "MO", // 澳门
39 | "TW", // 台湾
40 | "CHS", // 简体中文
41 | "CHT", // 繁体中文
42 | "Hans", // = CHS
43 | "Hant", // = CHT
44 | "SG" // 新加坡
45 | )
46 |
47 | @JvmStatic
48 | private fun getRequestHeaderLocale(request: HttpServerRequest?): Locale {
49 | // TODO: Fix this BAD logic
50 | if (request == null) {
51 | return Locale.getDefault()
52 | }
53 | val clientCountryOrRegion = request.getHeader(HEADER_LOCALE)
54 | if (clientCountryOrRegion == null) {
55 | return Locale.getDefault()
56 | }
57 | for (cOR in CHINESE_COUNTRY_AND_REGIONS) {
58 | if (clientCountryOrRegion.toLowerCase().contains(cOR.toLowerCase())) {
59 | return Locale("zh" /* We only support zh now*/)
60 | }
61 | }
62 | return Locale.getDefault()
63 | }
64 |
65 | @JvmStatic
66 | fun getRequestLocale(languageHeader: LanguageHeader?, request: HttpServerRequest?): Locale {
67 | return if (languageHeader == null) getRequestHeaderLocale(request) else Locale(getNonNullString(languageHeader.tag()),
68 | getNonNullString(languageHeader.subtag()),
69 | getNonNullString(languageHeader.subtag(2)))
70 | }
71 |
72 | @JvmStatic
73 | fun getString (key: String, languageHeader: LanguageHeader, vararg formatArgs: Any): String {
74 | return getValueOrResourcesString(key, getRequestLocale(languageHeader, null), formatArgs)
75 | }
76 |
77 | @JvmStatic
78 | fun getString(key: String, routingContext: RoutingContext, vararg formatArgs: Any): String {
79 | return getValueOrResourcesString(key, getRequestLocale(routingContext.preferredLanguage(), null), formatArgs)
80 | }
81 |
82 | @JvmStatic
83 | private fun getNonNullString(nullableString: String?): String {
84 | if (nullableString == null)
85 | return ""
86 | return nullableString
87 | }
88 |
89 | @JvmStatic
90 | fun getValueOrResourcesString(key: String, locale: Locale, vararg formatArgs: Any): String {
91 | return getString(key, locale, formatArgs)
92 | }
93 | }
--------------------------------------------------------------------------------
/server/src/main/kotlin/moe/yuuta/server/topic/TopicRegistry.kt:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.topic
2 |
3 | import io.vertx.core.*
4 | import moe.yuuta.server.topic.every5min.Every5MinTopicVerticle
5 | import java.util.*
6 | import java.util.stream.Collectors
7 |
8 | open class TopicRegistry {
9 | companion object {
10 | private var instance: TopicRegistry? = null
11 |
12 | @JvmStatic
13 | fun get(): TopicRegistry {
14 | if (instance == null) instance = TopicRegistry()
15 | return instance as TopicRegistry
16 | }
17 | }
18 |
19 | private val mTopicRegistry: MutableMap = mutableMapOf()
20 |
21 | open fun getDefaultTopics(): List =
22 | kotlin.collections.emptyList()
23 |
24 | fun init(vertx: Vertx, handler: Handler>) {
25 | CompositeFuture.all(
26 | getDefaultTopics()
27 | .stream()
28 | .map { topic -> Future.future { registerTopic(topic, vertx, it) } }
29 | .collect(Collectors.toList())
30 | ).setHandler(handler)
31 | }
32 |
33 | open fun values(): Map = mTopicRegistry.toMap()
34 |
35 | open fun allIds(): Set = mTopicRegistry.keys
36 |
37 | open fun allTopics(): Collection = mTopicRegistry.values
38 |
39 | fun registerTopic(topic: Topic, vertx: Vertx, handler: Handler>) {
40 | topic.onRegister(vertx, Handler {
41 | if (it.succeeded()) {
42 | mTopicRegistry.put(topic.id, topic)
43 | }
44 | handler.handle(object : AsyncResult {
45 | @Override
46 | override fun result(): Any? = it.result()
47 |
48 | @Override
49 | override fun cause(): Throwable? = it.cause()
50 |
51 | @Override
52 | override fun succeeded(): Boolean = it.succeeded()
53 |
54 | @Override
55 | override fun failed(): Boolean = it.failed()
56 | })
57 | })
58 | }
59 |
60 | open fun getTopic(id: String): Topic? =
61 | mTopicRegistry.get(id)
62 |
63 | fun unregisterTopic(id: String, vertx: Vertx, handler: Handler>) {
64 | val topic = getTopic(id)
65 | if (topic == null)
66 | throw IllegalArgumentException("$id can't be found")
67 | // TODO: Unregister when verticle "dies"
68 | topic.onUnRegister(vertx, Handler { it ->
69 | if (it.succeeded()) {
70 | mTopicRegistry.remove(id)
71 | }
72 | handler.handle(object : AsyncResult {
73 | @Override
74 | override fun result(): Any? = it.result()
75 |
76 | @Override
77 | override fun cause(): Throwable? = it.cause()
78 |
79 | @Override
80 | override fun succeeded(): Boolean = it.succeeded()
81 |
82 | @Override
83 | override fun failed(): Boolean = it.failed()
84 | })
85 | })
86 | }
87 |
88 | fun clear(vertx: Vertx, handler: Handler>) {
89 | val list = mutableListOf>()
90 | val topics = mTopicRegistry.values.toMutableList()
91 | for (i in topics.indices) {
92 | val topic = topics.get(i)
93 | list.add(Future.future { unregisterTopic(topic.id, vertx, it.completer()) })
94 | }
95 | CompositeFuture.all(list).setHandler(handler)
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/app/src/main/res/layout/layout_multi_state.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
8 |
9 |
15 |
16 |
29 |
41 |
53 |
65 |
74 |
75 |
--------------------------------------------------------------------------------
/app/src/main/res/layout/item_accept_time.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
10 |
11 |
19 |
22 |
33 |
34 |
45 |
46 |
57 |
58 |
66 |
74 |
75 |
76 |
--------------------------------------------------------------------------------
/server/src/main/kotlin/moe/yuuta/server/mipush/MiPushApi.kt:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.mipush
2 |
3 | import io.vertx.core.AsyncResult
4 | import io.vertx.core.Handler
5 | import io.vertx.core.buffer.Buffer
6 | import io.vertx.core.http.HttpClient
7 | import io.vertx.core.http.HttpMethod
8 | import io.vertx.core.http.RequestOptions
9 | import io.vertx.core.logging.LoggerFactory
10 | import io.vertx.ext.web.client.HttpRequest
11 | import io.vertx.ext.web.client.HttpResponse
12 | import io.vertx.ext.web.client.WebClient
13 | import io.vertx.ext.web.codec.BodyCodec
14 | import moe.yuuta.common.Constants
15 | import moe.yuuta.server.formprocessor.HttpForm
16 |
17 | // TODO: Add tests
18 | open class MiPushApi(private val httpClient: HttpClient?) {
19 | companion object {
20 | const val HOST_CHINA = "api.xmpush.xiaomi.com"
21 | const val HOST_GLOBAL = "api.xmpush.global.xiaomi.com"
22 |
23 | @JvmStatic
24 | private fun buildExtras(customExtras: Map): String {
25 | val extrasBuilder = StringBuilder()
26 | for (key in customExtras.keys) {
27 | extrasBuilder.append("extra.")
28 | extrasBuilder.append(key)
29 | extrasBuilder.append("=")
30 | extrasBuilder.append(customExtras.get(key))
31 | extrasBuilder.append("&")
32 | }
33 | var extras = extrasBuilder.toString()
34 | extras = extras.substring(0, extras.length - 1)
35 | return extras
36 | }
37 | }
38 |
39 | open fun pushOnce(message: Message, regId: String, regIdType: Int, customExtras: Map?, useGlobal: Boolean, handler: Handler>>) {
40 | val apiUrl: String = when (regIdType) {
41 | Constants.REG_ID_TYPE_REG_ID -> {
42 | message.regId = regId
43 | "/v3/message/regid"
44 | }
45 | Constants.REG_ID_TYPE_ACCOUNT -> {
46 | message.account = regId
47 | "/v2/message/user_account"
48 | }
49 | Constants.REG_ID_TYPE_ALIAS -> {
50 | message.alias = regId
51 | "/v3/message/alias"
52 | }
53 | else -> "/v3/message/regid"
54 | }
55 | val arguments = HttpForm.toBuffer(message)
56 | if (customExtras != null) {
57 | arguments.appendString("&" + buildExtras(customExtras))
58 | }
59 | LoggerFactory.getLogger(MiPushApi::class.java).error("Sending to $apiUrl , regIdWithType=$regId, $regIdType")
60 | LoggerFactory.getLogger(MiPushApi::class.java).error(arguments.toString())
61 | generateHttpCall(HttpMethod.POST, apiUrl, useGlobal)
62 | .`as`(BodyCodec.json(SendMessageResponse::class.java))
63 | .putHeader("Content-Type", "application/x-www-form-urlencoded")
64 | .sendBuffer(arguments, handler)
65 | }
66 |
67 | fun pushOnceToTopic (message: Message, topic: String, customExtras: Map?, useGlobal: Boolean, handler: Handler>>) {
68 | val arguments = HttpForm.toBuffer(message)
69 | arguments.appendString("&topic=$topic")
70 | if (customExtras != null) {
71 | arguments.appendString("&" + buildExtras(customExtras))
72 | }
73 | generateHttpCall(HttpMethod.POST, "/v3/message/topic", useGlobal)
74 | .`as`(BodyCodec.json(SendMessageResponse::class.java))
75 | .putHeader("Content-Type", "application/x-www-form-urlencoded")
76 | .sendBuffer(arguments, handler)
77 | }
78 |
79 | private fun generateHttpCall (method: HttpMethod, path: String, useGlobal: Boolean): HttpRequest {
80 | val webClient = WebClient.wrap(httpClient)
81 | return webClient.request(method, RequestOptions()
82 | .setPort(443)
83 | .setHost(if (useGlobal) HOST_GLOBAL else HOST_CHINA)
84 | .setSsl(true)
85 | .setURI(path))
86 | .putHeader("Authorization", "key=" + System.getenv("MIPUSH_AUTH"))
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/app/src/main/res/xml/preference_send_push.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
9 |
18 |
25 |
30 |
35 |
40 |
45 |
47 |
54 |
61 |
62 |
64 |
69 |
74 |
79 |
84 |
89 |
90 |
--------------------------------------------------------------------------------
/server/src/test/java/moe/yuuta/server/api/ApiVerticleTest.java:
--------------------------------------------------------------------------------
1 | package moe.yuuta.server.api;
2 |
3 | import org.jetbrains.annotations.NotNull;
4 | import org.junit.After;
5 | import org.junit.Before;
6 | import org.junit.Test;
7 | import org.junit.runner.RunWith;
8 | import org.mockito.Mockito;
9 |
10 | import io.vertx.core.Vertx;
11 | import io.vertx.ext.unit.Async;
12 | import io.vertx.ext.unit.TestContext;
13 | import io.vertx.ext.unit.junit.VertxUnitRunner;
14 | import io.vertx.ext.web.RoutingContext;
15 |
16 | import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
17 |
18 | @RunWith(VertxUnitRunner.class)
19 | public class ApiVerticleTest {
20 | private ApiVerticle apiVerticle;
21 | private Vertx vertx;
22 | private ApiHandler stubApiHandler;
23 |
24 | @Before
25 | public void setUp (TestContext testContext) {
26 | vertx = Vertx.vertx();
27 | stubApiHandler = new ApiHandler() {
28 | @Override
29 | public void handlePush(@NotNull RoutingContext routingContext) {
30 | routingContext.response().setStatusCode(NO_CONTENT.code()).end();
31 | }
32 |
33 | @Override
34 | public void handleFrameworkIndex(@NotNull RoutingContext routingContext) {
35 | routingContext.response().setStatusCode(NO_CONTENT.code()).end();
36 | }
37 |
38 | @Override
39 | public void handleTesterIndex(@NotNull RoutingContext routingContext) {
40 | routingContext.response().setStatusCode(NO_CONTENT.code()).end();
41 | }
42 |
43 | @Override
44 | public void handleUpdate(@NotNull RoutingContext routingContext) {
45 | routingContext.response().setStatusCode(NO_CONTENT.code()).end();
46 | }
47 |
48 | @Override
49 | public void handleGetTopicList(@NotNull RoutingContext routingContext) {
50 | routingContext.response().setStatusCode(NO_CONTENT.code()).end();
51 | }
52 | };
53 | apiVerticle = Mockito.spy(new ApiVerticle());
54 | // It will be called BEFORE started, so we have to mock it before deploying
55 | Mockito.when(apiVerticle.getApiHandler()).thenReturn(stubApiHandler);
56 | vertx.deployVerticle(apiVerticle, testContext.asyncAssertSuccess());
57 | }
58 |
59 | @Test(timeout = 2000)
60 | public void shouldGetIndex (TestContext testContext) {
61 | Async async = testContext.async();
62 | vertx.createHttpClient().getNow(8080, "localhost", ApiVerticle.ROUTE, response -> {
63 | testContext.assertEquals(response.statusCode(), NO_CONTENT.code());
64 | async.complete();
65 | });
66 | }
67 |
68 | @Test(timeout = 2000)
69 | public void shouldGetTesterIndex (TestContext testContext) {
70 | Async async = testContext.async();
71 | vertx.createHttpClient().getNow(8080, "localhost", ApiVerticle.ROUTE_TEST, response -> {
72 | testContext.assertEquals(response.statusCode(), NO_CONTENT.code());
73 | async.complete();
74 | });
75 | }
76 |
77 | @Test(timeout = 2000)
78 | public void shouldPush (TestContext testContext) {
79 | Async async = testContext.async();
80 | vertx.createHttpClient().post(8080, "localhost", ApiVerticle.ROUTE_TEST, response -> {
81 | testContext.assertEquals(response.statusCode(), NO_CONTENT.code());
82 | async.complete();
83 | }).end();
84 | }
85 |
86 | @Test(timeout = 2000)
87 | public void shouldGetUpdate (TestContext testContext) {
88 | Async async = testContext.async();
89 | vertx.createHttpClient().getNow(8080, "localhost", ApiVerticle.ROUTE_UPDATE, response -> {
90 | testContext.assertEquals(response.statusCode(), NO_CONTENT.code());
91 | async.complete();
92 | });
93 | }
94 |
95 | @Test(timeout = 2000)
96 | public void shouldGetTopicList (TestContext testContext) {
97 | Async async = testContext.async();
98 | vertx.createHttpClient().getNow(8080, "localhost", ApiVerticle.ROUTE_TEST_TOPIC, response -> {
99 | testContext.assertEquals(response.statusCode(), NO_CONTENT.code());
100 | async.complete();
101 | });
102 | }
103 |
104 | @After
105 | public void tearDown (TestContext testContext) {
106 | vertx.close(testContext.asyncAssertSuccess());
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/app/src/main/kotlin/utils/Utils.kt:
--------------------------------------------------------------------------------
1 | package moe.yuuta.mipushtester.utils
2 |
3 | import android.app.AlarmManager
4 | import android.app.PendingIntent
5 | import android.content.Context
6 | import android.content.Intent
7 | import android.os.Bundle
8 | import android.os.Handler
9 | import android.os.Looper
10 | import android.os.Process
11 | import com.google.gson.Gson
12 | import com.google.gson.JsonArray
13 | import com.google.gson.JsonObject
14 | import moe.yuuta.mipushtester.MainActivity
15 | import java.lang.reflect.Field
16 | import java.lang.reflect.Modifier
17 |
18 | object Utils {
19 | fun restart(context: Context) {
20 | val mStartActivity = Intent(context, MainActivity::class.java)
21 | val mPendingIntentId = 2333
22 | val mPendingIntent = PendingIntent.getActivity(context, mPendingIntentId, mStartActivity, PendingIntent.FLAG_CANCEL_CURRENT)
23 | val mgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
24 | mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent)
25 |
26 | Handler(Looper.getMainLooper()).postDelayed( {
27 | System.exit(0)
28 | Process.killProcess(Process.myPid())
29 | Runtime.getRuntime().exit(0)
30 | }, 100)
31 | }
32 |
33 | fun dumpIntent(intent: Intent): String {
34 | val trackMs: Long = System.currentTimeMillis()
35 | val rootJson: JsonObject = JsonObject()
36 | rootJson.addProperty("action", intent.action)
37 | val categoriesJson: JsonArray = JsonArray()
38 | if (intent.categories != null) {
39 | for (category in intent.categories) {
40 | categoriesJson.add(category)
41 | }
42 | }
43 | rootJson.add("categories", categoriesJson)
44 | rootJson.addProperty("clip_data_has", intent.clipData != null)
45 | val componentJson: JsonObject = JsonObject()
46 | componentJson.addProperty("package_name", intent.component?.packageName ?: "(Null)")
47 | componentJson.addProperty("class_name", intent.component?.className ?: "(Null)")
48 | rootJson.add("component", componentJson)
49 | rootJson.addProperty("data_string", intent.dataString)
50 | rootJson.addProperty("flag_raw", intent.flags)
51 | val flagFields: Array? = Intent::class.java.declaredFields
52 | val flagsJson: JsonArray = JsonArray()
53 | if (flagFields != null) {
54 | for (flag in flagFields) {
55 | if (Modifier.isFinal(flag.modifiers) &&
56 | Modifier.isPublic(flag.modifiers) &&
57 | Modifier.isStatic(flag.modifiers) &&
58 | flag.name.startsWith("FLAG_")) {
59 | try {
60 | val value: Int = flag.get(null) as Int
61 | if ((intent.flags and value) != 0) {
62 | flagsJson.add(flag.name)
63 | }
64 | } catch (ignored: Exception) {}
65 | }
66 | }
67 | }
68 | rootJson.add("flags", flagsJson)
69 | rootJson.addProperty("package", intent.`package`)
70 | rootJson.addProperty("scheme", intent.scheme)
71 | rootJson.addProperty("selector_has", intent.selector != null)
72 | rootJson.addProperty("source_bounds_has", intent.sourceBounds != null)
73 | rootJson.addProperty("type", intent.type)
74 | rootJson.add("extras", dumpExtras(intent.extras))
75 | if (intent.hasExtra("mipush_payload")) {
76 | val payload: ByteArray = intent.getByteArrayExtra("mipush_payload")
77 | // TODO: Deserialize payload
78 | val payloadArray: JsonArray = JsonArray()
79 | for (byte in payload) {
80 | payloadArray.add(byte)
81 | }
82 | rootJson.add("payload", payloadArray)
83 | }
84 | rootJson.addProperty("took", System.currentTimeMillis() - trackMs)
85 | return Gson().toJson(rootJson)
86 | }
87 |
88 | fun dumpExtras(bundle: Bundle?): JsonArray {
89 | val extrasJson: JsonArray = JsonArray()
90 | if (bundle != null) {
91 | for (key in bundle.keySet()) {
92 | val value = bundle.get(key)
93 | val obj: JsonObject = JsonObject()
94 | obj.addProperty("value", value?.toString())
95 | obj.addProperty("key", key)
96 | obj.addProperty("value_type", value.javaClass.name)
97 | extrasJson.add(obj)
98 | }
99 | }
100 | return extrasJson
101 | }
102 | }
--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
19 |
20 |
21 |
22 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
43 |
47 |
53 |
57 |
60 |
63 |
64 |
65 |
66 |
67 |
68 |
72 |
73 |
74 |
75 |
76 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
91 |
96 |
99 |
100 |
101 |
102 |
--------------------------------------------------------------------------------