Import settings from Riot - not all fonctional of course

vector/src/gplay/AndroidManifest.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application>
+
+        <!-- Firebase components -->
+        <meta-data
+            android:name="firebase_analytics_collection_deactivated"
+            android:value="true" />
+
+        <service android:name="im.vector.push.fcm.VectorFirebaseMessagingService">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
+
+    </application>
+
+</manifest>

vector/src/gplay/google-services.json

@@ -0,0 +1,46 @@
+{
+  "project_info": {
+    "project_number": "912726360885",
+    "firebase_url": "https://vector-alpha.firebaseio.com",
+    "project_id": "vector-alpha",
+    "storage_bucket": "vector-alpha.appspot.com"
+  },
+  "client": [
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:912726360885:android:448c9b63161abc9c",
+        "android_client_info": {
+          "package_name": "im.vector.riotredesign"
+        }
+      },
+      "oauth_client": [
+        {
+          "client_id": "912726360885-rsae0i66rgqt6ivnudu1pv4tksg9i8b2.apps.googleusercontent.com",
+          "client_type": 3
+        },
+        {
+          "client_id": "912726360885-e87n3jva9uoj4vbidvijq78ebg02asv2.apps.googleusercontent.com",
+          "client_type": 3
+        }
+      ],
+      "api_key": [
+        {
+          "current_key": "AIzaSyAFZX8IhIfgzdOZvxDP_ISO5WYoU7jmQ5c"
+        }
+      ],
+      "services": {
+        "analytics_service": {
+          "status": 1
+        },
+        "appinvite_service": {
+          "status": 1,
+          "other_platform_oauth_client": []
+        },
+        "ads_service": {
+          "status": 2
+        }
+      }
+    }
+  ],
+  "configuration_version": "1"
+}

vector/src/gplay/java/im/vector/push/fcm/FcmHelper.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2014 OpenMarket Ltd
+ * Copyright 2017 Vector Creations Ltd
+ * Copyright 2018 New Vector Ltd
+ *
+ * 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.
+ */
+package im.vector.push.fcm;
+
+import android.app.Activity;
+import android.content.Context;
+import android.preference.PreferenceManager;
+import android.text.TextUtils;
+import android.widget.Toast;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.firebase.iid.FirebaseInstanceId;
+import com.google.firebase.iid.InstanceIdResult;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import im.vector.riotredesign.R;
+import timber.log.Timber;
+
+/**
+ * This class store the FCM token in SharedPrefs and ensure this token is retrieved.
+ * It has an alter ego in the fdroid variant.
+ */
+public class FcmHelper {
+    private static final String LOG_TAG = FcmHelper.class.getSimpleName();
+
+    private static final String PREFS_KEY_FCM_TOKEN = "FCM_TOKEN";
+
+    /**
+     * Retrieves the FCM registration token.
+     *
+     * @return the FCM token or null if not received from FCM
+     */
+    @Nullable
+    public static String getFcmToken(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context).getString(PREFS_KEY_FCM_TOKEN, null);
+    }
+
+    /**
+     * Store FCM token to the SharedPrefs
+     *
+     * @param context android context
+     * @param token   the token to store
+     */
+    public static void storeFcmToken(@NonNull Context context,
+                                     @Nullable String token) {
+        PreferenceManager.getDefaultSharedPreferences(context)
+                .edit()
+                .putString(PREFS_KEY_FCM_TOKEN, token)
+                .apply();
+    }
+
+    /**
+     * onNewToken may not be called on application upgrade, so ensure my shared pref is set
+     *
+     * @param activity the first launch Activity
+     */
+    public static void ensureFcmTokenIsRetrieved(final Activity activity) {
+        if (TextUtils.isEmpty(getFcmToken(activity))) {
+
+
+            //vfe: according to firebase doc
+            //'app should always check the device for a compatible Google Play services APK before accessing Google Play services features'
+            if (checkPlayServices(activity)) {
+                try {
+                    FirebaseInstanceId.getInstance().getInstanceId()
+                            .addOnSuccessListener(activity, new OnSuccessListener<InstanceIdResult>() {
+                                @Override
+                                public void onSuccess(InstanceIdResult instanceIdResult) {
+                                    storeFcmToken(activity, instanceIdResult.getToken());
+                                }
+                            })
+                            .addOnFailureListener(activity, new OnFailureListener() {
+                                @Override
+                                public void onFailure(@NonNull Exception e) {
+                                    Timber.e(e, "## ensureFcmTokenIsRetrieved() : failed " + e.getMessage());
+                                }
+                            });
+                } catch (Throwable e) {
+                    Timber.e(e, "## ensureFcmTokenIsRetrieved() : failed " + e.getMessage());
+                }
+            } else {
+                Toast.makeText(activity, R.string.no_valid_google_play_services_apk, Toast.LENGTH_SHORT).show();
+                Timber.e("No valid Google Play Services found. Cannot use FCM.");
+            }
+        }
+    }
+
+    /**
+     * Check the device to make sure it has the Google Play Services APK. If
+     * it doesn't, display a dialog that allows users to download the APK from
+     * the Google Play Store or enable it in the device's system settings.
+     */
+    private static boolean checkPlayServices(Activity activity) {
+        GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
+        int resultCode = apiAvailability.isGooglePlayServicesAvailable(activity);
+        if (resultCode != ConnectionResult.SUCCESS) {
+            return false;
+        }
+        return true;
+    }
+}

