gronod/talk-android
1
0
Fork 1
mirror of https://github.com/nextcloud/talk-android synced 2025-06-19 19:49:33 +01:00
Code Issues Packages Projects Releases Wiki Activity

convert java code to kotlin - DatabaseStorageModule

Browse Source 
Signed-off-by: sowjanyakch <sowjanya.kch@gmail.com>
This commit is contained in:
sowjanyakch 2024-11-15 20:06:25 +01:00 committed by Marcel Hibbe
parent 9e8a5476f9
commit 77b55dcd9b
No known key found for this signature in database
GPG Key ID: C793F8B59F43CE7B
1 changed files with 171 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

358
app/src/main/java/com/nextcloud/talk/utils/preferences/preferencestorage/DatabaseStorageModule.kt
View File

@ -6,237 +6,239 @@
* SPDX-FileCopyrightText: 2017-2018 Mario Danic <mario@lovelyhq.com> * SPDX-FileCopyrightText: 2017-2018 Mario Danic <mario@lovelyhq.com>
* SPDX-License-Identifier: GPL-3.0-or-later * SPDX-License-Identifier: GPL-3.0-or-later
*/ */
package com.nextcloud.talk.utils.preferences.preferencestorage; package com.nextcloud.talk.utils.preferences.preferencestorage
import android.text.TextUtils; import android.text.TextUtils
import android.util.Log; import android.util.Log
import autodagger.AutoInjector
import com.nextcloud.talk.api.NcApi
import com.nextcloud.talk.application.NextcloudTalkApplication
import com.nextcloud.talk.application.NextcloudTalkApplication.Companion.sharedApplication
import com.nextcloud.talk.arbitrarystorage.ArbitraryStorageManager
import com.nextcloud.talk.data.storage.model.ArbitraryStorage
import com.nextcloud.talk.data.user.model.User
import com.nextcloud.talk.models.json.generic.GenericOverall
import com.nextcloud.talk.utils.ApiUtils
import com.nextcloud.talk.utils.ApiUtils.getConversationApiVersion
import com.nextcloud.talk.utils.ApiUtils.getCredentials
import com.nextcloud.talk.utils.ApiUtils.getUrlForMessageExpiration
import com.nextcloud.talk.utils.ApiUtils.getUrlForRoomNotificationCalls
import com.nextcloud.talk.utils.ApiUtils.getUrlForRoomNotificationLevel
import com.nextcloud.talk.utils.CapabilitiesUtil.hasSpreedFeatureCapability
import com.nextcloud.talk.utils.SpreedFeatures
import com.nextcloud.talk.utils.UserIdUtils.getIdForUser
import io.reactivex.Observer
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.Disposable
import io.reactivex.schedulers.Schedulers
import javax.inject.Inject
import com.nextcloud.talk.api.NcApi; @AutoInjector(NextcloudTalkApplication::class)
import com.nextcloud.talk.application.NextcloudTalkApplication; class DatabaseStorageModule(conversationUser: User, conversationToken: String) {
import com.nextcloud.talk.arbitrarystorage.ArbitraryStorageManager; @JvmField
import com.nextcloud.talk.data.storage.model.ArbitraryStorage;
import com.nextcloud.talk.data.user.model.User;
import com.nextcloud.talk.models.json.generic.GenericOverall;
import com.nextcloud.talk.utils.ApiUtils;
import com.nextcloud.talk.utils.SpreedFeatures;
import com.nextcloud.talk.utils.UserIdUtils;
import com.nextcloud.talk.utils.CapabilitiesUtil;
import javax.inject.Inject;
import autodagger.AutoInjector;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
@AutoInjector(NextcloudTalkApplication.class)
public class DatabaseStorageModule {
private static final String TAG = "DatabaseStorageModule";
@Inject @Inject
ArbitraryStorageManager arbitraryStorageManager; var arbitraryStorageManager: ArbitraryStorageManager? = null
@JvmField
@Inject @Inject
NcApi ncApi; var ncApi: NcApi? = null
private int messageExpiration; private var messageExpiration = 0
private final User conversationUser; private val conversationUser: User
private final String conversationToken; private val conversationToken: String
private final long accountIdentifier; private val accountIdentifier: Long
private boolean lobbyValue; private var lobbyValue = false
private String messageNotificationLevel; private var messageNotificationLevel: String? = null
public DatabaseStorageModule(User conversationUser, String conversationToken) { init {
NextcloudTalkApplication.Companion.getSharedApplication().getComponentApplication().inject(this); sharedApplication!!.componentApplication.inject(this)
this.conversationUser = conversationUser; this.conversationUser = conversationUser
this.accountIdentifier = UserIdUtils.INSTANCE.getIdForUser(conversationUser); this.accountIdentifier = getIdForUser(conversationUser)
this.conversationToken = conversationToken; this.conversationToken = conversationToken
} }
public void saveBoolean(String key, boolean value) { fun saveBoolean(key: String, value: Boolean) {
if ("call_notifications_switch".equals(key)) { if ("call_notifications_switch" == key) {
int apiVersion = ApiUtils.getConversationApiVersion(conversationUser, new int[]{4}); val apiVersion = getConversationApiVersion(conversationUser, intArrayOf(4))
ncApi.notificationCalls(ApiUtils.getCredentials(conversationUser.getUsername(), ncApi!!.notificationCalls(
conversationUser.getToken()), getCredentials(
ApiUtils.getUrlForRoomNotificationCalls(apiVersion, conversationUser.username,
conversationUser.getBaseUrl(), conversationUser.token
conversationToken), ),
value ? 1 : 0) getUrlForRoomNotificationCalls(
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<GenericOverall>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
// unused atm
}
@Override
public void onNext(@NonNull GenericOverall genericOverall) {
Log.d(TAG, "Toggled notification calls");
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "Error when trying to toggle notification calls", e);
}
@Override
public void onComplete() {
// unused atm
}
}
);
}
if (!"lobby_switch".equals(key)) {
arbitraryStorageManager.storeStorageSetting(accountIdentifier,
key,
Boolean.toString(value),
conversationToken);
} else {
lobbyValue = value;
}
}
public void saveString(String key, String value) {
if ("conversation_settings_dropdown".equals(key)) {
int apiVersion = ApiUtils.getConversationApiVersion(conversationUser, new int[]{4});
String trimmedValue = value.replace("expire_", "");
int valueInt = Integer.parseInt(trimmedValue);
ncApi.setMessageExpiration(
ApiUtils.getCredentials(
conversationUser.getUsername(),
conversationUser.getToken()),
ApiUtils.getUrlForMessageExpiration(
apiVersion, apiVersion,
conversationUser.getBaseUrl(), conversationUser.baseUrl,
conversationToken), conversationToken
valueInt) ),
if (value) 1 else 0
)
.subscribeOn(Schedulers.io()) .subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()) .observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<GenericOverall>() { .subscribe(
@Override object : Observer<GenericOverall> {
public void onSubscribe(@NonNull Disposable d) { override fun onSubscribe(d: Disposable) {
// unused atm // unused atm
} }
@Override override fun onNext(genericOverall: GenericOverall) {
public void onNext(@NonNull GenericOverall genericOverall) { Log.d(TAG, "Toggled notification calls")
messageExpiration = valueInt;
} }
@Override override fun onError(e: Throwable) {
public void onError(@NonNull Throwable e) { Log.e(TAG, "Error when trying to toggle notification calls", e)
Log.e(TAG, "Error when trying to set message expiration", e);
} }
@Override override fun onComplete() {
public void onComplete() {
// unused atm // unused atm
} }
}); }
)
} else if ("conversation_info_message_notifications_dropdown".equals(key)) {
if (CapabilitiesUtil.hasSpreedFeatureCapability(
conversationUser.getCapabilities().getSpreedCapability(),
SpreedFeatures.NOTIFICATION_LEVELS)
) {
if (TextUtils.isEmpty(messageNotificationLevel) || !messageNotificationLevel.equals(value)) {
int intValue;
switch (value) {
case "never":
intValue = 3;
break;
case "mention":
intValue = 2;
break;
case "always":
intValue = 1;
break;
default:
intValue = 0;
} }
int apiVersion = ApiUtils.getConversationApiVersion(conversationUser, new int[]{ApiUtils.API_V4, 1}); if ("lobby_switch" != key) {
arbitraryStorageManager!!.storeStorageSetting(
accountIdentifier,
key,
value.toString(),
conversationToken
)
} else {
lobbyValue = value
}
}
ncApi.setNotificationLevel(ApiUtils.getCredentials(conversationUser.getUsername(), fun saveString(key: String, value: String) {
conversationUser.getToken()), if ("conversation_settings_dropdown" == key) {
ApiUtils.getUrlForRoomNotificationLevel(apiVersion, val apiVersion = getConversationApiVersion(conversationUser, intArrayOf(4))
conversationUser.getBaseUrl(),
conversationToken), val trimmedValue = value.replace("expire_", "")
intValue) val valueInt = trimmedValue.toInt()
ncApi!!.setMessageExpiration(
getCredentials(
conversationUser.username,
conversationUser.token
),
getUrlForMessageExpiration(
apiVersion,
conversationUser.baseUrl,
conversationToken
),
valueInt
)
.subscribeOn(Schedulers.io()) .subscribeOn(Schedulers.io())
.subscribe(new Observer<GenericOverall>() { .observeOn(AndroidSchedulers.mainThread())
@Override .subscribe(object : Observer<GenericOverall> {
public void onSubscribe(Disposable d) { override fun onSubscribe(d: Disposable) {
// unused atm // unused atm
} }
@Override override fun onNext(genericOverall: GenericOverall) {
public void onNext(GenericOverall genericOverall) {messageNotificationLevel = value;} messageExpiration = valueInt
}
@Override override fun onError(e: Throwable) {
public void onError(Throwable e) { Log.e(TAG, "Error when trying to set message expiration", e)
}
override fun onComplete() {
// unused atm
}
})
} else if ("conversation_info_message_notifications_dropdown" == key) {
if (hasSpreedFeatureCapability(
conversationUser.capabilities!!.spreedCapability!!,
SpreedFeatures.NOTIFICATION_LEVELS
)
) {
if (TextUtils.isEmpty(messageNotificationLevel) || messageNotificationLevel != value) {
val intValue = when (value) {
"never" -> 3
"mention" -> 2
"always" -> 1
else -> 0
}
val apiVersion = getConversationApiVersion(conversationUser, intArrayOf(ApiUtils.API_V4, 1))
ncApi!!.setNotificationLevel(
getCredentials(
conversationUser.username,
conversationUser.token
),
getUrlForRoomNotificationLevel(
apiVersion,
conversationUser.baseUrl,
conversationToken
),
intValue
)
.subscribeOn(Schedulers.io())
.subscribe(object : Observer<GenericOverall?> {
override fun onSubscribe(d: Disposable) {
// unused atm // unused atm
} }
@Override override fun onNext(p0: GenericOverall) {
public void onComplete() { messageNotificationLevel = value
}
override fun onError(e: Throwable) {
// unused atm // unused atm
} }
});
override fun onComplete() {
// unused atm
}
})
} else { } else {
messageNotificationLevel = value; messageNotificationLevel = value
} }
} }
} else { } else {
arbitraryStorageManager.storeStorageSetting(accountIdentifier, key, value, conversationToken); arbitraryStorageManager!!.storeStorageSetting(accountIdentifier, key, value, conversationToken)
} }
} }
public boolean getBoolean(String key, boolean defaultVal) {
if ("lobby_switch".equals(key)) { fun getBoolean(key: String, defaultVal: Boolean): Boolean {
return lobbyValue; return if ("lobby_switch" == key) {
lobbyValue
} else { } else {
return arbitraryStorageManager arbitraryStorageManager!!
.getStorageSetting(accountIdentifier, key, conversationToken) .getStorageSetting(accountIdentifier, key, conversationToken)
.map(arbitraryStorage -> Boolean.parseBoolean(arbitraryStorage.getValue())) .map { arbitraryStorage: ArbitraryStorage -> arbitraryStorage.value.toBoolean() }
.blockingGet(defaultVal); .blockingGet(defaultVal)
} }
} }
public String getString(String key, String defaultVal) { fun getString(key: String, defaultVal: String): String? {
if ("conversation_settings_dropdown".equals(key)) { return if ("conversation_settings_dropdown" == key) {
switch (messageExpiration) { when (messageExpiration) {
case 2419200: 2419200 -> "expire_2419200"
return "expire_2419200"; 604800 -> "expire_604800"
case 604800: 86400 -> "expire_86400"
return "expire_604800"; 28800 -> "expire_28800"
case 86400: 3600 -> "expire_3600"
return "expire_86400"; else -> "expire_0"
case 28800:
return "expire_28800";
case 3600:
return "expire_3600";
default:
return "expire_0";
} }
} else if ("conversation_info_message_notifications_dropdown".equals(key)) { } else if ("conversation_info_message_notifications_dropdown" == key) {
return messageNotificationLevel; messageNotificationLevel
} else { } else {
return arbitraryStorageManager arbitraryStorageManager!!
.getStorageSetting(accountIdentifier, key, conversationToken) .getStorageSetting(accountIdentifier, key, conversationToken)
.map(ArbitraryStorage::getValue) .map(ArbitraryStorage::value)
.blockingGet(defaultVal); .blockingGet(defaultVal)
} }
} }
public void setMessageExpiration(int messageExpiration) { fun setMessageExpiration(messageExpiration: Int) {
this.messageExpiration = messageExpiration; this.messageExpiration = messageExpiration
}
companion object {
private const val TAG = "DatabaseStorageModule"
} }
} }