vector/src/gplay/java/im/vector/push/fcm/NotificationTroubleshootTestManagerFactory.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * 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.
+ */
+package im.vector.push.fcm
+
+import androidx.fragment.app.Fragment
+import im.vector.fragments.troubleshoot.TestAccountSettings
+import im.vector.matrix.android.api.session.Session
+import im.vector.push.fcm.troubleshoot.TestFirebaseToken
+import im.vector.push.fcm.troubleshoot.TestPlayServices
+import im.vector.push.fcm.troubleshoot.TestTokenRegistration
+import im.vector.riotredesign.features.settings.troubleshoot.NotificationTroubleshootTestManager
+import im.vector.riotredesign.features.settings.troubleshoot.TestBingRulesSettings
+import im.vector.riotredesign.features.settings.troubleshoot.TestDeviceSettings
+import im.vector.riotredesign.features.settings.troubleshoot.TestSystemSettings
+
+class NotificationTroubleshootTestManagerFactory {
+
+    companion object {
+        fun createTestManager(fragment: Fragment, session: Session?): NotificationTroubleshootTestManager {
+            val mgr = NotificationTroubleshootTestManager(fragment)
+            mgr.addTest(TestSystemSettings(fragment))
+            if (session != null) {
+                mgr.addTest(TestAccountSettings(fragment, session))
+            }
+            mgr.addTest(TestDeviceSettings(fragment))
+            if (session != null) {
+                mgr.addTest(TestBingRulesSettings(fragment, session))
+            }
+            mgr.addTest(TestPlayServices(fragment))
+            mgr.addTest(TestFirebaseToken(fragment))
+            mgr.addTest(TestTokenRegistration(fragment))
+            return mgr
+        }
+    }
+
+}

vector/src/gplay/java/im/vector/push/fcm/VectorFirebaseMessagingService.kt

@@ -0,0 +1,271 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ *
+ * 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.
+ */
+
+package im.vector.push.fcm
+
+import android.os.Handler
+import android.os.Looper
+import android.text.TextUtils
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.riotredesign.BuildConfig
+import im.vector.riotredesign.R
+import im.vector.riotredesign.core.preference.BingRule
+import im.vector.riotredesign.features.badge.BadgeProxy
+import im.vector.riotredesign.features.notifications.NotifiableEventResolver
+import im.vector.riotredesign.features.notifications.NotifiableMessageEvent
+import im.vector.riotredesign.features.notifications.NotificationDrawerManager
+import im.vector.riotredesign.features.notifications.SimpleNotifiableEvent
+import org.koin.android.ext.android.inject
+import timber.log.Timber
+
+/**
+ * Class extending FirebaseMessagingService.
+ */
+class VectorFirebaseMessagingService : FirebaseMessagingService() {
+
+    val notificationDrawerManager by inject<NotificationDrawerManager>()
+
+    private val notifiableEventResolver by lazy {
+        NotifiableEventResolver(this)
+    }
+
+    // UI handler
+    private val mUIHandler by lazy {
+        Handler(Looper.getMainLooper())
+    }
+
+    /**
+     * Called when message is received.
+     *
+     * @param message the message
+     */
+    override fun onMessageReceived(message: RemoteMessage?) {
+        if (message == null || message.data == null) {
+            Timber.e("## onMessageReceived() : received a null message or message with no data")
+            return
+        }
+        if (BuildConfig.LOW_PRIVACY_LOG_ENABLE) {
+            Timber.i("## onMessageReceived()" + message.data.toString())
+            Timber.i("## onMessageReceived() from FCM with priority " + message.priority)
+        }
+
+        //safe guard
+        /* TODO
+        val pushManager = Matrix.getInstance(applicationContext).pushManager
+        if (!pushManager.areDeviceNotificationsAllowed()) {
+            Timber.i("## onMessageReceived() : the notifications are disabled")
+            return
+        }
+        */
+
+        //TODO if the app is in foreground, we could just ignore this. The sync loop is already going?
+        // TODO mUIHandler.post { onMessageReceivedInternal(message.data, pushManager) }
+    }
+
+    /**
+     * Called if InstanceID token is updated. This may occur if the security of
+     * the previous token had been compromised. Note that this is also called
+     * when the InstanceID token is initially generated, so this is where
+     * you retrieve the token.
+     */
+    override fun onNewToken(refreshedToken: String?) {
+        Timber.i("onNewToken: FCM Token has been updated")
+        FcmHelper.storeFcmToken(this, refreshedToken)
+        // TODO Matrix.getInstance(this)?.pushManager?.resetFCMRegistration(refreshedToken)
+    }
+
+    override fun onDeletedMessages() {
+        Timber.d("## onDeletedMessages()")
+    }
+
+    /**
+     * Internal receive method
+     *
+     * @param data Data map containing message data as key/value pairs.
+     * For Set of keys use data.keySet().
+     */
+    private fun onMessageReceivedInternal(data: Map<String, String> /*, pushManager: PushManager*/) {
+        try {
+            if (BuildConfig.LOW_PRIVACY_LOG_ENABLE) {
+                Timber.i("## onMessageReceivedInternal() : $data")
+            }
+            // update the badge counter
+            val unreadCount = data.get("unread")?.let { Integer.parseInt(it) } ?: 0
+            BadgeProxy.updateBadgeCount(applicationContext, unreadCount)
+
+            /* TODO
+            val session = Matrix.getInstance(applicationContext)?.defaultSession
+
+            if (VectorApp.isAppInBackground() && !pushManager.isBackgroundSyncAllowed) {
+                //Notification contains metadata and maybe data information
+                handleNotificationWithoutSyncingMode(data, session)
+            } else {
+                // Safe guard... (race?)
+                if (isEventAlreadyKnown(data["event_id"], data["room_id"])) return
+                //Catch up!!
+                EventStreamServiceX.onPushReceived(this)
+            }
+            */
+        } catch (e: Exception) {
+            Timber.e(e, "## onMessageReceivedInternal() failed : " + e.message)
+        }
+    }
+
+    // check if the event was not yet received
+    // a previous catchup might have already retrieved the notified event
+    private fun isEventAlreadyKnown(eventId: String?, roomId: String?): Boolean {
+        if (null != eventId && null != roomId) {
+            try {
+                /* TODO
+                val sessions = Matrix.getInstance(applicationContext).sessions
+
+                if (null != sessions && !sessions.isEmpty()) {
+                    for (session in sessions) {
+                        if (session.dataHandler?.store?.isReady == true) {
+                            session.dataHandler.store?.getEvent(eventId, roomId)?.let {
+                                Timber.e("## isEventAlreadyKnown() : ignore the event " + eventId
+                                        + " in room " + roomId + " because it is already known")
+                                return true
+                            }
+                        }
+                    }
+                }
+                */
+            } catch (e: Exception) {
+                Timber.e(e, "## isEventAlreadyKnown() : failed to check if the event was already defined " + e.message)
+            }
+
+        }
+        return false
+    }
+
+    private fun handleNotificationWithoutSyncingMode(data: Map<String, String>, session: Session?) {
+
+        if (session == null) {
+            Timber.e("## handleNotificationWithoutSyncingMode cannot find session")
+            return
+        }
+
+        // The Matrix event ID of the event being notified about.
+        // This is required if the notification is about a particular Matrix event.
+        // It may be omitted for notifications that only contain updated badge counts.
+        // This ID can and should be used to detect duplicate notification requests.
+        val eventId = data["event_id"] ?: return //Just ignore
+
+
+        val eventType = data["type"]
+        if (eventType == null) {
+            //Just add a generic unknown event
+            val simpleNotifiableEvent = SimpleNotifiableEvent(
+                    session.sessionParams.credentials.userId,
+                    eventId,
+                    true, //It's an issue in this case, all event will bing even if expected to be silent.
+                    title = getString(R.string.notification_unknown_new_event),
+                    description = "",
+                    type = null,
+                    timestamp = System.currentTimeMillis(),
+                    soundName = BingRule.ACTION_VALUE_DEFAULT,
+                    isPushGatewayEvent = true
+            )
+            notificationDrawerManager.onNotifiableEventReceived(simpleNotifiableEvent)
+            notificationDrawerManager.refreshNotificationDrawer(null)
+
+            return
+        } else {
+
+            val event = parseEvent(data)
+            if (event?.roomId == null) {
+                //unsupported event
+                Timber.e("Received an event with no room id")
+                return
+            } else {
+
+                var notifiableEvent = notifiableEventResolver.resolveEvent(event, null, null /* TODO session.fulfillRule(event) */, session)
+
+                if (notifiableEvent == null) {
+                    Timber.e("Unsupported notifiable event ${eventId}")
+                    if (BuildConfig.LOW_PRIVACY_LOG_ENABLE) {
+                        Timber.e("--> ${event}")
+                    }
+                } else {
+
+
+                    if (notifiableEvent is NotifiableMessageEvent) {
+                        if (TextUtils.isEmpty(notifiableEvent.senderName)) {
+                            notifiableEvent.senderName = data["sender_display_name"] ?: data["sender"] ?: ""
+                        }
+                        if (TextUtils.isEmpty(notifiableEvent.roomName)) {
+                            notifiableEvent.roomName = findRoomNameBestEffort(data, session) ?: ""
+                        }
+                    }
+
+                    notifiableEvent.isPushGatewayEvent = true
+                    notifiableEvent.matrixID = session.sessionParams.credentials.userId
+                    notificationDrawerManager.onNotifiableEventReceived(notifiableEvent)
+                    notificationDrawerManager.refreshNotificationDrawer(null)
+                }
+            }
+        }
+    }
+
+    private fun findRoomNameBestEffort(data: Map<String, String>, session: Session?): String? {
+        var roomName: String? = data["room_name"]
+        val roomId = data["room_id"]
+        if (null == roomName && null != roomId) {
+            // Try to get the room name from our store
+            /*
+            TODO
+            if (session?.dataHandler?.store?.isReady == true) {
+                val room = session.getRoom(roomId)
+                roomName = room?.getRoomDisplayName(this)
+            }
+            */
+        }
+        return roomName
+    }
+
+    /**
+     * Try to create an event from the FCM data
+     *
+     * @param data the FCM data
+     * @return the event
+     */
+    private fun parseEvent(data: Map<String, String>?): Event? {
+        // accept only event with room id.
+        if (null == data || !data.containsKey("room_id") || !data.containsKey("event_id")) {
+            return null
+        }
+
+        try {
+            return Event(eventId = data["event_id"],
+                    sender = data["sender"],
+                    roomId = data["room_id"],
+                    type = data.getValue("type"),
+                    // TODO content = data.getValue("content"),
+                    originServerTs = System.currentTimeMillis())
+        } catch (e: Exception) {
+            Timber.e(e, "buildEvent fails " + e.localizedMessage)
+        }
+
+        return null
+    }
+}

vector/src/gplay/java/im/vector/push/fcm/troubleshoot/TestFirebaseToken.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * 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.
+ */
+package im.vector.push.fcm.troubleshoot
+
+import androidx.fragment.app.Fragment
+import com.google.firebase.iid.FirebaseInstanceId
+import im.vector.riotredesign.R
+import im.vector.riotredesign.core.utils.startAddGoogleAccountIntent
+import im.vector.riotredesign.features.settings.troubleshoot.NotificationTroubleshootTestManager
+import im.vector.riotredesign.features.settings.troubleshoot.TroubleshootTest
+import timber.log.Timber
+
+/*
+* Test that app can successfully retrieve a token via firebase
+ */
+class TestFirebaseToken(val fragment: Fragment) : TroubleshootTest(R.string.settings_troubleshoot_test_fcm_title) {
+
+    override fun perform() {
+        status = TestStatus.RUNNING
+        val activity = fragment.activity
+        if (activity != null) {
+            try {
+                FirebaseInstanceId.getInstance().instanceId
+                        .addOnCompleteListener(activity) { task ->
+                            if (!task.isSuccessful) {
+                                val errorMsg = if (task.exception == null) "Unknown" else task.exception!!.localizedMessage
+                                //Can't find where this constant is (not documented -or deprecated in docs- and all obfuscated)
+                                if ("SERVICE_NOT_AVAILABLE".equals(errorMsg)) {
+                                    description = fragment.getString(R.string.settings_troubleshoot_test_fcm_failed_service_not_available, errorMsg)
+                                } else if ("TOO_MANY_REGISTRATIONS".equals(errorMsg)) {
+                                    description = fragment.getString(R.string.settings_troubleshoot_test_fcm_failed_too_many_registration, errorMsg)
+                                } else if ("ACCOUNT_MISSING".equals(errorMsg)) {
+                                    description = fragment.getString(R.string.settings_troubleshoot_test_fcm_failed_account_missing, errorMsg)
+                                    quickFix = object : TroubleshootQuickFix(R.string.settings_troubleshoot_test_fcm_failed_account_missing_quick_fix) {
+                                        override fun doFix() {
+                                            startAddGoogleAccountIntent(fragment, NotificationTroubleshootTestManager.REQ_CODE_FIX)
+                                        }
+                                    }
+                                } else {
+                                    description = fragment.getString(R.string.settings_troubleshoot_test_fcm_failed, errorMsg)
+                                }
+                                status = TestStatus.FAILED
+                            } else {
+                                task.result?.token?.let {
+                                    val tok = it.substring(0, Math.min(8, it.length)) + "********************"
+                                    description = fragment.getString(R.string.settings_troubleshoot_test_fcm_success, tok)
+                                    Timber.e("Retrieved FCM token success [$it].")
+                                }
+                                status = TestStatus.SUCCESS
+                            }
+                        }
+            } catch (e: Throwable) {
+                description = fragment.getString(R.string.settings_troubleshoot_test_fcm_failed, e.localizedMessage)
+                status = TestStatus.FAILED
+            }
+        } else {
+            status = TestStatus.FAILED
+        }
+    }
+
+}

vector/src/gplay/java/im/vector/push/fcm/troubleshoot/TestPlayServices.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * 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.
+ */
+package im.vector.push.fcm.troubleshoot
+
+import androidx.fragment.app.Fragment
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import im.vector.riotredesign.R
+import im.vector.riotredesign.features.settings.troubleshoot.TroubleshootTest
+import timber.log.Timber
+
+/*
+* Check that the play services APK is available an up-to-date. If needed provide quick fix to install it.
+ */
+class TestPlayServices(val fragment: Fragment) : TroubleshootTest(R.string.settings_troubleshoot_test_play_services_title) {
+
+    override fun perform() {
+        val apiAvailability = GoogleApiAvailability.getInstance()
+        val resultCode = apiAvailability.isGooglePlayServicesAvailable(fragment.context)
+        if (resultCode == ConnectionResult.SUCCESS) {
+            quickFix = null
+            description = fragment.getString(R.string.settings_troubleshoot_test_play_services_success)
+            status = TestStatus.SUCCESS
+        } else {
+            if (apiAvailability.isUserResolvableError(resultCode)) {
+                quickFix = object : TroubleshootQuickFix(R.string.settings_troubleshoot_test_play_services_quickfix) {
+                    override fun doFix() {
+                        fragment.activity?.let {
+                            apiAvailability.getErrorDialog(it, resultCode, 9000 /*hey does the magic number*/).show()
+                        }
+                    }
+                }
+                Timber.e("Play Services apk error $resultCode -> ${apiAvailability.getErrorString(resultCode)}.")
+            }
+
+            description = fragment.getString(R.string.settings_troubleshoot_test_play_services_failed, apiAvailability.getErrorString(resultCode))
+            status = TestStatus.FAILED
+        }
+    }
+
+}
+

vector/src/gplay/java/im/vector/push/fcm/troubleshoot/TestTokenRegistration.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * 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.
+ */
+package im.vector.push.fcm.troubleshoot
+
+import androidx.fragment.app.Fragment
+import im.vector.riotredesign.R
+import im.vector.riotredesign.features.settings.troubleshoot.TroubleshootTest
+
+/**
+ * Force registration of the token to HomeServer
+ */
+class TestTokenRegistration(val fragment: Fragment) : TroubleshootTest(R.string.settings_troubleshoot_test_token_registration_title) {
+
+    override fun perform() {
+        /*
+        TODO
+        Matrix.getInstance(VectorApp.getInstance().baseContext).pushManager.forceSessionsRegistration(object : ApiCallback<Void> {
+            override fun onSuccess(info: Void?) {
+                description = fragment.getString(R.string.settings_troubleshoot_test_token_registration_success)
+                status = TestStatus.SUCCESS
+            }
+
+            override fun onNetworkError(e: Exception?) {
+                description = fragment.getString(R.string.settings_troubleshoot_test_token_registration_failed, e?.localizedMessage)
+                status = TestStatus.FAILED
+            }
+
+            override fun onMatrixError(e: MatrixError?) {
+                description = fragment.getString(R.string.settings_troubleshoot_test_token_registration_failed, e?.localizedMessage)
+                status = TestStatus.FAILED
+            }
+
+            override fun onUnexpectedError(e: Exception?) {
+                description = fragment.getString(R.string.settings_troubleshoot_test_token_registration_failed, e?.localizedMessage)
+                status = TestStatus.FAILED
+            }
+    })
+         */
+
+        status = TestStatus.FAILED
+
+    }
+
+}