content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.simplemobiletools.commons.helpers
import android.net.Uri
import android.provider.ContactsContract.CommonDataKinds
import android.provider.ContactsContract.CommonDataKinds.Event
import android.provider.ContactsContract.CommonDataKinds.Im
import android.provider.ContactsContract.CommonDataKinds.Phone
import android.provider.ContactsContract.CommonDataKinds.StructuredPostal
import android.provider.MediaStore
import com.simplemobiletools.commons.R
import com.simplemobiletools.commons.activities.BaseSimpleActivity
import com.simplemobiletools.commons.extensions.getByteArray
import com.simplemobiletools.commons.extensions.getDateTimeFromDateString
import com.simplemobiletools.commons.extensions.showErrorToast
import com.simplemobiletools.commons.extensions.toast
import com.simplemobiletools.commons.models.contacts.Contact
import ezvcard.Ezvcard
import ezvcard.VCard
import ezvcard.VCardVersion
import ezvcard.parameter.ImageType
import ezvcard.property.*
import java.io.OutputStream
import java.util.*
class VcfExporter {
private var contactsExported = 0
private var contactsFailed = 0
fun exportContacts(
activity: BaseSimpleActivity,
outputStream: OutputStream?,
contacts: ArrayList<Contact>,
showExportingToast: Boolean,
callback: (result: ExportResult) -> Unit
) {
try {
if (outputStream == null) {
callback(ExportResult.EXPORT_FAIL)
return
}
if (showExportingToast) {
activity.toast(R.string.exporting)
}
val cards = ArrayList<VCard>()
for (contact in contacts) {
val card = VCard()
val formattedName = arrayOf(contact.prefix, contact.firstName, contact.middleName, contact.surname, contact.suffix)
.filter { it.isNotEmpty() }
.joinToString(separator = " ")
card.formattedName = FormattedName(formattedName)
StructuredName().apply {
prefixes.add(contact.prefix)
given = contact.firstName
additionalNames.add(contact.middleName)
family = contact.surname
suffixes.add(contact.suffix)
card.structuredName = this
}
if (contact.nickname.isNotEmpty()) {
card.setNickname(contact.nickname)
}
contact.phoneNumbers.forEach {
val phoneNumber = Telephone(it.value)
phoneNumber.parameters.addType(getPhoneNumberTypeLabel(it.type, it.label))
card.addTelephoneNumber(phoneNumber)
}
contact.emails.forEach {
val email = Email(it.value)
email.parameters.addType(getEmailTypeLabel(it.type, it.label))
card.addEmail(email)
}
contact.events.forEach { event ->
if (event.type == Event.TYPE_ANNIVERSARY || event.type == Event.TYPE_BIRTHDAY) {
val dateTime = event.value.getDateTimeFromDateString(false)
Calendar.getInstance().apply {
clear()
if (event.value.startsWith("--")) {
set(Calendar.YEAR, 1900)
} else {
set(Calendar.YEAR, dateTime.year)
}
set(Calendar.MONTH, dateTime.monthOfYear - 1)
set(Calendar.DAY_OF_MONTH, dateTime.dayOfMonth)
if (event.type == Event.TYPE_BIRTHDAY) {
card.birthdays.add(Birthday(time))
} else {
card.anniversaries.add(Anniversary(time))
}
}
}
}
contact.addresses.forEach {
val address = Address()
address.streetAddress = it.value
address.parameters.addType(getAddressTypeLabel(it.type, it.label))
card.addAddress(address)
}
contact.IMs.forEach {
val impp = when (it.type) {
Im.PROTOCOL_AIM -> Impp.aim(it.value)
Im.PROTOCOL_YAHOO -> Impp.yahoo(it.value)
Im.PROTOCOL_MSN -> Impp.msn(it.value)
Im.PROTOCOL_ICQ -> Impp.icq(it.value)
Im.PROTOCOL_SKYPE -> Impp.skype(it.value)
Im.PROTOCOL_GOOGLE_TALK -> Impp(HANGOUTS, it.value)
Im.PROTOCOL_QQ -> Impp(QQ, it.value)
Im.PROTOCOL_JABBER -> Impp(JABBER, it.value)
else -> Impp(it.label, it.value)
}
card.addImpp(impp)
}
if (contact.notes.isNotEmpty()) {
card.addNote(contact.notes)
}
if (contact.organization.isNotEmpty()) {
val organization = Organization()
organization.values.add(contact.organization.company)
card.organization = organization
card.titles.add(Title(contact.organization.jobPosition))
}
contact.websites.forEach {
card.addUrl(it)
}
if (contact.thumbnailUri.isNotEmpty()) {
val photoByteArray = MediaStore.Images.Media.getBitmap(activity.contentResolver, Uri.parse(contact.thumbnailUri)).getByteArray()
val photo = Photo(photoByteArray, ImageType.JPEG)
card.addPhoto(photo)
}
if (contact.groups.isNotEmpty()) {
val groupList = Categories()
contact.groups.forEach {
groupList.values.add(it.title)
}
card.categories = groupList
}
cards.add(card)
contactsExported++
}
Ezvcard.write(cards).version(VCardVersion.V4_0).go(outputStream)
} catch (e: Exception) {
activity.showErrorToast(e)
}
callback(
when {
contactsExported == 0 -> ExportResult.EXPORT_FAIL
contactsFailed > 0 -> ExportResult.EXPORT_PARTIAL
else -> ExportResult.EXPORT_OK
}
)
}
private fun getPhoneNumberTypeLabel(type: Int, label: String) = when (type) {
Phone.TYPE_MOBILE -> CELL
Phone.TYPE_HOME -> HOME
Phone.TYPE_WORK -> WORK
Phone.TYPE_MAIN -> PREF
Phone.TYPE_FAX_WORK -> WORK_FAX
Phone.TYPE_FAX_HOME -> HOME_FAX
Phone.TYPE_PAGER -> PAGER
Phone.TYPE_OTHER -> OTHER
else -> label
}
private fun getEmailTypeLabel(type: Int, label: String) = when (type) {
CommonDataKinds.Email.TYPE_HOME -> HOME
CommonDataKinds.Email.TYPE_WORK -> WORK
CommonDataKinds.Email.TYPE_MOBILE -> MOBILE
CommonDataKinds.Email.TYPE_OTHER -> OTHER
else -> label
}
private fun getAddressTypeLabel(type: Int, label: String) = when (type) {
StructuredPostal.TYPE_HOME -> HOME
StructuredPostal.TYPE_WORK -> WORK
StructuredPostal.TYPE_OTHER -> OTHER
else -> label
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/VcfExporter.kt | 1543350366 |
package com.simplemobiletools.commons.helpers
import android.annotation.TargetApi
import android.content.Context
import android.content.ContextWrapper
import android.content.res.Configuration
import android.os.Build
import java.util.*
// language forcing used at "Use english language", taken from https://stackoverflow.com/a/40704077/1967672
class MyContextWrapper(context: Context) : ContextWrapper(context) {
fun wrap(context: Context, language: String): ContextWrapper {
var newContext = context
val config = newContext.resources.configuration
val sysLocale: Locale?
sysLocale = if (isNougatPlus()) {
getSystemLocale(config)
} else {
getSystemLocaleLegacy(config)
}
if (language != "" && sysLocale!!.language != language) {
val locale = Locale(language)
Locale.setDefault(locale)
if (isNougatPlus()) {
setSystemLocale(config, locale)
} else {
setSystemLocaleLegacy(config, locale)
}
}
newContext = newContext.createConfigurationContext(config)
return MyContextWrapper(newContext)
}
private fun getSystemLocaleLegacy(config: Configuration) = config.locale
@TargetApi(Build.VERSION_CODES.N)
private fun getSystemLocale(config: Configuration) = config.locales.get(0)
private fun setSystemLocaleLegacy(config: Configuration, locale: Locale) {
config.locale = locale
}
@TargetApi(Build.VERSION_CODES.N)
private fun setSystemLocale(config: Configuration, locale: Locale) {
config.setLocale(locale)
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/MyContextWrapper.kt | 1008980092 |
package com.simplemobiletools.commons.helpers
import android.content.ContentValues
import android.net.Uri
import com.simplemobiletools.commons.models.SharedTheme
class MyContentProvider {
companion object {
private const val AUTHORITY = "com.simplemobiletools.commons.provider"
const val SHARED_THEME_ACTIVATED = "com.simplemobiletools.commons.SHARED_THEME_ACTIVATED"
const val SHARED_THEME_UPDATED = "com.simplemobiletools.commons.SHARED_THEME_UPDATED"
val MY_CONTENT_URI = Uri.parse("content://$AUTHORITY/themes")
const val COL_ID = "_id" // used in Simple Thank You
const val COL_TEXT_COLOR = "text_color"
const val COL_BACKGROUND_COLOR = "background_color"
const val COL_PRIMARY_COLOR = "primary_color"
const val COL_ACCENT_COLOR = "accent_color"
const val COL_APP_ICON_COLOR = "app_icon_color"
const val COL_LAST_UPDATED_TS = "last_updated_ts"
fun fillThemeContentValues(sharedTheme: SharedTheme) = ContentValues().apply {
put(COL_TEXT_COLOR, sharedTheme.textColor)
put(COL_BACKGROUND_COLOR, sharedTheme.backgroundColor)
put(COL_PRIMARY_COLOR, sharedTheme.primaryColor)
put(COL_ACCENT_COLOR, sharedTheme.accentColor)
put(COL_APP_ICON_COLOR, sharedTheme.appIconColor)
put(COL_LAST_UPDATED_TS, System.currentTimeMillis() / 1000)
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/MyContentProvider.kt | 1410019572 |
package com.simplemobiletools.commons.helpers
inline fun <T> Iterable<T>.sumByLong(selector: (T) -> Long) = this.map { selector(it) }.sum()
inline fun <T> Iterable<T>.sumByInt(selector: (T) -> Int) = this.map { selector(it) }.sum()
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/Inlines.kt | 1165859052 |
package com.simplemobiletools.commons.helpers
import androidx.room.TypeConverter
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.simplemobiletools.commons.models.PhoneNumber
import com.simplemobiletools.commons.models.contacts.*
import java.util.ArrayList
class Converters {
private val gson = Gson()
private val longType = object : TypeToken<List<Long>>() {}.type
private val stringType = object : TypeToken<List<String>>() {}.type
private val numberType = object : TypeToken<List<PhoneNumber>>() {}.type
private val numberConverterType = object : TypeToken<List<PhoneNumberConverter>>() {}.type
private val emailType = object : TypeToken<List<Email>>() {}.type
private val addressType = object : TypeToken<List<Address>>() {}.type
private val eventType = object : TypeToken<List<Event>>() {}.type
private val imType = object : TypeToken<List<IM>>() {}.type
@TypeConverter
fun jsonToStringList(value: String): ArrayList<String> = gson.fromJson(value, stringType)
@TypeConverter
fun stringListToJson(list: ArrayList<String>): String = gson.toJson(list)
@TypeConverter
fun jsonToLongList(value: String): ArrayList<Long> = gson.fromJson(value, longType)
@TypeConverter
fun longListToJson(list: ArrayList<Long>): String = gson.toJson(list)
// some hacky converting is needed since PhoneNumber model has been added to proguard rules, but obfuscated json was stored in database
// convert [{"a":"678910","b":2,"c":"","d":"678910","e":false}] to PhoneNumber(value=678910, type=2, label=, normalizedNumber=678910, isPrimary=false)
@TypeConverter
fun jsonToPhoneNumberList(value: String): ArrayList<PhoneNumber> {
val numbers = gson.fromJson<ArrayList<PhoneNumber>>(value, numberType)
return if (numbers.any { it.value == null }) {
val phoneNumbers = ArrayList<PhoneNumber>()
val numberConverters = gson.fromJson<ArrayList<PhoneNumberConverter>>(value, numberConverterType)
numberConverters.forEach { converter ->
val phoneNumber = PhoneNumber(converter.a, converter.b, converter.c, converter.d, converter.e)
phoneNumbers.add(phoneNumber)
}
phoneNumbers
} else {
numbers
}
}
@TypeConverter
fun phoneNumberListToJson(list: ArrayList<PhoneNumber>): String = gson.toJson(list)
@TypeConverter
fun jsonToEmailList(value: String): ArrayList<Email> = gson.fromJson(value, emailType)
@TypeConverter
fun emailListToJson(list: ArrayList<Email>): String = gson.toJson(list)
@TypeConverter
fun jsonToAddressList(value: String): ArrayList<Address> = gson.fromJson(value, addressType)
@TypeConverter
fun addressListToJson(list: ArrayList<Address>): String = gson.toJson(list)
@TypeConverter
fun jsonToEventList(value: String): ArrayList<Event> = gson.fromJson(value, eventType)
@TypeConverter
fun eventListToJson(list: ArrayList<Event>): String = gson.toJson(list)
@TypeConverter
fun jsonToIMsList(value: String): ArrayList<IM> = gson.fromJson(value, imType)
@TypeConverter
fun iMsListToJson(list: ArrayList<IM>): String = gson.toJson(list)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/Converters.kt | 2960516353 |
package com.simplemobiletools.commons.helpers
import android.content.Context
import android.database.Cursor
import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.drawable.BitmapDrawable
import android.graphics.drawable.Drawable
import android.graphics.drawable.LayerDrawable
import android.net.Uri
import android.provider.ContactsContract.CommonDataKinds.Event
import android.provider.ContactsContract.CommonDataKinds.Organization
import android.provider.ContactsContract.CommonDataKinds.Phone
import android.provider.ContactsContract.CommonDataKinds.StructuredName
import android.provider.ContactsContract.Data
import android.provider.ContactsContract.PhoneLookup
import android.text.TextUtils
import android.util.SparseArray
import android.widget.ImageView
import android.widget.TextView
import com.bumptech.glide.Glide
import com.bumptech.glide.load.DecodeFormat
import com.bumptech.glide.load.engine.DiskCacheStrategy
import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions
import com.bumptech.glide.request.RequestOptions
import com.simplemobiletools.commons.R
import com.simplemobiletools.commons.extensions.*
import com.simplemobiletools.commons.models.PhoneNumber
import com.simplemobiletools.commons.models.SimpleContact
class SimpleContactsHelper(val context: Context) {
fun getAvailableContacts(favoritesOnly: Boolean, callback: (ArrayList<SimpleContact>) -> Unit) {
ensureBackgroundThread {
val names = getContactNames(favoritesOnly)
var allContacts = getContactPhoneNumbers(favoritesOnly)
allContacts.forEach {
val contactId = it.rawId
val contact = names.firstOrNull { it.rawId == contactId }
val name = contact?.name
if (name != null) {
it.name = name
}
val photoUri = contact?.photoUri
if (photoUri != null) {
it.photoUri = photoUri
}
}
allContacts = allContacts.filter { it.name.isNotEmpty() }.distinctBy {
val startIndex = Math.max(0, it.phoneNumbers.first().normalizedNumber.length - 9)
it.phoneNumbers.first().normalizedNumber.substring(startIndex)
}.distinctBy { it.rawId }.toMutableList() as ArrayList<SimpleContact>
// if there are duplicate contacts with the same name, while the first one has phone numbers 1234 and 4567, second one has only 4567,
// use just the first contact
val contactsToRemove = ArrayList<SimpleContact>()
allContacts.groupBy { it.name }.forEach {
val contacts = it.value.toMutableList() as ArrayList<SimpleContact>
if (contacts.size > 1) {
contacts.sortByDescending { it.phoneNumbers.size }
if (contacts.any { it.phoneNumbers.size == 1 } && contacts.any { it.phoneNumbers.size > 1 }) {
val multipleNumbersContact = contacts.first()
contacts.subList(1, contacts.size).forEach { contact ->
if (contact.phoneNumbers.all { multipleNumbersContact.doesContainPhoneNumber(it.normalizedNumber) }) {
val contactToRemove = allContacts.firstOrNull { it.rawId == contact.rawId }
if (contactToRemove != null) {
contactsToRemove.add(contactToRemove)
}
}
}
}
}
}
contactsToRemove.forEach {
allContacts.remove(it)
}
val birthdays = getContactEvents(true)
var size = birthdays.size()
for (i in 0 until size) {
val key = birthdays.keyAt(i)
allContacts.firstOrNull { it.rawId == key }?.birthdays = birthdays.valueAt(i)
}
val anniversaries = getContactEvents(false)
size = anniversaries.size()
for (i in 0 until size) {
val key = anniversaries.keyAt(i)
allContacts.firstOrNull { it.rawId == key }?.anniversaries = anniversaries.valueAt(i)
}
allContacts.sort()
callback(allContacts)
}
}
private fun getContactNames(favoritesOnly: Boolean): List<SimpleContact> {
val contacts = ArrayList<SimpleContact>()
val startNameWithSurname = context.baseConfig.startNameWithSurname
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
Data.CONTACT_ID,
StructuredName.PREFIX,
StructuredName.GIVEN_NAME,
StructuredName.MIDDLE_NAME,
StructuredName.FAMILY_NAME,
StructuredName.SUFFIX,
StructuredName.PHOTO_THUMBNAIL_URI,
Organization.COMPANY,
Organization.TITLE,
Data.MIMETYPE
)
var selection = "(${Data.MIMETYPE} = ? OR ${Data.MIMETYPE} = ?)"
if (favoritesOnly) {
selection += " AND ${Data.STARRED} = 1"
}
val selectionArgs = arrayOf(
StructuredName.CONTENT_ITEM_TYPE,
Organization.CONTENT_ITEM_TYPE
)
context.queryCursor(uri, projection, selection, selectionArgs) { cursor ->
val rawId = cursor.getIntValue(Data.RAW_CONTACT_ID)
val contactId = cursor.getIntValue(Data.CONTACT_ID)
val mimetype = cursor.getStringValue(Data.MIMETYPE)
val photoUri = cursor.getStringValue(StructuredName.PHOTO_THUMBNAIL_URI) ?: ""
val isPerson = mimetype == StructuredName.CONTENT_ITEM_TYPE
if (isPerson) {
val prefix = cursor.getStringValue(StructuredName.PREFIX) ?: ""
val firstName = cursor.getStringValue(StructuredName.GIVEN_NAME) ?: ""
val middleName = cursor.getStringValue(StructuredName.MIDDLE_NAME) ?: ""
val familyName = cursor.getStringValue(StructuredName.FAMILY_NAME) ?: ""
val suffix = cursor.getStringValue(StructuredName.SUFFIX) ?: ""
if (firstName.isNotEmpty() || middleName.isNotEmpty() || familyName.isNotEmpty()) {
val names = if (startNameWithSurname) {
arrayOf(prefix, familyName, middleName, firstName, suffix).filter { it.isNotEmpty() }
} else {
arrayOf(prefix, firstName, middleName, familyName, suffix).filter { it.isNotEmpty() }
}
val fullName = TextUtils.join(" ", names)
val contact = SimpleContact(rawId, contactId, fullName, photoUri, ArrayList(), ArrayList(), ArrayList())
contacts.add(contact)
}
}
val isOrganization = mimetype == Organization.CONTENT_ITEM_TYPE
if (isOrganization) {
val company = cursor.getStringValue(Organization.COMPANY) ?: ""
val jobTitle = cursor.getStringValue(Organization.TITLE) ?: ""
if (company.isNotEmpty() || jobTitle.isNotEmpty()) {
val fullName = "$company $jobTitle".trim()
val contact = SimpleContact(rawId, contactId, fullName, photoUri, ArrayList(), ArrayList(), ArrayList())
contacts.add(contact)
}
}
}
return contacts
}
private fun getContactPhoneNumbers(favoritesOnly: Boolean): ArrayList<SimpleContact> {
val contacts = ArrayList<SimpleContact>()
val uri = Phone.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
Data.CONTACT_ID,
Phone.NORMALIZED_NUMBER,
Phone.NUMBER,
Phone.TYPE,
Phone.LABEL,
Phone.IS_PRIMARY
)
val selection = if (favoritesOnly) "${Data.STARRED} = 1" else null
context.queryCursor(uri, projection, selection) { cursor ->
val normalizedNumber = cursor.getStringValue(Phone.NORMALIZED_NUMBER)
?: cursor.getStringValue(Phone.NUMBER)?.normalizePhoneNumber() ?: return@queryCursor
val rawId = cursor.getIntValue(Data.RAW_CONTACT_ID)
val contactId = cursor.getIntValue(Data.CONTACT_ID)
val type = cursor.getIntValue(Phone.TYPE)
val label = cursor.getStringValue(Phone.LABEL) ?: ""
val isPrimary = cursor.getIntValue(Phone.IS_PRIMARY) != 0
if (contacts.firstOrNull { it.rawId == rawId } == null) {
val contact = SimpleContact(rawId, contactId, "", "", ArrayList(), ArrayList(), ArrayList())
contacts.add(contact)
}
val phoneNumber = PhoneNumber(normalizedNumber, type, label, normalizedNumber, isPrimary)
contacts.firstOrNull { it.rawId == rawId }?.phoneNumbers?.add(phoneNumber)
}
return contacts
}
private fun getContactEvents(getBirthdays: Boolean): SparseArray<ArrayList<String>> {
val eventDates = SparseArray<ArrayList<String>>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
Event.START_DATE
)
val selection = "${Event.MIMETYPE} = ? AND ${Event.TYPE} = ?"
val requiredType = if (getBirthdays) Event.TYPE_BIRTHDAY.toString() else Event.TYPE_ANNIVERSARY.toString()
val selectionArgs = arrayOf(Event.CONTENT_ITEM_TYPE, requiredType)
context.queryCursor(uri, projection, selection, selectionArgs) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val startDate = cursor.getStringValue(Event.START_DATE) ?: return@queryCursor
if (eventDates[id] == null) {
eventDates.put(id, ArrayList())
}
eventDates[id]!!.add(startDate)
}
return eventDates
}
fun getNameFromPhoneNumber(number: String): String {
if (!context.hasPermission(PERMISSION_READ_CONTACTS)) {
return number
}
val uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, Uri.encode(number))
val projection = arrayOf(
PhoneLookup.DISPLAY_NAME
)
try {
val cursor = context.contentResolver.query(uri, projection, null, null, null)
cursor.use {
if (cursor?.moveToFirst() == true) {
return cursor.getStringValue(PhoneLookup.DISPLAY_NAME)
}
}
} catch (ignored: Exception) {
}
return number
}
fun getPhotoUriFromPhoneNumber(number: String): String {
if (!context.hasPermission(PERMISSION_READ_CONTACTS)) {
return ""
}
val uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, Uri.encode(number))
val projection = arrayOf(
PhoneLookup.PHOTO_URI
)
try {
val cursor = context.contentResolver.query(uri, projection, null, null, null)
cursor.use {
if (cursor?.moveToFirst() == true) {
return cursor.getStringValue(PhoneLookup.PHOTO_URI) ?: ""
}
}
} catch (ignored: Exception) {
}
return ""
}
fun loadContactImage(path: String, imageView: ImageView, placeholderName: String, placeholderImage: Drawable? = null) {
val placeholder = placeholderImage ?: BitmapDrawable(context.resources, getContactLetterIcon(placeholderName))
val options = RequestOptions()
.diskCacheStrategy(DiskCacheStrategy.RESOURCE)
.error(placeholder)
.centerCrop()
Glide.with(context)
.load(path)
.transition(DrawableTransitionOptions.withCrossFade())
.placeholder(placeholder)
.apply(options)
.apply(RequestOptions.circleCropTransform())
.into(imageView)
}
fun getContactLetterIcon(name: String): Bitmap {
val letter = name.getNameLetter()
val size = context.resources.getDimension(R.dimen.normal_icon_size).toInt()
val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
val canvas = Canvas(bitmap)
val view = TextView(context)
view.layout(0, 0, size, size)
val circlePaint = Paint().apply {
color = letterBackgroundColors[Math.abs(name.hashCode()) % letterBackgroundColors.size].toInt()
isAntiAlias = true
}
val wantedTextSize = size / 2f
val textPaint = Paint().apply {
color = circlePaint.color.getContrastColor()
isAntiAlias = true
textAlign = Paint.Align.CENTER
textSize = wantedTextSize
style = Paint.Style.FILL
}
canvas.drawCircle(size / 2f, size / 2f, size / 2f, circlePaint)
val xPos = canvas.width / 2f
val yPos = canvas.height / 2 - (textPaint.descent() + textPaint.ascent()) / 2
canvas.drawText(letter, xPos, yPos, textPaint)
view.draw(canvas)
return bitmap
}
fun getColoredGroupIcon(title: String): Drawable {
val icon = context.resources.getDrawable(R.drawable.ic_group_circle_bg)
val bgColor = letterBackgroundColors[Math.abs(title.hashCode()) % letterBackgroundColors.size].toInt()
(icon as LayerDrawable).findDrawableByLayerId(R.id.attendee_circular_background).applyColorFilter(bgColor)
return icon
}
fun getContactLookupKey(contactId: String): String {
val uri = Data.CONTENT_URI
val projection = arrayOf(Data.CONTACT_ID, Data.LOOKUP_KEY)
val selection = "${Data.MIMETYPE} = ? AND ${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = arrayOf(StructuredName.CONTENT_ITEM_TYPE, contactId)
val cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
cursor?.use {
if (cursor.moveToFirst()) {
val id = cursor.getIntValue(Data.CONTACT_ID)
val lookupKey = cursor.getStringValue(Data.LOOKUP_KEY)
return "$lookupKey/$id"
}
}
return ""
}
fun deleteContactRawIDs(ids: ArrayList<Int>, callback: () -> Unit) {
ensureBackgroundThread {
val uri = Data.CONTENT_URI
ids.chunked(30).forEach { chunk ->
val selection = "${Data.RAW_CONTACT_ID} IN (${getQuestionMarks(chunk.size)})"
val selectionArgs = chunk.map { it.toString() }.toTypedArray()
context.contentResolver.delete(uri, selection, selectionArgs)
}
callback()
}
}
fun getShortcutImage(path: String, placeholderName: String, callback: (image: Bitmap) -> Unit) {
ensureBackgroundThread {
val placeholder = BitmapDrawable(context.resources, getContactLetterIcon(placeholderName))
try {
val options = RequestOptions()
.format(DecodeFormat.PREFER_ARGB_8888)
.diskCacheStrategy(DiskCacheStrategy.NONE)
.error(placeholder)
.centerCrop()
val size = context.resources.getDimension(R.dimen.shortcut_size).toInt()
val bitmap = Glide.with(context).asBitmap()
.load(path)
.placeholder(placeholder)
.apply(options)
.apply(RequestOptions.circleCropTransform())
.into(size, size)
.get()
callback(bitmap)
} catch (ignored: Exception) {
callback(placeholder.bitmap)
}
}
}
fun exists(number: String, privateCursor: Cursor?, callback: (Boolean) -> Unit) {
SimpleContactsHelper(context).getAvailableContacts(false) { contacts ->
val contact = contacts.firstOrNull { it.doesHavePhoneNumber(number) }
if (contact != null) {
callback.invoke(true)
} else {
val privateContacts = MyContactsContentProvider.getSimpleContacts(context, privateCursor)
val privateContact = privateContacts.firstOrNull { it.doesHavePhoneNumber(number) }
callback.invoke(privateContact != null)
}
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/SimpleContactsHelper.kt | 1810975077 |
package com.simplemobiletools.commons.helpers
import android.content.Context
import android.database.Cursor
import android.net.Uri
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.simplemobiletools.commons.extensions.getIntValue
import com.simplemobiletools.commons.extensions.getStringValue
import com.simplemobiletools.commons.models.PhoneNumber
import com.simplemobiletools.commons.models.SimpleContact
import com.simplemobiletools.commons.models.contacts.Contact
// used for sharing privately stored contacts in Simple Contacts with Simple Dialer, Simple SMS Messenger and Simple Calendar Pro
class MyContactsContentProvider {
companion object {
private const val AUTHORITY = "com.simplemobiletools.commons.contactsprovider"
val CONTACTS_CONTENT_URI = Uri.parse("content://$AUTHORITY/contacts")
const val FAVORITES_ONLY = "favorites_only"
const val COL_RAW_ID = "raw_id"
const val COL_CONTACT_ID = "contact_id"
const val COL_NAME = "name"
const val COL_PHOTO_URI = "photo_uri"
const val COL_PHONE_NUMBERS = "phone_numbers"
const val COL_BIRTHDAYS = "birthdays"
const val COL_ANNIVERSARIES = "anniversaries"
fun getSimpleContacts(context: Context, cursor: Cursor?): ArrayList<SimpleContact> {
val contacts = ArrayList<SimpleContact>()
val packageName = context.packageName.removeSuffix(".debug")
if (packageName != "com.simplemobiletools.dialer" && packageName != "com.simplemobiletools.smsmessenger" && packageName != "com.simplemobiletools.calendar.pro") {
return contacts
}
try {
cursor?.use {
if (cursor.moveToFirst()) {
do {
val rawId = cursor.getIntValue(COL_RAW_ID)
val contactId = cursor.getIntValue(COL_CONTACT_ID)
val name = cursor.getStringValue(COL_NAME)
val photoUri = cursor.getStringValue(COL_PHOTO_URI)
val phoneNumbersJson = cursor.getStringValue(COL_PHONE_NUMBERS)
val birthdaysJson = cursor.getStringValue(COL_BIRTHDAYS)
val anniversariesJson = cursor.getStringValue(COL_ANNIVERSARIES)
val phoneNumbersToken = object : TypeToken<ArrayList<PhoneNumber>>() {}.type
val phoneNumbers = Gson().fromJson<ArrayList<PhoneNumber>>(phoneNumbersJson, phoneNumbersToken) ?: ArrayList()
val stringsToken = object : TypeToken<ArrayList<String>>() {}.type
val birthdays = Gson().fromJson<ArrayList<String>>(birthdaysJson, stringsToken) ?: ArrayList()
val anniversaries = Gson().fromJson<ArrayList<String>>(anniversariesJson, stringsToken) ?: ArrayList()
val contact = SimpleContact(rawId, contactId, name, photoUri, phoneNumbers, birthdays, anniversaries)
contacts.add(contact)
} while (cursor.moveToNext())
}
}
} catch (ignored: Exception) {
}
return contacts
}
fun getContacts(context: Context, cursor: Cursor?): ArrayList<Contact> {
val contacts = ArrayList<Contact>()
val packageName = context.packageName.removeSuffix(".debug")
if (packageName != "com.simplemobiletools.dialer" && packageName != "com.simplemobiletools.smsmessenger" && packageName != "com.simplemobiletools.calendar.pro") {
return contacts
}
try {
cursor?.use {
if (cursor.moveToFirst()) {
do {
val rawId = cursor.getIntValue(COL_RAW_ID)
val contactId = cursor.getIntValue(COL_CONTACT_ID)
val name = cursor.getStringValue(COL_NAME)
val photoUri = cursor.getStringValue(COL_PHOTO_URI)
val phoneNumbersJson = cursor.getStringValue(COL_PHONE_NUMBERS)
val birthdaysJson = cursor.getStringValue(COL_BIRTHDAYS)
val anniversariesJson = cursor.getStringValue(COL_ANNIVERSARIES)
val phoneNumbersToken = object : TypeToken<ArrayList<PhoneNumber>>() {}.type
val phoneNumbers = Gson().fromJson<ArrayList<PhoneNumber>>(phoneNumbersJson, phoneNumbersToken) ?: ArrayList()
val stringsToken = object : TypeToken<ArrayList<String>>() {}.type
val birthdays = Gson().fromJson<ArrayList<String>>(birthdaysJson, stringsToken) ?: ArrayList()
val anniversaries = Gson().fromJson<ArrayList<String>>(anniversariesJson, stringsToken) ?: ArrayList()
val names = if (name.contains(",")) {
name.split(",")
} else {
name.split(" ")
}
var firstName = names.firstOrNull() ?: ""
if (name.contains(",")) {
firstName += ", "
}
val middleName = if (names.size >= 3) {
names.subList(1, names.size - 1).joinToString(" ")
} else {
""
}
val surname = names.lastOrNull()?.takeIf { names.size > 1 } ?: ""
val contact = Contact(
id = rawId,
contactId = contactId,
firstName = firstName,
middleName = middleName,
surname = surname,
photoUri = photoUri,
phoneNumbers = phoneNumbers,
source = SMT_PRIVATE
).also {
it.birthdays = birthdays
it.anniversaries = anniversaries
}
contacts.add(contact)
} while (cursor.moveToNext())
}
}
} catch (ignored: Exception) {
}
return contacts
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/MyContactsContentProvider.kt | 2431144464 |
package com.simplemobiletools.commons.helpers
import com.simplemobiletools.commons.models.BlockedNumber
import java.io.OutputStream
object BlockedNumbersExporter {
fun exportBlockedNumbers(
blockedNumbers: ArrayList<BlockedNumber>,
outputStream: OutputStream?,
callback: (result: ExportResult) -> Unit,
) {
if (outputStream == null) {
callback.invoke(ExportResult.EXPORT_FAIL)
return
}
try {
outputStream.bufferedWriter().use { out ->
out.write(blockedNumbers.joinToString(BLOCKED_NUMBERS_EXPORT_DELIMITER) {
it.number
})
}
callback.invoke(ExportResult.EXPORT_OK)
} catch (e: Exception) {
callback.invoke(ExportResult.EXPORT_FAIL)
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/BlockedNumbersExporter.kt | 1656258369 |
package com.simplemobiletools.commons.helpers
import android.accounts.Account
import android.accounts.AccountManager
import android.content.*
import android.graphics.Bitmap
import android.net.Uri
import android.os.Handler
import android.os.Looper
import android.provider.ContactsContract
import android.provider.ContactsContract.*
import android.provider.MediaStore
import android.text.TextUtils
import android.util.SparseArray
import com.simplemobiletools.commons.R
import com.simplemobiletools.commons.extensions.*
import com.simplemobiletools.commons.models.PhoneNumber
import com.simplemobiletools.commons.models.contacts.*
import com.simplemobiletools.commons.overloads.times
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import java.io.OutputStream
import java.util.Locale
class ContactsHelper(val context: Context) {
private val BATCH_SIZE = 50
private var displayContactSources = ArrayList<String>()
fun getContacts(
getAll: Boolean = false,
gettingDuplicates: Boolean = false,
ignoredContactSources: HashSet<String> = HashSet(),
showOnlyContactsWithNumbers: Boolean = context.baseConfig.showOnlyContactsWithNumbers,
callback: (ArrayList<Contact>) -> Unit
) {
ensureBackgroundThread {
val contacts = SparseArray<Contact>()
displayContactSources = context.getVisibleContactSources()
if (getAll) {
displayContactSources = if (ignoredContactSources.isEmpty()) {
context.getAllContactSources().map { it.name }.toMutableList() as ArrayList
} else {
context.getAllContactSources().filter {
it.getFullIdentifier().isNotEmpty() && !ignoredContactSources.contains(it.getFullIdentifier())
}.map { it.name }.toMutableList() as ArrayList
}
}
getDeviceContacts(contacts, ignoredContactSources, gettingDuplicates)
if (displayContactSources.contains(SMT_PRIVATE)) {
LocalContactsHelper(context).getAllContacts().forEach {
contacts.put(it.id, it)
}
}
val contactsSize = contacts.size()
val tempContacts = ArrayList<Contact>(contactsSize)
val resultContacts = ArrayList<Contact>(contactsSize)
(0 until contactsSize).filter {
if (ignoredContactSources.isEmpty() && showOnlyContactsWithNumbers) {
contacts.valueAt(it).phoneNumbers.isNotEmpty()
} else {
true
}
}.mapTo(tempContacts) {
contacts.valueAt(it)
}
if (context.baseConfig.mergeDuplicateContacts && ignoredContactSources.isEmpty() && !getAll) {
tempContacts.filter { displayContactSources.contains(it.source) }.groupBy { it.getNameToDisplay().toLowerCase() }.values.forEach { it ->
if (it.size == 1) {
resultContacts.add(it.first())
} else {
val sorted = it.sortedByDescending { it.getStringToCompare().length }
resultContacts.add(sorted.first())
}
}
} else {
resultContacts.addAll(tempContacts)
}
// groups are obtained with contactID, not rawID, so assign them to proper contacts like this
val groups = getContactGroups(getStoredGroupsSync())
val size = groups.size()
for (i in 0 until size) {
val key = groups.keyAt(i)
resultContacts.firstOrNull { it.contactId == key }?.groups = groups.valueAt(i)
}
Contact.sorting = context.baseConfig.sorting
Contact.startWithSurname = context.baseConfig.startNameWithSurname
resultContacts.sort()
Handler(Looper.getMainLooper()).post {
callback(resultContacts)
}
}
}
private fun getContentResolverAccounts(): HashSet<ContactSource> {
val sources = HashSet<ContactSource>()
arrayOf(Groups.CONTENT_URI, Settings.CONTENT_URI, RawContacts.CONTENT_URI).forEach {
fillSourcesFromUri(it, sources)
}
return sources
}
private fun fillSourcesFromUri(uri: Uri, sources: HashSet<ContactSource>) {
val projection = arrayOf(
RawContacts.ACCOUNT_NAME,
RawContacts.ACCOUNT_TYPE
)
context.queryCursor(uri, projection) { cursor ->
val name = cursor.getStringValue(RawContacts.ACCOUNT_NAME) ?: ""
val type = cursor.getStringValue(RawContacts.ACCOUNT_TYPE) ?: ""
var publicName = name
if (type == TELEGRAM_PACKAGE) {
publicName = context.getString(R.string.telegram)
}
val source = ContactSource(name, type, publicName)
sources.add(source)
}
}
private fun getDeviceContacts(contacts: SparseArray<Contact>, ignoredContactSources: HashSet<String>?, gettingDuplicates: Boolean) {
if (!context.hasPermission(PERMISSION_READ_CONTACTS)) {
return
}
val ignoredSources = ignoredContactSources ?: context.baseConfig.ignoredContactSources
val uri = Data.CONTENT_URI
val projection = getContactProjection()
arrayOf(CommonDataKinds.Organization.CONTENT_ITEM_TYPE, CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE).forEach { mimetype ->
val selection = "${Data.MIMETYPE} = ?"
val selectionArgs = arrayOf(mimetype)
val sortOrder = getSortString()
context.queryCursor(uri, projection, selection, selectionArgs, sortOrder, true) { cursor ->
val accountName = cursor.getStringValue(RawContacts.ACCOUNT_NAME) ?: ""
val accountType = cursor.getStringValue(RawContacts.ACCOUNT_TYPE) ?: ""
if (ignoredSources.contains("$accountName:$accountType")) {
return@queryCursor
}
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
var prefix = ""
var firstName = ""
var middleName = ""
var surname = ""
var suffix = ""
// ignore names at Organization type contacts
if (mimetype == CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE) {
prefix = cursor.getStringValue(CommonDataKinds.StructuredName.PREFIX) ?: ""
firstName = cursor.getStringValue(CommonDataKinds.StructuredName.GIVEN_NAME) ?: ""
middleName = cursor.getStringValue(CommonDataKinds.StructuredName.MIDDLE_NAME) ?: ""
surname = cursor.getStringValue(CommonDataKinds.StructuredName.FAMILY_NAME) ?: ""
suffix = cursor.getStringValue(CommonDataKinds.StructuredName.SUFFIX) ?: ""
}
var photoUri = ""
var starred = 0
var contactId = 0
var thumbnailUri = ""
var ringtone: String? = null
if (!gettingDuplicates) {
photoUri = cursor.getStringValue(CommonDataKinds.StructuredName.PHOTO_URI) ?: ""
starred = cursor.getIntValue(CommonDataKinds.StructuredName.STARRED)
contactId = cursor.getIntValue(Data.CONTACT_ID)
thumbnailUri = cursor.getStringValue(CommonDataKinds.StructuredName.PHOTO_THUMBNAIL_URI) ?: ""
ringtone = cursor.getStringValue(CommonDataKinds.StructuredName.CUSTOM_RINGTONE)
}
val nickname = ""
val numbers = ArrayList<PhoneNumber>() // proper value is obtained below
val emails = ArrayList<Email>()
val addresses = ArrayList<Address>()
val events = ArrayList<Event>()
val notes = ""
val groups = ArrayList<Group>()
val organization = Organization("", "")
val websites = ArrayList<String>()
val ims = ArrayList<IM>()
val contact = Contact(
id, prefix, firstName, middleName, surname, suffix, nickname, photoUri, numbers, emails, addresses,
events, accountName, starred, contactId, thumbnailUri, null, notes, groups, organization, websites, ims, mimetype, ringtone
)
contacts.put(id, contact)
}
}
val emails = getEmails()
var size = emails.size()
for (i in 0 until size) {
val key = emails.keyAt(i)
contacts[key]?.emails = emails.valueAt(i)
}
val organizations = getOrganizations()
size = organizations.size()
for (i in 0 until size) {
val key = organizations.keyAt(i)
contacts[key]?.organization = organizations.valueAt(i)
}
// no need to fetch some fields if we are only getting duplicates of the current contact
if (gettingDuplicates) {
return
}
val phoneNumbers = getPhoneNumbers(null)
size = phoneNumbers.size()
for (i in 0 until size) {
val key = phoneNumbers.keyAt(i)
if (contacts[key] != null) {
val numbers = phoneNumbers.valueAt(i)
contacts[key].phoneNumbers = numbers
}
}
val addresses = getAddresses()
size = addresses.size()
for (i in 0 until size) {
val key = addresses.keyAt(i)
contacts[key]?.addresses = addresses.valueAt(i)
}
val IMs = getIMs()
size = IMs.size()
for (i in 0 until size) {
val key = IMs.keyAt(i)
contacts[key]?.IMs = IMs.valueAt(i)
}
val events = getEvents()
size = events.size()
for (i in 0 until size) {
val key = events.keyAt(i)
contacts[key]?.events = events.valueAt(i)
}
val notes = getNotes()
size = notes.size()
for (i in 0 until size) {
val key = notes.keyAt(i)
contacts[key]?.notes = notes.valueAt(i)
}
val nicknames = getNicknames()
size = nicknames.size()
for (i in 0 until size) {
val key = nicknames.keyAt(i)
contacts[key]?.nickname = nicknames.valueAt(i)
}
val websites = getWebsites()
size = websites.size()
for (i in 0 until size) {
val key = websites.keyAt(i)
contacts[key]?.websites = websites.valueAt(i)
}
}
private fun getPhoneNumbers(contactId: Int? = null): SparseArray<ArrayList<PhoneNumber>> {
val phoneNumbers = SparseArray<ArrayList<PhoneNumber>>()
val uri = CommonDataKinds.Phone.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Phone.NUMBER,
CommonDataKinds.Phone.NORMALIZED_NUMBER,
CommonDataKinds.Phone.TYPE,
CommonDataKinds.Phone.LABEL,
CommonDataKinds.Phone.IS_PRIMARY
)
val selection = if (contactId == null) getSourcesSelection() else "${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = if (contactId == null) getSourcesSelectionArgs() else arrayOf(contactId.toString())
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val number = cursor.getStringValue(CommonDataKinds.Phone.NUMBER) ?: return@queryCursor
val normalizedNumber = cursor.getStringValue(CommonDataKinds.Phone.NORMALIZED_NUMBER) ?: number.normalizePhoneNumber()
val type = cursor.getIntValue(CommonDataKinds.Phone.TYPE)
val label = cursor.getStringValue(CommonDataKinds.Phone.LABEL) ?: ""
val isPrimary = cursor.getIntValue(CommonDataKinds.Phone.IS_PRIMARY) != 0
if (phoneNumbers[id] == null) {
phoneNumbers.put(id, ArrayList())
}
val phoneNumber = PhoneNumber(number, type, label, normalizedNumber, isPrimary)
phoneNumbers[id].add(phoneNumber)
}
return phoneNumbers
}
private fun getNicknames(contactId: Int? = null): SparseArray<String> {
val nicknames = SparseArray<String>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Nickname.NAME
)
val selection = getSourcesSelection(true, contactId != null)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.Nickname.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val nickname = cursor.getStringValue(CommonDataKinds.Nickname.NAME) ?: return@queryCursor
nicknames.put(id, nickname)
}
return nicknames
}
private fun getEmails(contactId: Int? = null): SparseArray<ArrayList<Email>> {
val emails = SparseArray<ArrayList<Email>>()
val uri = CommonDataKinds.Email.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Email.DATA,
CommonDataKinds.Email.TYPE,
CommonDataKinds.Email.LABEL
)
val selection = if (contactId == null) getSourcesSelection() else "${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = if (contactId == null) getSourcesSelectionArgs() else arrayOf(contactId.toString())
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val email = cursor.getStringValue(CommonDataKinds.Email.DATA) ?: return@queryCursor
val type = cursor.getIntValue(CommonDataKinds.Email.TYPE)
val label = cursor.getStringValue(CommonDataKinds.Email.LABEL) ?: ""
if (emails[id] == null) {
emails.put(id, ArrayList())
}
emails[id]!!.add(Email(email, type, label))
}
return emails
}
private fun getAddresses(contactId: Int? = null): SparseArray<ArrayList<Address>> {
val addresses = SparseArray<ArrayList<Address>>()
val uri = CommonDataKinds.StructuredPostal.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS,
CommonDataKinds.StructuredPostal.TYPE,
CommonDataKinds.StructuredPostal.LABEL
)
val selection = if (contactId == null) getSourcesSelection() else "${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = if (contactId == null) getSourcesSelectionArgs() else arrayOf(contactId.toString())
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val address = cursor.getStringValue(CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS) ?: return@queryCursor
val type = cursor.getIntValue(CommonDataKinds.StructuredPostal.TYPE)
val label = cursor.getStringValue(CommonDataKinds.StructuredPostal.LABEL) ?: ""
if (addresses[id] == null) {
addresses.put(id, ArrayList())
}
addresses[id]!!.add(Address(address, type, label))
}
return addresses
}
private fun getIMs(contactId: Int? = null): SparseArray<ArrayList<IM>> {
val IMs = SparseArray<ArrayList<IM>>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Im.DATA,
CommonDataKinds.Im.PROTOCOL,
CommonDataKinds.Im.CUSTOM_PROTOCOL
)
val selection = getSourcesSelection(true, contactId != null)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.Im.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val IM = cursor.getStringValue(CommonDataKinds.Im.DATA) ?: return@queryCursor
val type = cursor.getIntValue(CommonDataKinds.Im.PROTOCOL)
val label = cursor.getStringValue(CommonDataKinds.Im.CUSTOM_PROTOCOL) ?: ""
if (IMs[id] == null) {
IMs.put(id, ArrayList())
}
IMs[id]!!.add(IM(IM, type, label))
}
return IMs
}
private fun getEvents(contactId: Int? = null): SparseArray<ArrayList<Event>> {
val events = SparseArray<ArrayList<Event>>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Event.START_DATE,
CommonDataKinds.Event.TYPE
)
val selection = getSourcesSelection(true, contactId != null)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.Event.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val startDate = cursor.getStringValue(CommonDataKinds.Event.START_DATE) ?: return@queryCursor
val type = cursor.getIntValue(CommonDataKinds.Event.TYPE)
if (events[id] == null) {
events.put(id, ArrayList())
}
events[id]!!.add(Event(startDate, type))
}
return events
}
private fun getNotes(contactId: Int? = null): SparseArray<String> {
val notes = SparseArray<String>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Note.NOTE
)
val selection = getSourcesSelection(true, contactId != null)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.Note.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val note = cursor.getStringValue(CommonDataKinds.Note.NOTE) ?: return@queryCursor
notes.put(id, note)
}
return notes
}
private fun getOrganizations(contactId: Int? = null): SparseArray<Organization> {
val organizations = SparseArray<Organization>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Organization.COMPANY,
CommonDataKinds.Organization.TITLE
)
val selection = getSourcesSelection(true, contactId != null)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.Organization.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val company = cursor.getStringValue(CommonDataKinds.Organization.COMPANY) ?: ""
val title = cursor.getStringValue(CommonDataKinds.Organization.TITLE) ?: ""
if (company.isEmpty() && title.isEmpty()) {
return@queryCursor
}
val organization = Organization(company, title)
organizations.put(id, organization)
}
return organizations
}
private fun getWebsites(contactId: Int? = null): SparseArray<ArrayList<String>> {
val websites = SparseArray<ArrayList<String>>()
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.RAW_CONTACT_ID,
CommonDataKinds.Website.URL
)
val selection = getSourcesSelection(true, contactId != null)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.Website.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
val url = cursor.getStringValue(CommonDataKinds.Website.URL) ?: return@queryCursor
if (websites[id] == null) {
websites.put(id, ArrayList())
}
websites[id]!!.add(url)
}
return websites
}
private fun getContactGroups(storedGroups: ArrayList<Group>, contactId: Int? = null): SparseArray<ArrayList<Group>> {
val groups = SparseArray<ArrayList<Group>>()
if (!context.hasPermission(PERMISSION_READ_CONTACTS)) {
return groups
}
val uri = Data.CONTENT_URI
val projection = arrayOf(
Data.CONTACT_ID,
Data.DATA1
)
val selection = getSourcesSelection(true, contactId != null, false)
val selectionArgs = getSourcesSelectionArgs(CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE, contactId)
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getIntValue(Data.CONTACT_ID)
val newRowId = cursor.getLongValue(Data.DATA1)
val groupTitle = storedGroups.firstOrNull { it.id == newRowId }?.title ?: return@queryCursor
val group = Group(newRowId, groupTitle)
if (groups[id] == null) {
groups.put(id, ArrayList())
}
groups[id]!!.add(group)
}
return groups
}
private fun getQuestionMarks() = ("?," * displayContactSources.filter { it.isNotEmpty() }.size).trimEnd(',')
private fun getSourcesSelection(addMimeType: Boolean = false, addContactId: Boolean = false, useRawContactId: Boolean = true): String {
val strings = ArrayList<String>()
if (addMimeType) {
strings.add("${Data.MIMETYPE} = ?")
}
if (addContactId) {
strings.add("${if (useRawContactId) Data.RAW_CONTACT_ID else Data.CONTACT_ID} = ?")
} else {
// sometimes local device storage has null account_name, handle it properly
val accountnameString = StringBuilder()
if (displayContactSources.contains("")) {
accountnameString.append("(")
}
accountnameString.append("${RawContacts.ACCOUNT_NAME} IN (${getQuestionMarks()})")
if (displayContactSources.contains("")) {
accountnameString.append(" OR ${RawContacts.ACCOUNT_NAME} IS NULL)")
}
strings.add(accountnameString.toString())
}
return TextUtils.join(" AND ", strings)
}
private fun getSourcesSelectionArgs(mimetype: String? = null, contactId: Int? = null): Array<String> {
val args = ArrayList<String>()
if (mimetype != null) {
args.add(mimetype)
}
if (contactId != null) {
args.add(contactId.toString())
} else {
args.addAll(displayContactSources.filter { it.isNotEmpty() })
}
return args.toTypedArray()
}
fun getStoredGroups(callback: (ArrayList<Group>) -> Unit) {
ensureBackgroundThread {
val groups = getStoredGroupsSync()
Handler(Looper.getMainLooper()).post {
callback(groups)
}
}
}
fun getStoredGroupsSync(): ArrayList<Group> {
val groups = getDeviceStoredGroups()
groups.addAll(context.groupsDB.getGroups())
return groups
}
private fun getDeviceStoredGroups(): ArrayList<Group> {
val groups = ArrayList<Group>()
if (!context.hasPermission(PERMISSION_READ_CONTACTS)) {
return groups
}
val uri = Groups.CONTENT_URI
val projection = arrayOf(
Groups._ID,
Groups.TITLE,
Groups.SYSTEM_ID
)
val selection = "${Groups.AUTO_ADD} = ? AND ${Groups.FAVORITES} = ?"
val selectionArgs = arrayOf("0", "0")
context.queryCursor(uri, projection, selection, selectionArgs, showErrors = true) { cursor ->
val id = cursor.getLongValue(Groups._ID)
val title = cursor.getStringValue(Groups.TITLE) ?: return@queryCursor
val systemId = cursor.getStringValue(Groups.SYSTEM_ID)
if (groups.map { it.title }.contains(title) && systemId != null) {
return@queryCursor
}
groups.add(Group(id, title))
}
return groups
}
fun createNewGroup(title: String, accountName: String, accountType: String): Group? {
if (accountType == SMT_PRIVATE) {
val newGroup = Group(null, title)
val id = context.groupsDB.insertOrUpdate(newGroup)
newGroup.id = id
return newGroup
}
val operations = ArrayList<ContentProviderOperation>()
ContentProviderOperation.newInsert(Groups.CONTENT_URI).apply {
withValue(Groups.TITLE, title)
withValue(Groups.GROUP_VISIBLE, 1)
withValue(Groups.ACCOUNT_NAME, accountName)
withValue(Groups.ACCOUNT_TYPE, accountType)
operations.add(build())
}
try {
val results = context.contentResolver.applyBatch(AUTHORITY, operations)
val rawId = ContentUris.parseId(results[0].uri!!)
return Group(rawId, title)
} catch (e: Exception) {
context.showErrorToast(e)
}
return null
}
fun renameGroup(group: Group) {
val operations = ArrayList<ContentProviderOperation>()
ContentProviderOperation.newUpdate(Groups.CONTENT_URI).apply {
val selection = "${Groups._ID} = ?"
val selectionArgs = arrayOf(group.id.toString())
withSelection(selection, selectionArgs)
withValue(Groups.TITLE, group.title)
operations.add(build())
}
try {
context.contentResolver.applyBatch(AUTHORITY, operations)
} catch (e: Exception) {
context.showErrorToast(e)
}
}
fun deleteGroup(id: Long) {
val operations = ArrayList<ContentProviderOperation>()
val uri = ContentUris.withAppendedId(Groups.CONTENT_URI, id).buildUpon()
.appendQueryParameter(CALLER_IS_SYNCADAPTER, "true")
.build()
operations.add(ContentProviderOperation.newDelete(uri).build())
try {
context.contentResolver.applyBatch(AUTHORITY, operations)
} catch (e: Exception) {
context.showErrorToast(e)
}
}
fun getContactWithId(id: Int, isLocalPrivate: Boolean): Contact? {
if (id == 0) {
return null
} else if (isLocalPrivate) {
return LocalContactsHelper(context).getContactWithId(id)
}
val selection = "(${Data.MIMETYPE} = ? OR ${Data.MIMETYPE} = ?) AND ${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = arrayOf(CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE, id.toString())
return parseContactCursor(selection, selectionArgs)
}
fun getContactFromUri(uri: Uri): Contact? {
val key = getLookupKeyFromUri(uri) ?: return null
return getContactWithLookupKey(key)
}
private fun getLookupKeyFromUri(lookupUri: Uri): String? {
val projection = arrayOf(ContactsContract.Contacts.LOOKUP_KEY)
val cursor = context.contentResolver.query(lookupUri, projection, null, null, null)
cursor?.use {
if (cursor.moveToFirst()) {
return cursor.getStringValue(ContactsContract.Contacts.LOOKUP_KEY)
}
}
return null
}
fun getContactWithLookupKey(key: String): Contact? {
val selection = "(${Data.MIMETYPE} = ? OR ${Data.MIMETYPE} = ?) AND ${Data.LOOKUP_KEY} = ?"
val selectionArgs = arrayOf(CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE, key)
return parseContactCursor(selection, selectionArgs)
}
private fun parseContactCursor(selection: String, selectionArgs: Array<String>): Contact? {
val storedGroups = getStoredGroupsSync()
val uri = Data.CONTENT_URI
val projection = getContactProjection()
val cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
cursor?.use {
if (cursor.moveToFirst()) {
val id = cursor.getIntValue(Data.RAW_CONTACT_ID)
var prefix = ""
var firstName = ""
var middleName = ""
var surname = ""
var suffix = ""
var mimetype = cursor.getStringValue(Data.MIMETYPE)
// if first line is an Organization type contact, go to next line if available
if (mimetype != CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE) {
if (!cursor.isLast() && cursor.moveToNext()) {
mimetype = cursor.getStringValue(Data.MIMETYPE)
}
}
// ignore names at Organization type contacts
if (mimetype == CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE) {
prefix = cursor.getStringValue(CommonDataKinds.StructuredName.PREFIX) ?: ""
firstName = cursor.getStringValue(CommonDataKinds.StructuredName.GIVEN_NAME) ?: ""
middleName = cursor.getStringValue(CommonDataKinds.StructuredName.MIDDLE_NAME) ?: ""
surname = cursor.getStringValue(CommonDataKinds.StructuredName.FAMILY_NAME) ?: ""
suffix = cursor.getStringValue(CommonDataKinds.StructuredName.SUFFIX) ?: ""
}
val nickname = getNicknames(id)[id] ?: ""
val photoUri = cursor.getStringValueOrNull(CommonDataKinds.Phone.PHOTO_URI) ?: ""
val number = getPhoneNumbers(id)[id] ?: ArrayList()
val emails = getEmails(id)[id] ?: ArrayList()
val addresses = getAddresses(id)[id] ?: ArrayList()
val events = getEvents(id)[id] ?: ArrayList()
val notes = getNotes(id)[id] ?: ""
val accountName = cursor.getStringValue(RawContacts.ACCOUNT_NAME) ?: ""
val starred = cursor.getIntValue(CommonDataKinds.StructuredName.STARRED)
val ringtone = cursor.getStringValue(CommonDataKinds.StructuredName.CUSTOM_RINGTONE)
val contactId = cursor.getIntValue(Data.CONTACT_ID)
val groups = getContactGroups(storedGroups, contactId)[contactId] ?: ArrayList()
val thumbnailUri = cursor.getStringValue(CommonDataKinds.StructuredName.PHOTO_THUMBNAIL_URI) ?: ""
val organization = getOrganizations(id)[id] ?: Organization("", "")
val websites = getWebsites(id)[id] ?: ArrayList()
val ims = getIMs(id)[id] ?: ArrayList()
return Contact(
id, prefix, firstName, middleName, surname, suffix, nickname, photoUri, number, emails, addresses, events,
accountName, starred, contactId, thumbnailUri, null, notes, groups, organization, websites, ims, mimetype, ringtone
)
}
}
return null
}
fun getContactSources(callback: (ArrayList<ContactSource>) -> Unit) {
ensureBackgroundThread {
callback(getContactSourcesSync())
}
}
private fun getContactSourcesSync(): ArrayList<ContactSource> {
val sources = getDeviceContactSources()
sources.add(context.getPrivateContactSource())
return ArrayList(sources)
}
fun getSaveableContactSources(callback: (ArrayList<ContactSource>) -> Unit) {
ensureBackgroundThread {
val ignoredTypes = arrayListOf(
SIGNAL_PACKAGE,
TELEGRAM_PACKAGE,
WHATSAPP_PACKAGE,
THREEMA_PACKAGE
)
val contactSources = getContactSourcesSync()
val filteredSources = contactSources.filter { !ignoredTypes.contains(it.type) }.toMutableList() as ArrayList<ContactSource>
callback(filteredSources)
}
}
fun getDeviceContactSources(): LinkedHashSet<ContactSource> {
val sources = LinkedHashSet<ContactSource>()
if (!context.hasPermission(PERMISSION_READ_CONTACTS)) {
return sources
}
if (!context.baseConfig.wasLocalAccountInitialized) {
initializeLocalPhoneAccount()
context.baseConfig.wasLocalAccountInitialized = true
}
val accounts = AccountManager.get(context).accounts
if (context.hasPermission(PERMISSION_READ_SYNC_SETTINGS)) {
accounts.forEach {
if (ContentResolver.getIsSyncable(it, AUTHORITY) == 1) {
var publicName = it.name
if (it.type == TELEGRAM_PACKAGE) {
publicName = context.getString(R.string.telegram)
} else if (it.type == VIBER_PACKAGE) {
publicName = context.getString(R.string.viber)
}
val contactSource = ContactSource(it.name, it.type, publicName)
sources.add(contactSource)
}
}
}
var hadEmptyAccount = false
val allAccounts = getContentResolverAccounts()
val contentResolverAccounts = allAccounts.filter {
if (it.name.isEmpty() && it.type.isEmpty() && allAccounts.none { it.name.lowercase(Locale.getDefault()) == "phone" }) {
hadEmptyAccount = true
}
it.name.isNotEmpty() && it.type.isNotEmpty() && !accounts.contains(Account(it.name, it.type))
}
sources.addAll(contentResolverAccounts)
if (hadEmptyAccount) {
sources.add(ContactSource("", "", context.getString(R.string.phone_storage)))
}
return sources
}
// make sure the local Phone contact source is initialized and available
// https://stackoverflow.com/a/6096508/1967672
private fun initializeLocalPhoneAccount() {
try {
val operations = ArrayList<ContentProviderOperation>()
ContentProviderOperation.newInsert(RawContacts.CONTENT_URI).apply {
withValue(RawContacts.ACCOUNT_NAME, null)
withValue(RawContacts.ACCOUNT_TYPE, null)
operations.add(build())
}
val results = context.contentResolver.applyBatch(AUTHORITY, operations)
val rawContactUri = results.firstOrNull()?.uri ?: return
context.contentResolver.delete(rawContactUri, null, null)
} catch (ignored: Exception) {
}
}
private fun getContactSourceType(accountName: String) = getDeviceContactSources().firstOrNull { it.name == accountName }?.type ?: ""
private fun getContactProjection() = arrayOf(
Data.MIMETYPE,
Data.CONTACT_ID,
Data.RAW_CONTACT_ID,
CommonDataKinds.StructuredName.PREFIX,
CommonDataKinds.StructuredName.GIVEN_NAME,
CommonDataKinds.StructuredName.MIDDLE_NAME,
CommonDataKinds.StructuredName.FAMILY_NAME,
CommonDataKinds.StructuredName.SUFFIX,
CommonDataKinds.StructuredName.PHOTO_URI,
CommonDataKinds.StructuredName.PHOTO_THUMBNAIL_URI,
CommonDataKinds.StructuredName.STARRED,
CommonDataKinds.StructuredName.CUSTOM_RINGTONE,
RawContacts.ACCOUNT_NAME,
RawContacts.ACCOUNT_TYPE
)
private fun getSortString(): String {
val sorting = context.baseConfig.sorting
return when {
sorting and SORT_BY_FIRST_NAME != 0 -> "${CommonDataKinds.StructuredName.GIVEN_NAME} COLLATE NOCASE"
sorting and SORT_BY_MIDDLE_NAME != 0 -> "${CommonDataKinds.StructuredName.MIDDLE_NAME} COLLATE NOCASE"
sorting and SORT_BY_SURNAME != 0 -> "${CommonDataKinds.StructuredName.FAMILY_NAME} COLLATE NOCASE"
sorting and SORT_BY_FULL_NAME != 0 -> CommonDataKinds.StructuredName.DISPLAY_NAME
else -> Data.RAW_CONTACT_ID
}
}
private fun getRealContactId(id: Long): Int {
val uri = Data.CONTENT_URI
val projection = getContactProjection()
val selection = "(${Data.MIMETYPE} = ? OR ${Data.MIMETYPE} = ?) AND ${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = arrayOf(CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE, id.toString())
val cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
cursor?.use {
if (cursor.moveToFirst()) {
return cursor.getIntValue(Data.CONTACT_ID)
}
}
return 0
}
fun updateContact(contact: Contact, photoUpdateStatus: Int): Boolean {
context.toast(R.string.updating)
if (contact.isPrivate()) {
return LocalContactsHelper(context).insertOrUpdateContact(contact)
}
try {
val operations = ArrayList<ContentProviderOperation>()
ContentProviderOperation.newUpdate(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ?"
val selectionArgs = arrayOf(contact.id.toString(), contact.mimetype)
withSelection(selection, selectionArgs)
withValue(CommonDataKinds.StructuredName.PREFIX, contact.prefix)
withValue(CommonDataKinds.StructuredName.GIVEN_NAME, contact.firstName)
withValue(CommonDataKinds.StructuredName.MIDDLE_NAME, contact.middleName)
withValue(CommonDataKinds.StructuredName.FAMILY_NAME, contact.surname)
withValue(CommonDataKinds.StructuredName.SUFFIX, contact.suffix)
operations.add(build())
}
// delete nickname
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Nickname.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add nickname
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Nickname.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Nickname.NAME, contact.nickname)
operations.add(build())
}
// delete phone numbers
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add phone numbers
contact.phoneNumbers.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Phone.NUMBER, it.value)
withValue(CommonDataKinds.Phone.NORMALIZED_NUMBER, it.normalizedNumber)
withValue(CommonDataKinds.Phone.TYPE, it.type)
withValue(CommonDataKinds.Phone.LABEL, it.label)
withValue(CommonDataKinds.Phone.IS_PRIMARY, it.isPrimary)
operations.add(build())
}
}
// delete emails
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Email.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add emails
contact.emails.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Email.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Email.DATA, it.value)
withValue(CommonDataKinds.Email.TYPE, it.type)
withValue(CommonDataKinds.Email.LABEL, it.label)
operations.add(build())
}
}
// delete addresses
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add addresses
contact.addresses.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, it.value)
withValue(CommonDataKinds.StructuredPostal.TYPE, it.type)
withValue(CommonDataKinds.StructuredPostal.LABEL, it.label)
operations.add(build())
}
}
// delete IMs
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Im.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add IMs
contact.IMs.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Im.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Im.DATA, it.value)
withValue(CommonDataKinds.Im.PROTOCOL, it.type)
withValue(CommonDataKinds.Im.CUSTOM_PROTOCOL, it.label)
operations.add(build())
}
}
// delete events
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Event.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add events
contact.events.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Event.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Event.START_DATE, it.value)
withValue(CommonDataKinds.Event.TYPE, it.type)
operations.add(build())
}
}
// delete notes
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Note.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add notes
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Note.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Note.NOTE, contact.notes)
operations.add(build())
}
// delete organization
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add organization
if (contact.organization.isNotEmpty()) {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Organization.COMPANY, contact.organization.company)
withValue(CommonDataKinds.Organization.TYPE, DEFAULT_ORGANIZATION_TYPE)
withValue(CommonDataKinds.Organization.TITLE, contact.organization.jobPosition)
withValue(CommonDataKinds.Organization.TYPE, DEFAULT_ORGANIZATION_TYPE)
operations.add(build())
}
}
// delete websites
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? "
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Website.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
// add websites
contact.websites.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Website.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Website.URL, it)
withValue(CommonDataKinds.Website.TYPE, DEFAULT_WEBSITE_TYPE)
operations.add(build())
}
}
// delete groups
val relevantGroupIDs = getStoredGroupsSync().map { it.id }
if (relevantGroupIDs.isNotEmpty()) {
val IDsString = TextUtils.join(",", relevantGroupIDs)
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? AND ${Data.DATA1} IN ($IDsString)"
val selectionArgs = arrayOf(contact.contactId.toString(), CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
}
// add groups
contact.groups.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.GroupMembership.GROUP_ROW_ID, it.id)
operations.add(build())
}
}
// favorite, ringtone
try {
val uri = Uri.withAppendedPath(Contacts.CONTENT_URI, contact.contactId.toString())
val contentValues = ContentValues(2)
contentValues.put(Contacts.STARRED, contact.starred)
contentValues.put(Contacts.CUSTOM_RINGTONE, contact.ringtone)
context.contentResolver.update(uri, contentValues, null, null)
} catch (e: Exception) {
context.showErrorToast(e)
}
// photo
when (photoUpdateStatus) {
PHOTO_ADDED, PHOTO_CHANGED -> addPhoto(contact, operations)
PHOTO_REMOVED -> removePhoto(contact, operations)
}
context.contentResolver.applyBatch(AUTHORITY, operations)
return true
} catch (e: Exception) {
context.showErrorToast(e)
return false
}
}
private fun addPhoto(contact: Contact, operations: ArrayList<ContentProviderOperation>): ArrayList<ContentProviderOperation> {
if (contact.photoUri.isNotEmpty()) {
val photoUri = Uri.parse(contact.photoUri)
val bitmap = MediaStore.Images.Media.getBitmap(context.contentResolver, photoUri)
val thumbnailSize = context.getPhotoThumbnailSize()
val scaledPhoto = Bitmap.createScaledBitmap(bitmap, thumbnailSize, thumbnailSize, false)
val scaledSizePhotoData = scaledPhoto.getByteArray()
scaledPhoto.recycle()
val fullSizePhotoData = bitmap.getByteArray()
bitmap.recycle()
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, contact.id)
withValue(Data.MIMETYPE, CommonDataKinds.Photo.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Photo.PHOTO, scaledSizePhotoData)
operations.add(build())
}
addFullSizePhoto(contact.id.toLong(), fullSizePhotoData)
}
return operations
}
private fun removePhoto(contact: Contact, operations: ArrayList<ContentProviderOperation>): ArrayList<ContentProviderOperation> {
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.RAW_CONTACT_ID} = ? AND ${Data.MIMETYPE} = ?"
val selectionArgs = arrayOf(contact.id.toString(), CommonDataKinds.Photo.CONTENT_ITEM_TYPE)
withSelection(selection, selectionArgs)
operations.add(build())
}
return operations
}
fun addContactsToGroup(contacts: ArrayList<Contact>, groupId: Long) {
try {
val operations = ArrayList<ContentProviderOperation>()
contacts.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValue(Data.RAW_CONTACT_ID, it.id)
withValue(Data.MIMETYPE, CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.GroupMembership.GROUP_ROW_ID, groupId)
operations.add(build())
}
if (operations.size % BATCH_SIZE == 0) {
context.contentResolver.applyBatch(AUTHORITY, operations)
operations.clear()
}
}
context.contentResolver.applyBatch(AUTHORITY, operations)
} catch (e: Exception) {
context.showErrorToast(e)
}
}
fun removeContactsFromGroup(contacts: ArrayList<Contact>, groupId: Long) {
try {
val operations = ArrayList<ContentProviderOperation>()
contacts.forEach {
ContentProviderOperation.newDelete(Data.CONTENT_URI).apply {
val selection = "${Data.CONTACT_ID} = ? AND ${Data.MIMETYPE} = ? AND ${Data.DATA1} = ?"
val selectionArgs = arrayOf(it.contactId.toString(), CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE, groupId.toString())
withSelection(selection, selectionArgs)
operations.add(build())
}
if (operations.size % BATCH_SIZE == 0) {
context.contentResolver.applyBatch(AUTHORITY, operations)
operations.clear()
}
}
context.contentResolver.applyBatch(AUTHORITY, operations)
} catch (e: Exception) {
context.showErrorToast(e)
}
}
fun insertContact(contact: Contact): Boolean {
if (contact.isPrivate()) {
return LocalContactsHelper(context).insertOrUpdateContact(contact)
}
try {
val operations = ArrayList<ContentProviderOperation>()
ContentProviderOperation.newInsert(RawContacts.CONTENT_URI).apply {
withValue(RawContacts.ACCOUNT_NAME, contact.source)
withValue(RawContacts.ACCOUNT_TYPE, getContactSourceType(contact.source))
operations.add(build())
}
// names
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.StructuredName.PREFIX, contact.prefix)
withValue(CommonDataKinds.StructuredName.GIVEN_NAME, contact.firstName)
withValue(CommonDataKinds.StructuredName.MIDDLE_NAME, contact.middleName)
withValue(CommonDataKinds.StructuredName.FAMILY_NAME, contact.surname)
withValue(CommonDataKinds.StructuredName.SUFFIX, contact.suffix)
operations.add(build())
}
// nickname
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Nickname.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Nickname.NAME, contact.nickname)
operations.add(build())
}
// phone numbers
contact.phoneNumbers.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Phone.NUMBER, it.value)
withValue(CommonDataKinds.Phone.NORMALIZED_NUMBER, it.normalizedNumber)
withValue(CommonDataKinds.Phone.TYPE, it.type)
withValue(CommonDataKinds.Phone.LABEL, it.label)
withValue(CommonDataKinds.Phone.IS_PRIMARY, it.isPrimary)
operations.add(build())
}
}
// emails
contact.emails.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Email.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Email.DATA, it.value)
withValue(CommonDataKinds.Email.TYPE, it.type)
withValue(CommonDataKinds.Email.LABEL, it.label)
operations.add(build())
}
}
// addresses
contact.addresses.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, it.value)
withValue(CommonDataKinds.StructuredPostal.TYPE, it.type)
withValue(CommonDataKinds.StructuredPostal.LABEL, it.label)
operations.add(build())
}
}
// IMs
contact.IMs.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Im.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Im.DATA, it.value)
withValue(CommonDataKinds.Im.PROTOCOL, it.type)
withValue(CommonDataKinds.Im.CUSTOM_PROTOCOL, it.label)
operations.add(build())
}
}
// events
contact.events.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Event.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Event.START_DATE, it.value)
withValue(CommonDataKinds.Event.TYPE, it.type)
operations.add(build())
}
}
// notes
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Note.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Note.NOTE, contact.notes)
operations.add(build())
}
// organization
if (contact.organization.isNotEmpty()) {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Organization.COMPANY, contact.organization.company)
withValue(CommonDataKinds.Organization.TYPE, DEFAULT_ORGANIZATION_TYPE)
withValue(CommonDataKinds.Organization.TITLE, contact.organization.jobPosition)
withValue(CommonDataKinds.Organization.TYPE, DEFAULT_ORGANIZATION_TYPE)
operations.add(build())
}
}
// websites
contact.websites.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.Website.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.Website.URL, it)
withValue(CommonDataKinds.Website.TYPE, DEFAULT_WEBSITE_TYPE)
operations.add(build())
}
}
// groups
contact.groups.forEach {
ContentProviderOperation.newInsert(Data.CONTENT_URI).apply {
withValueBackReference(Data.RAW_CONTACT_ID, 0)
withValue(Data.MIMETYPE, CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE)
withValue(CommonDataKinds.GroupMembership.GROUP_ROW_ID, it.id)
operations.add(build())
}
}
// photo (inspired by https://gist.github.com/slightfoot/5985900)
var fullSizePhotoData: ByteArray? = null
if (contact.photoUri.isNotEmpty()) {
val photoUri = Uri.parse(contact.photoUri)
fullSizePhotoData = context.contentResolver.openInputStream(photoUri)?.readBytes()
}
val results = context.contentResolver.applyBatch(AUTHORITY, operations)
// storing contacts on some devices seems to be messed up and they move on Phone instead, or disappear completely
// try storing a lighter contact version with this oldschool version too just so it wont disappear, future edits work well
if (getContactSourceType(contact.source).contains(".sim")) {
val simUri = Uri.parse("content://icc/adn")
ContentValues().apply {
put("number", contact.phoneNumbers.firstOrNull()?.value ?: "")
put("tag", contact.getNameToDisplay())
context.contentResolver.insert(simUri, this)
}
}
// fullsize photo
val rawId = ContentUris.parseId(results[0].uri!!)
if (contact.photoUri.isNotEmpty() && fullSizePhotoData != null) {
addFullSizePhoto(rawId, fullSizePhotoData)
}
// favorite, ringtone
val userId = getRealContactId(rawId)
if (userId != 0) {
val uri = Uri.withAppendedPath(Contacts.CONTENT_URI, userId.toString())
val contentValues = ContentValues(2)
contentValues.put(Contacts.STARRED, contact.starred)
contentValues.put(Contacts.CUSTOM_RINGTONE, contact.ringtone)
context.contentResolver.update(uri, contentValues, null, null)
}
return true
} catch (e: Exception) {
context.showErrorToast(e)
return false
}
}
private fun addFullSizePhoto(contactId: Long, fullSizePhotoData: ByteArray) {
val baseUri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, contactId)
val displayPhotoUri = Uri.withAppendedPath(baseUri, RawContacts.DisplayPhoto.CONTENT_DIRECTORY)
val fileDescriptor = context.contentResolver.openAssetFileDescriptor(displayPhotoUri, "rw")
val photoStream = fileDescriptor!!.createOutputStream()
photoStream.write(fullSizePhotoData)
photoStream.close()
fileDescriptor.close()
}
fun getContactMimeTypeId(contactId: String, mimeType: String): String {
val uri = Data.CONTENT_URI
val projection = arrayOf(Data._ID, Data.RAW_CONTACT_ID, Data.MIMETYPE)
val selection = "${Data.MIMETYPE} = ? AND ${Data.RAW_CONTACT_ID} = ?"
val selectionArgs = arrayOf(mimeType, contactId)
val cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
cursor?.use {
if (cursor.moveToFirst()) {
return cursor.getStringValue(Data._ID)
}
}
return ""
}
fun addFavorites(contacts: ArrayList<Contact>) {
ensureBackgroundThread {
toggleLocalFavorites(contacts, true)
if (context.hasContactPermissions()) {
toggleFavorites(contacts, true)
}
}
}
fun removeFavorites(contacts: ArrayList<Contact>) {
ensureBackgroundThread {
toggleLocalFavorites(contacts, false)
if (context.hasContactPermissions()) {
toggleFavorites(contacts, false)
}
}
}
private fun toggleFavorites(contacts: ArrayList<Contact>, addToFavorites: Boolean) {
try {
val operations = ArrayList<ContentProviderOperation>()
contacts.filter { !it.isPrivate() }.map { it.contactId.toString() }.forEach {
val uri = Uri.withAppendedPath(Contacts.CONTENT_URI, it)
ContentProviderOperation.newUpdate(uri).apply {
withValue(Contacts.STARRED, if (addToFavorites) 1 else 0)
operations.add(build())
}
if (operations.size % BATCH_SIZE == 0) {
context.contentResolver.applyBatch(AUTHORITY, operations)
operations.clear()
}
}
context.contentResolver.applyBatch(AUTHORITY, operations)
} catch (e: Exception) {
context.showErrorToast(e)
}
}
private fun toggleLocalFavorites(contacts: ArrayList<Contact>, addToFavorites: Boolean) {
val localContacts = contacts.filter { it.isPrivate() }.map { it.id }.toTypedArray()
LocalContactsHelper(context).toggleFavorites(localContacts, addToFavorites)
}
fun updateRingtone(contactId: String, newUri: String) {
try {
val operations = ArrayList<ContentProviderOperation>()
val uri = Uri.withAppendedPath(Contacts.CONTENT_URI, contactId)
ContentProviderOperation.newUpdate(uri).apply {
withValue(Contacts.CUSTOM_RINGTONE, newUri)
operations.add(build())
}
context.contentResolver.applyBatch(AUTHORITY, operations)
} catch (e: Exception) {
context.showErrorToast(e)
}
}
fun deleteContact(originalContact: Contact, deleteClones: Boolean = false, callback: (success: Boolean) -> Unit) {
ensureBackgroundThread {
if (deleteClones) {
getDuplicatesOfContact(originalContact, true) { contacts ->
ensureBackgroundThread {
if (deleteContacts(contacts)) {
callback(true)
}
}
}
} else {
if (deleteContacts(arrayListOf(originalContact))) {
callback(true)
}
}
}
}
fun deleteContacts(contacts: ArrayList<Contact>): Boolean {
val localContacts = contacts.filter { it.isPrivate() }.map { it.id.toLong() }.toMutableList()
LocalContactsHelper(context).deleteContactIds(localContacts)
return try {
val operations = ArrayList<ContentProviderOperation>()
val selection = "${RawContacts._ID} = ?"
contacts.filter { !it.isPrivate() }.forEach {
ContentProviderOperation.newDelete(RawContacts.CONTENT_URI).apply {
val selectionArgs = arrayOf(it.id.toString())
withSelection(selection, selectionArgs)
operations.add(build())
}
if (operations.size % BATCH_SIZE == 0) {
context.contentResolver.applyBatch(AUTHORITY, operations)
operations.clear()
}
}
if (context.hasPermission(PERMISSION_WRITE_CONTACTS)) {
context.contentResolver.applyBatch(AUTHORITY, operations)
}
true
} catch (e: Exception) {
context.showErrorToast(e)
false
}
}
fun getDuplicatesOfContact(contact: Contact, addOriginal: Boolean, callback: (ArrayList<Contact>) -> Unit) {
ensureBackgroundThread {
getContacts(true, true) { contacts ->
val duplicates =
contacts.filter { it.id != contact.id && it.getHashToCompare() == contact.getHashToCompare() }.toMutableList() as ArrayList<Contact>
if (addOriginal) {
duplicates.add(contact)
}
callback(duplicates)
}
}
}
fun getContactsToExport(selectedContactSources: Set<String>, callback: (List<Contact>) -> Unit) {
getContacts(getAll = true) { receivedContacts ->
val contacts = receivedContacts.filter { it.source in selectedContactSources }
callback(contacts)
}
}
fun exportContacts(contacts: List<Contact>, outputStream: OutputStream): ExportResult {
return try {
val jsonString = Json.encodeToString(contacts)
outputStream.use {
it.write(jsonString.toByteArray())
}
ExportResult.EXPORT_OK
} catch (_: Error) {
ExportResult.EXPORT_FAIL
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/ContactsHelper.kt | 3033753997 |
package com.simplemobiletools.commons.helpers
// taken from https://gist.github.com/MichaelRocks/1b94bb44c7804e999dbf31dac86955ec
// make IMG_5.jpg come before IMG_10.jpg
class AlphanumericComparator {
fun compare(string1: String, string2: String): Int {
var thisMarker = 0
var thatMarker = 0
val s1Length = string1.length
val s2Length = string2.length
while (thisMarker < s1Length && thatMarker < s2Length) {
val thisChunk = getChunk(string1, s1Length, thisMarker)
thisMarker += thisChunk.length
val thatChunk = getChunk(string2, s2Length, thatMarker)
thatMarker += thatChunk.length
// If both chunks contain numeric characters, sort them numerically.
var result: Int
if (isDigit(thisChunk[0]) && isDigit(thatChunk[0])) {
// Simple chunk comparison by length.
val thisChunkLength = thisChunk.length
result = thisChunkLength - thatChunk.length
// If equal, the first different number counts.
if (result == 0) {
for (i in 0 until thisChunkLength) {
result = thisChunk[i] - thatChunk[i]
if (result != 0) {
return result
}
}
}
} else {
result = thisChunk.compareTo(thatChunk)
}
if (result != 0) {
return result
}
}
return s1Length - s2Length
}
private fun getChunk(string: String, length: Int, marker: Int): String {
var current = marker
val chunk = StringBuilder()
var c = string[current]
chunk.append(c)
current++
if (isDigit(c)) {
while (current < length) {
c = string[current]
if (!isDigit(c)) {
break
}
chunk.append(c)
current++
}
} else {
while (current < length) {
c = string[current]
if (isDigit(c)) {
break
}
chunk.append(c)
current++
}
}
return chunk.toString()
}
private fun isDigit(ch: Char) = ch in '0'..'9'
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/AlphanumericComparator.kt | 62872250 |
package com.simplemobiletools.commons.helpers
enum class ExportResult {
EXPORT_FAIL, EXPORT_OK, EXPORT_PARTIAL
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/ExportResult.kt | 547305950 |
package com.simplemobiletools.commons.helpers
import android.app.Activity
import android.telephony.PhoneNumberUtils
import com.simplemobiletools.commons.extensions.addBlockedNumber
import com.simplemobiletools.commons.extensions.showErrorToast
import java.io.File
class BlockedNumbersImporter(
private val activity: Activity,
) {
enum class ImportResult {
IMPORT_FAIL, IMPORT_OK
}
fun importBlockedNumbers(path: String): ImportResult {
return try {
val inputStream = File(path).inputStream()
val numbers = inputStream.bufferedReader().use {
val content = it.readText().trimEnd().split(BLOCKED_NUMBERS_EXPORT_DELIMITER)
content.filter { text -> PhoneNumberUtils.isGlobalPhoneNumber(text) }
}
if (numbers.isNotEmpty()) {
numbers.forEach { number ->
activity.addBlockedNumber(number)
}
ImportResult.IMPORT_OK
} else {
ImportResult.IMPORT_FAIL
}
} catch (e: Exception) {
activity.showErrorToast(e)
ImportResult.IMPORT_FAIL
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/BlockedNumbersImporter.kt | 3939097844 |
package com.simplemobiletools.commons.helpers
import android.content.Context
import android.graphics.BitmapFactory
import android.net.Uri
import android.provider.ContactsContract.CommonDataKinds.Event
import android.provider.MediaStore
import com.simplemobiletools.commons.extensions.contactsDB
import com.simplemobiletools.commons.extensions.getByteArray
import com.simplemobiletools.commons.extensions.getEmptyContact
import com.simplemobiletools.commons.models.SimpleContact
import com.simplemobiletools.commons.models.contacts.Contact
import com.simplemobiletools.commons.models.contacts.*
import com.simplemobiletools.commons.models.contacts.LocalContact
class LocalContactsHelper(val context: Context) {
fun getAllContacts(favoritesOnly: Boolean = false): ArrayList<Contact> {
val contacts = if (favoritesOnly) context.contactsDB.getFavoriteContacts() else context.contactsDB.getContacts()
val storedGroups = ContactsHelper(context).getStoredGroupsSync()
return (contacts.map { convertLocalContactToContact(it, storedGroups) }.toMutableList() as? ArrayList<Contact>) ?: arrayListOf()
}
fun getContactWithId(id: Int): Contact? {
val storedGroups = ContactsHelper(context).getStoredGroupsSync()
return convertLocalContactToContact(context.contactsDB.getContactWithId(id), storedGroups)
}
fun insertOrUpdateContact(contact: Contact): Boolean {
val localContact = convertContactToLocalContact(contact)
return context.contactsDB.insertOrUpdate(localContact) > 0
}
fun addContactsToGroup(contacts: ArrayList<Contact>, groupId: Long) {
contacts.forEach {
val localContact = convertContactToLocalContact(it)
val newGroups = localContact.groups
newGroups.add(groupId)
newGroups.distinct()
localContact.groups = newGroups
context.contactsDB.insertOrUpdate(localContact)
}
}
fun removeContactsFromGroup(contacts: ArrayList<Contact>, groupId: Long) {
contacts.forEach {
val localContact = convertContactToLocalContact(it)
val newGroups = localContact.groups
newGroups.remove(groupId)
localContact.groups = newGroups
context.contactsDB.insertOrUpdate(localContact)
}
}
fun deleteContactIds(ids: MutableList<Long>) {
ids.chunked(30).forEach {
context.contactsDB.deleteContactIds(it)
}
}
fun toggleFavorites(ids: Array<Int>, addToFavorites: Boolean) {
val isStarred = if (addToFavorites) 1 else 0
ids.forEach {
context.contactsDB.updateStarred(isStarred, it)
}
}
fun updateRingtone(id: Int, ringtone: String) {
context.contactsDB.updateRingtone(ringtone, id)
}
private fun getPhotoByteArray(uri: String): ByteArray {
if (uri.isEmpty()) {
return ByteArray(0)
}
val photoUri = Uri.parse(uri)
val bitmap = MediaStore.Images.Media.getBitmap(context.contentResolver, photoUri)
val fullSizePhotoData = bitmap.getByteArray()
bitmap.recycle()
return fullSizePhotoData
}
private fun convertLocalContactToContact(localContact: LocalContact?, storedGroups: ArrayList<Group>): Contact? {
if (localContact == null) {
return null
}
val contactPhoto = if (localContact.photo == null) {
null
} else {
try {
BitmapFactory.decodeByteArray(localContact.photo, 0, localContact.photo!!.size)
} catch (e: OutOfMemoryError) {
null
}
}
return context.getEmptyContact().apply {
id = localContact.id!!
prefix = localContact.prefix
firstName = localContact.firstName
middleName = localContact.middleName
surname = localContact.surname
suffix = localContact.suffix
nickname = localContact.nickname
phoneNumbers = localContact.phoneNumbers
emails = localContact.emails
addresses = localContact.addresses
events = localContact.events
source = SMT_PRIVATE
starred = localContact.starred
contactId = localContact.id!!
thumbnailUri = ""
photo = contactPhoto
photoUri = localContact.photoUri
notes = localContact.notes
groups = storedGroups.filter { localContact.groups.contains(it.id) } as ArrayList<Group>
organization = Organization(localContact.company, localContact.jobPosition)
websites = localContact.websites
IMs = localContact.IMs
ringtone = localContact.ringtone
}
}
private fun convertContactToLocalContact(contact: Contact): LocalContact {
val photoByteArray = if (contact.photoUri.isNotEmpty()) {
getPhotoByteArray(contact.photoUri)
} else {
contact.photo?.getByteArray()
}
return getEmptyLocalContact().apply {
id = if (contact.id <= FIRST_CONTACT_ID) null else contact.id
prefix = contact.prefix
firstName = contact.firstName
middleName = contact.middleName
surname = contact.surname
suffix = contact.suffix
nickname = contact.nickname
photo = photoByteArray
phoneNumbers = contact.phoneNumbers
emails = contact.emails
events = contact.events
starred = contact.starred
addresses = contact.addresses
notes = contact.notes
groups = contact.groups.map { it.id }.toMutableList() as ArrayList<Long>
company = contact.organization.company
jobPosition = contact.organization.jobPosition
websites = contact.websites
IMs = contact.IMs
ringtone = contact.ringtone
}
}
fun getPrivateSimpleContactsSync(favoritesOnly: Boolean, withPhoneNumbersOnly: Boolean) = getAllContacts(favoritesOnly).mapNotNull {
convertContactToSimpleContact(it, withPhoneNumbersOnly)
}
companion object{
fun convertContactToSimpleContact(contact: Contact?, withPhoneNumbersOnly: Boolean): SimpleContact?{
return if (contact == null || (withPhoneNumbersOnly && contact.phoneNumbers.isEmpty())) {
null
} else {
val birthdays = contact.events.filter { it.type == Event.TYPE_BIRTHDAY }.map { it.value }.toMutableList() as ArrayList<String>
val anniversaries = contact.events.filter { it.type == Event.TYPE_ANNIVERSARY }.map { it.value }.toMutableList() as ArrayList<String>
SimpleContact(contact.id, contact.id, contact.getNameToDisplay(), contact.photoUri, contact.phoneNumbers, birthdays, anniversaries)
}
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/LocalContactsHelper.kt | 2833759484 |
package com.simplemobiletools.commons.helpers
import android.database.Cursor
import android.database.MatrixCursor
import android.database.MergeCursor
import android.net.Uri
import android.provider.DocumentsContract
import com.simplemobiletools.commons.extensions.getStringValue
// On Android 11, ExternalStorageProvider no longer returns Android/data and Android/obb as children
// of the Android directory on primary storage. However, the two child directories are actually
// still accessible.
// Inspired by: https://github.com/zhanghai/MaterialFiles/blob/master/app/src/main/java/me/zhanghai/android/files/provider/document/resolver/ExternalStorageProviderPrimaryAndroidDataHack.kt
object ExternalStorageProviderHack {
private const val ANDROID_DATA_DISPLAY_NAME = "data"
private const val ANDROID_OBB_DISPLAY_NAME = "obb"
private val CHILD_DOCUMENTS_CURSOR_COLUMN_NAMES = arrayOf(
DocumentsContract.Document.COLUMN_DOCUMENT_ID,
DocumentsContract.Document.COLUMN_DISPLAY_NAME,
DocumentsContract.Document.COLUMN_MIME_TYPE,
DocumentsContract.Document.COLUMN_LAST_MODIFIED,
DocumentsContract.Document.COLUMN_SIZE,
)
private fun getAndroidDocumentId(rootDocId: String): String {
return "$rootDocId:Android"
}
private fun getAndroidDataDocumentId(rootDocId: String): String {
return "${getAndroidDocumentId(rootDocId)}/data"
}
private fun getAndroidObbDocumentId(rootDocId: String): String {
return "${getAndroidDocumentId(rootDocId)}/obb"
}
fun transformQueryResult(rootDocId: String, uri: Uri, cursor: Cursor): Cursor {
val documentId = DocumentsContract.getDocumentId(uri)
if (uri.authority == EXTERNAL_STORAGE_PROVIDER_AUTHORITY && documentId == getAndroidDocumentId(rootDocId)) {
var hasDataRow = false
var hasObbRow = false
try {
while (cursor.moveToNext()) {
when (cursor.getStringValue(DocumentsContract.Document.COLUMN_DOCUMENT_ID)) {
getAndroidDataDocumentId(rootDocId) ->
hasDataRow = true
getAndroidObbDocumentId(rootDocId) ->
hasObbRow = true
}
if (hasDataRow && hasObbRow) {
break
}
}
} finally {
cursor.moveToPosition(-1)
}
if (hasDataRow && hasObbRow) {
return cursor
}
val extraCursor = MatrixCursor(CHILD_DOCUMENTS_CURSOR_COLUMN_NAMES)
if (!hasDataRow) {
extraCursor.newRow()
.add(
DocumentsContract.Document.COLUMN_DOCUMENT_ID,
getAndroidDataDocumentId(rootDocId)
)
.add(
DocumentsContract.Document.COLUMN_DISPLAY_NAME,
ANDROID_DATA_DISPLAY_NAME
)
.add(
DocumentsContract.Document.COLUMN_MIME_TYPE,
DocumentsContract.Document.MIME_TYPE_DIR
)
.add(
DocumentsContract.Document.COLUMN_LAST_MODIFIED,
System.currentTimeMillis()
)
.add(
DocumentsContract.Document.COLUMN_SIZE,
0L
)
}
if (!hasObbRow) {
extraCursor.newRow()
.add(
DocumentsContract.Document.COLUMN_DOCUMENT_ID,
getAndroidObbDocumentId(rootDocId)
)
.add(
DocumentsContract.Document.COLUMN_DISPLAY_NAME,
ANDROID_OBB_DISPLAY_NAME
)
.add(
DocumentsContract.Document.COLUMN_MIME_TYPE,
DocumentsContract.Document.MIME_TYPE_DIR
)
.add(
DocumentsContract.Document.COLUMN_LAST_MODIFIED,
System.currentTimeMillis()
)
.add(
DocumentsContract.Document.COLUMN_SIZE,
0L
)
}
return MergeCursor(arrayOf(cursor, extraCursor))
}
return cursor
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/ExternalStorageProviderHack.kt | 3375093559 |
package com.simplemobiletools.commons.helpers
import android.content.Context
import android.graphics.drawable.Drawable
import android.os.Build
import android.os.Looper
import android.provider.ContactsContract
import android.util.Log
import androidx.annotation.ChecksSdkIntAtLeast
import androidx.annotation.StringRes
import com.simplemobiletools.commons.R
import com.simplemobiletools.commons.extensions.normalizeString
import com.simplemobiletools.commons.models.contacts.LocalContact
import com.simplemobiletools.commons.overloads.times
const val EXTERNAL_STORAGE_PROVIDER_AUTHORITY = "com.android.externalstorage.documents"
const val EXTRA_SHOW_ADVANCED = "android.content.extra.SHOW_ADVANCED"
const val APP_NAME = "app_name"
const val APP_LICENSES = "app_licenses"
const val APP_FAQ = "app_faq"
const val APP_VERSION_NAME = "app_version_name"
const val APP_ICON_IDS = "app_icon_ids"
const val APP_ID = "app_id"
const val APP_LAUNCHER_NAME = "app_launcher_name"
const val REAL_FILE_PATH = "real_file_path_2"
const val IS_FROM_GALLERY = "is_from_gallery"
const val BROADCAST_REFRESH_MEDIA = "com.simplemobiletools.REFRESH_MEDIA"
const val REFRESH_PATH = "refresh_path"
const val IS_CUSTOMIZING_COLORS = "is_customizing_colors"
const val BLOCKED_NUMBERS_EXPORT_DELIMITER = ","
const val BLOCKED_NUMBERS_EXPORT_EXTENSION = ".txt"
const val NOMEDIA = ".nomedia"
const val YOUR_ALARM_SOUNDS_MIN_ID = 1000
const val SHOW_FAQ_BEFORE_MAIL = "show_faq_before_mail"
const val CHOPPED_LIST_DEFAULT_SIZE = 50
const val SAVE_DISCARD_PROMPT_INTERVAL = 1000L
const val SD_OTG_PATTERN = "^/storage/[A-Za-z0-9]{4}-[A-Za-z0-9]{4}$"
const val SD_OTG_SHORT = "^[A-Za-z0-9]{4}-[A-Za-z0-9]{4}$"
const val KEY_PHONE = "phone"
const val KEY_MAILTO = "mailto"
const val CONTACT_ID = "contact_id"
const val IS_PRIVATE = "is_private"
const val SMT_PRIVATE = "smt_private" // used at the contact source of local contacts hidden from other apps
const val FIRST_GROUP_ID = 10000L
const val MD5 = "MD5"
const val SHORT_ANIMATION_DURATION = 150L
val DARK_GREY = 0xFF333333.toInt()
const val LOWER_ALPHA = 0.25f
const val MEDIUM_ALPHA = 0.5f
const val HIGHER_ALPHA = 0.75f
// alpha values on a scale 0 - 255
const val LOWER_ALPHA_INT = 30
const val MEDIUM_ALPHA_INT = 90
const val HOUR_MINUTES = 60
const val DAY_MINUTES = 24 * HOUR_MINUTES
const val WEEK_MINUTES = DAY_MINUTES * 7
const val MONTH_MINUTES = DAY_MINUTES * 30
const val YEAR_MINUTES = DAY_MINUTES * 365
const val MINUTE_SECONDS = 60
const val HOUR_SECONDS = HOUR_MINUTES * 60
const val DAY_SECONDS = DAY_MINUTES * 60
const val WEEK_SECONDS = WEEK_MINUTES * 60
const val MONTH_SECONDS = MONTH_MINUTES * 60
const val YEAR_SECONDS = YEAR_MINUTES * 60
// shared preferences
const val PREFS_KEY = "Prefs"
const val APP_RUN_COUNT = "app_run_count"
const val LAST_VERSION = "last_version"
const val SD_TREE_URI = "tree_uri_2"
const val PRIMARY_ANDROID_DATA_TREE_URI = "primary_android_data_tree_uri_2"
const val OTG_ANDROID_DATA_TREE_URI = "otg_android_data_tree__uri_2"
const val SD_ANDROID_DATA_TREE_URI = "sd_android_data_tree_uri_2"
const val PRIMARY_ANDROID_OBB_TREE_URI = "primary_android_obb_tree_uri_2"
const val OTG_ANDROID_OBB_TREE_URI = "otg_android_obb_tree_uri_2"
const val SD_ANDROID_OBB_TREE_URI = "sd_android_obb_tree_uri_2"
const val OTG_TREE_URI = "otg_tree_uri_2"
const val SD_CARD_PATH = "sd_card_path_2"
const val OTG_REAL_PATH = "otg_real_path_2"
const val INTERNAL_STORAGE_PATH = "internal_storage_path"
const val TEXT_COLOR = "text_color"
const val BACKGROUND_COLOR = "background_color"
const val PRIMARY_COLOR = "primary_color_2"
const val ACCENT_COLOR = "accent_color"
const val APP_ICON_COLOR = "app_icon_color"
const val LAST_HANDLED_SHORTCUT_COLOR = "last_handled_shortcut_color"
const val LAST_ICON_COLOR = "last_icon_color"
const val CUSTOM_TEXT_COLOR = "custom_text_color"
const val CUSTOM_BACKGROUND_COLOR = "custom_background_color"
const val CUSTOM_PRIMARY_COLOR = "custom_primary_color"
const val CUSTOM_ACCENT_COLOR = "custom_accent_color"
const val CUSTOM_APP_ICON_COLOR = "custom_app_icon_color"
const val WIDGET_BG_COLOR = "widget_bg_color"
const val WIDGET_TEXT_COLOR = "widget_text_color"
const val PASSWORD_PROTECTION = "password_protection"
const val PASSWORD_HASH = "password_hash"
const val PROTECTION_TYPE = "protection_type"
const val APP_PASSWORD_PROTECTION = "app_password_protection"
const val APP_PASSWORD_HASH = "app_password_hash"
const val APP_PROTECTION_TYPE = "app_protection_type"
const val DELETE_PASSWORD_PROTECTION = "delete_password_protection"
const val DELETE_PASSWORD_HASH = "delete_password_hash"
const val DELETE_PROTECTION_TYPE = "delete_protection_type"
const val PROTECTED_FOLDER_PATH = "protected_folder_path_"
const val PROTECTED_FOLDER_HASH = "protected_folder_hash_"
const val PROTECTED_FOLDER_TYPE = "protected_folder_type_"
const val KEEP_LAST_MODIFIED = "keep_last_modified"
const val USE_ENGLISH = "use_english"
const val WAS_USE_ENGLISH_TOGGLED = "was_use_english_toggled"
const val WAS_SHARED_THEME_EVER_ACTIVATED = "was_shared_theme_ever_activated"
const val IS_USING_SHARED_THEME = "is_using_shared_theme"
const val IS_USING_AUTO_THEME = "is_using_auto_theme"
const val IS_USING_SYSTEM_THEME = "is_using_system_theme"
const val SHOULD_USE_SHARED_THEME = "should_use_shared_theme"
const val WAS_SHARED_THEME_FORCED = "was_shared_theme_forced"
const val WAS_CUSTOM_THEME_SWITCH_DESCRIPTION_SHOWN = "was_custom_theme_switch_description_shown"
const val SHOW_INFO_BUBBLE = "show_info_bubble"
const val LAST_CONFLICT_RESOLUTION = "last_conflict_resolution"
const val LAST_CONFLICT_APPLY_TO_ALL = "last_conflict_apply_to_all"
const val LAST_COPY_PATH = "last_copy_path"
const val HAD_THANK_YOU_INSTALLED = "had_thank_you_installed"
const val SKIP_DELETE_CONFIRMATION = "skip_delete_confirmation"
const val ENABLE_PULL_TO_REFRESH = "enable_pull_to_refresh"
const val SCROLL_HORIZONTALLY = "scroll_horizontally"
const val PREVENT_PHONE_FROM_SLEEPING = "prevent_phone_from_sleeping"
const val LAST_USED_VIEW_PAGER_PAGE = "last_used_view_pager_page"
const val USE_24_HOUR_FORMAT = "use_24_hour_format"
const val SUNDAY_FIRST = "sunday_first"
const val WAS_ALARM_WARNING_SHOWN = "was_alarm_warning_shown"
const val WAS_REMINDER_WARNING_SHOWN = "was_reminder_warning_shown"
const val USE_SAME_SNOOZE = "use_same_snooze"
const val SNOOZE_TIME = "snooze_delay"
const val VIBRATE_ON_BUTTON_PRESS = "vibrate_on_button_press"
const val YOUR_ALARM_SOUNDS = "your_alarm_sounds"
const val SILENT = "silent"
const val OTG_PARTITION = "otg_partition_2"
const val IS_USING_MODIFIED_APP_ICON = "is_using_modified_app_icon"
const val INITIAL_WIDGET_HEIGHT = "initial_widget_height"
const val WIDGET_ID_TO_MEASURE = "widget_id_to_measure"
const val WAS_ORANGE_ICON_CHECKED = "was_orange_icon_checked"
const val WAS_APP_ON_SD_SHOWN = "was_app_on_sd_shown"
const val WAS_BEFORE_ASKING_SHOWN = "was_before_asking_shown"
const val WAS_BEFORE_RATE_SHOWN = "was_before_rate_shown"
const val WAS_INITIAL_UPGRADE_TO_PRO_SHOWN = "was_initial_upgrade_to_pro_shown"
const val WAS_APP_ICON_CUSTOMIZATION_WARNING_SHOWN = "was_app_icon_customization_warning_shown"
const val APP_SIDELOADING_STATUS = "app_sideloading_status"
const val DATE_FORMAT = "date_format"
const val WAS_OTG_HANDLED = "was_otg_handled_2"
const val WAS_UPGRADED_FROM_FREE_SHOWN = "was_upgraded_from_free_shown"
const val WAS_RATE_US_PROMPT_SHOWN = "was_rate_us_prompt_shown"
const val WAS_APP_RATED = "was_app_rated"
const val WAS_SORTING_BY_NUMERIC_VALUE_ADDED = "was_sorting_by_numeric_value_added"
const val WAS_FOLDER_LOCKING_NOTICE_SHOWN = "was_folder_locking_notice_shown"
const val LAST_RENAME_USED = "last_rename_used"
const val LAST_RENAME_PATTERN_USED = "last_rename_pattern_used"
const val LAST_EXPORTED_SETTINGS_FOLDER = "last_exported_settings_folder"
const val LAST_EXPORTED_SETTINGS_FILE = "last_exported_settings_file"
const val LAST_BLOCKED_NUMBERS_EXPORT_PATH = "last_blocked_numbers_export_path"
const val BLOCK_UNKNOWN_NUMBERS = "block_unknown_numbers"
const val BLOCK_HIDDEN_NUMBERS = "block_hidden_numbers"
const val FONT_SIZE = "font_size"
const val WAS_MESSENGER_RECORDER_SHOWN = "was_messenger_recorder_shown"
const val DEFAULT_TAB = "default_tab"
const val START_NAME_WITH_SURNAME = "start_name_with_surname"
const val FAVORITES = "favorites"
const val SHOW_CALL_CONFIRMATION = "show_call_confirmation"
const val COLOR_PICKER_RECENT_COLORS = "color_picker_recent_colors"
const val SHOW_CONTACT_THUMBNAILS = "show_contact_thumbnails"
const val SHOW_PHONE_NUMBERS = "show_phone_numbers"
const val SHOW_ONLY_CONTACTS_WITH_NUMBERS = "show_only_contacts_with_numbers"
const val IGNORED_CONTACT_SOURCES = "ignored_contact_sources_2"
const val LAST_USED_CONTACT_SOURCE = "last_used_contact_source"
const val ON_CONTACT_CLICK = "on_contact_click"
const val SHOW_CONTACT_FIELDS = "show_contact_fields"
const val SHOW_TABS = "show_tabs"
const val SHOW_DIALPAD_BUTTON = "show_dialpad_button"
const val SPEED_DIAL = "speed_dial"
const val LAST_EXPORT_PATH = "last_export_path"
const val WAS_LOCAL_ACCOUNT_INITIALIZED = "was_local_account_initialized"
const val SHOW_PRIVATE_CONTACTS = "show_private_contacts"
const val MERGE_DUPLICATE_CONTACTS = "merge_duplicate_contacts"
const val FAVORITES_CONTACTS_ORDER = "favorites_contacts_order"
const val FAVORITES_CUSTOM_ORDER_SELECTED = "favorites_custom_order_selected"
const val VIEW_TYPE = "view_type"
const val CONTACTS_GRID_COLUMN_COUNT = "contacts_grid_column_count"
const val AUTO_BACKUP = "auto_backup"
const val AUTO_BACKUP_FOLDER = "auto_backup_folder"
const val AUTO_BACKUP_FILENAME = "auto_backup_filename"
const val LAST_AUTO_BACKUP_TIME = "last_auto_backup_time"
const val PASSWORD_RETRY_COUNT = "password_retry_count"
const val PASSWORD_COUNTDOWN_START_MS = "password_count_down_start_ms"
const val MAX_PASSWORD_RETRY_COUNT = 3
const val DEFAULT_PASSWORD_COUNTDOWN = 5
const val MINIMUM_PIN_LENGTH = 4
// contact grid view constants
const val CONTACTS_GRID_MAX_COLUMNS_COUNT = 10
// phone number/email types
const val CELL = "CELL"
const val WORK = "WORK"
const val HOME = "HOME"
const val OTHER = "OTHER"
const val PREF = "PREF"
const val MAIN = "MAIN"
const val FAX = "FAX"
const val WORK_FAX = "WORK;FAX"
const val HOME_FAX = "HOME;FAX"
const val PAGER = "PAGER"
const val MOBILE = "MOBILE"
// IMs not supported by Ez-vcard
const val HANGOUTS = "Hangouts"
const val QQ = "QQ"
const val JABBER = "Jabber"
// licenses
internal const val LICENSE_KOTLIN = 1L
const val LICENSE_SUBSAMPLING = 2L
const val LICENSE_GLIDE = 4L
const val LICENSE_CROPPER = 8L
const val LICENSE_FILTERS = 16L
const val LICENSE_RTL = 32L
const val LICENSE_JODA = 64L
const val LICENSE_STETHO = 128L
const val LICENSE_OTTO = 256L
const val LICENSE_PHOTOVIEW = 512L
const val LICENSE_PICASSO = 1024L
const val LICENSE_PATTERN = 2048L
const val LICENSE_REPRINT = 4096L
const val LICENSE_GIF_DRAWABLE = 8192L
const val LICENSE_AUTOFITTEXTVIEW = 16384L
const val LICENSE_ROBOLECTRIC = 32768L
const val LICENSE_ESPRESSO = 65536L
const val LICENSE_GSON = 131072L
const val LICENSE_LEAK_CANARY = 262144L
const val LICENSE_NUMBER_PICKER = 524288L
const val LICENSE_EXOPLAYER = 1048576L
const val LICENSE_PANORAMA_VIEW = 2097152L
const val LICENSE_SANSELAN = 4194304L
const val LICENSE_GESTURE_VIEWS = 8388608L
const val LICENSE_INDICATOR_FAST_SCROLL = 16777216L
const val LICENSE_EVENT_BUS = 33554432L
const val LICENSE_AUDIO_RECORD_VIEW = 67108864L
const val LICENSE_SMS_MMS = 134217728L
const val LICENSE_APNG = 268435456L
const val LICENSE_PDF_VIEW_PAGER = 536870912L
const val LICENSE_M3U_PARSER = 1073741824L
const val LICENSE_ANDROID_LAME = 2147483648L
const val LICENSE_PDF_VIEWER = 4294967296L
const val LICENSE_ZIP4J = 8589934592L
// global intents
const val OPEN_DOCUMENT_TREE_FOR_ANDROID_DATA_OR_OBB = 1000
const val OPEN_DOCUMENT_TREE_OTG = 1001
const val OPEN_DOCUMENT_TREE_SD = 1002
const val OPEN_DOCUMENT_TREE_FOR_SDK_30 = 1003
const val REQUEST_SET_AS = 1004
const val REQUEST_EDIT_IMAGE = 1005
const val SELECT_EXPORT_SETTINGS_FILE_INTENT = 1006
const val REQUEST_CODE_SET_DEFAULT_DIALER = 1007
const val CREATE_DOCUMENT_SDK_30 = 1008
const val REQUEST_CODE_SET_DEFAULT_CALLER_ID = 1010
// sorting
const val SORT_ORDER = "sort_order"
const val SORT_FOLDER_PREFIX = "sort_folder_" // storing folder specific values at using "Use for this folder only"
const val SORT_BY_NAME = 1
const val SORT_BY_DATE_MODIFIED = 2
const val SORT_BY_SIZE = 4
const val SORT_BY_DATE_TAKEN = 8
const val SORT_BY_EXTENSION = 16
const val SORT_BY_PATH = 32
const val SORT_BY_NUMBER = 64
const val SORT_BY_FIRST_NAME = 128
const val SORT_BY_MIDDLE_NAME = 256
const val SORT_BY_SURNAME = 512
const val SORT_DESCENDING = 1024
const val SORT_BY_TITLE = 2048
const val SORT_BY_ARTIST = 4096
const val SORT_BY_DURATION = 8192
const val SORT_BY_RANDOM = 16384
const val SORT_USE_NUMERIC_VALUE = 32768
const val SORT_BY_FULL_NAME = 65536
const val SORT_BY_CUSTOM = 131072
const val SORT_BY_DATE_CREATED = 262144
// security
const val WAS_PROTECTION_HANDLED = "was_protection_handled"
const val PROTECTION_NONE = -1
const val PROTECTION_PATTERN = 0
const val PROTECTION_PIN = 1
const val PROTECTION_FINGERPRINT = 2
// renaming
const val RENAME_SIMPLE = 0
const val RENAME_PATTERN = 1
const val SHOW_ALL_TABS = -1
const val SHOW_PATTERN = 0
const val SHOW_PIN = 1
const val SHOW_FINGERPRINT = 2
// permissions
const val PERMISSION_READ_STORAGE = 1
const val PERMISSION_WRITE_STORAGE = 2
const val PERMISSION_CAMERA = 3
const val PERMISSION_RECORD_AUDIO = 4
const val PERMISSION_READ_CONTACTS = 5
const val PERMISSION_WRITE_CONTACTS = 6
const val PERMISSION_READ_CALENDAR = 7
const val PERMISSION_WRITE_CALENDAR = 8
const val PERMISSION_CALL_PHONE = 9
const val PERMISSION_READ_CALL_LOG = 10
const val PERMISSION_WRITE_CALL_LOG = 11
const val PERMISSION_GET_ACCOUNTS = 12
const val PERMISSION_READ_SMS = 13
const val PERMISSION_SEND_SMS = 14
const val PERMISSION_READ_PHONE_STATE = 15
const val PERMISSION_MEDIA_LOCATION = 16
const val PERMISSION_POST_NOTIFICATIONS = 17
const val PERMISSION_READ_MEDIA_IMAGES = 18
const val PERMISSION_READ_MEDIA_VIDEO = 19
const val PERMISSION_READ_MEDIA_AUDIO = 20
const val PERMISSION_ACCESS_COARSE_LOCATION = 21
const val PERMISSION_ACCESS_FINE_LOCATION = 22
const val PERMISSION_READ_MEDIA_VISUAL_USER_SELECTED = 23
const val PERMISSION_READ_SYNC_SETTINGS = 24
// conflict resolving
const val CONFLICT_SKIP = 1
const val CONFLICT_OVERWRITE = 2
const val CONFLICT_MERGE = 3
const val CONFLICT_KEEP_BOTH = 4
// font sizes
const val FONT_SIZE_SMALL = 0
const val FONT_SIZE_MEDIUM = 1
const val FONT_SIZE_LARGE = 2
const val FONT_SIZE_EXTRA_LARGE = 3
const val MONDAY_BIT = 1
const val TUESDAY_BIT = 2
const val WEDNESDAY_BIT = 4
const val THURSDAY_BIT = 8
const val FRIDAY_BIT = 16
const val SATURDAY_BIT = 32
const val SUNDAY_BIT = 64
const val EVERY_DAY_BIT = MONDAY_BIT or TUESDAY_BIT or WEDNESDAY_BIT or THURSDAY_BIT or FRIDAY_BIT or SATURDAY_BIT or SUNDAY_BIT
const val WEEK_DAYS_BIT = MONDAY_BIT or TUESDAY_BIT or WEDNESDAY_BIT or THURSDAY_BIT or FRIDAY_BIT
const val WEEKENDS_BIT = SATURDAY_BIT or SUNDAY_BIT
const val SIDELOADING_UNCHECKED = 0
const val SIDELOADING_TRUE = 1
const val SIDELOADING_FALSE = 2
// default tabs
const val TAB_LAST_USED = 0
const val TAB_CONTACTS = 1
const val TAB_FAVORITES = 2
const val TAB_CALL_HISTORY = 4
const val TAB_GROUPS = 8
const val TAB_FILES = 16
const val TAB_RECENT_FILES = 32
const val TAB_STORAGE_ANALYSIS = 64
val photoExtensions: Array<String> get() = arrayOf(".jpg", ".png", ".jpeg", ".bmp", ".webp", ".heic", ".heif", ".apng", ".avif")
val videoExtensions: Array<String> get() = arrayOf(".mp4", ".mkv", ".webm", ".avi", ".3gp", ".mov", ".m4v", ".3gpp")
val audioExtensions: Array<String> get() = arrayOf(".mp3", ".wav", ".wma", ".ogg", ".m4a", ".opus", ".flac", ".aac", ".m4b")
val rawExtensions: Array<String> get() = arrayOf(".dng", ".orf", ".nef", ".arw", ".rw2", ".cr2", ".cr3")
val extensionsSupportingEXIF: Array<String> get() = arrayOf(".jpg", ".jpeg", ".png", ".webp", ".dng")
const val DATE_FORMAT_ONE = "dd.MM.yyyy"
const val DATE_FORMAT_TWO = "dd/MM/yyyy"
const val DATE_FORMAT_THREE = "MM/dd/yyyy"
const val DATE_FORMAT_FOUR = "yyyy-MM-dd"
const val DATE_FORMAT_FIVE = "d MMMM yyyy"
const val DATE_FORMAT_SIX = "MMMM d yyyy"
const val DATE_FORMAT_SEVEN = "MM-dd-yyyy"
const val DATE_FORMAT_EIGHT = "dd-MM-yyyy"
const val DATE_FORMAT_NINE = "yyyyMMdd"
const val DATE_FORMAT_TEN = "yyyy.MM.dd"
const val DATE_FORMAT_ELEVEN = "yy-MM-dd"
const val DATE_FORMAT_TWELVE = "yyMMdd"
const val DATE_FORMAT_THIRTEEN = "yy.MM.dd"
const val DATE_FORMAT_FOURTEEN = "yy/MM/dd"
const val TIME_FORMAT_12 = "hh:mm a"
const val TIME_FORMAT_24 = "HH:mm"
// possible icons at the top left corner
enum class NavigationIcon(@StringRes val accessibilityResId: Int) {
Cross(R.string.close),
Arrow(R.string.back),
None(0)
}
val appIconColorStrings = arrayListOf(
".Red",
".Pink",
".Purple",
".Deep_purple",
".Indigo",
".Blue",
".Light_blue",
".Cyan",
".Teal",
".Green",
".Light_green",
".Lime",
".Yellow",
".Amber",
".Orange",
".Deep_orange",
".Brown",
".Blue_grey",
".Grey_black"
)
// most app icon colors from md_app_icon_colors with reduced alpha
// used at showing contact placeholders without image
val letterBackgroundColors = arrayListOf(
0xCCD32F2F,
0xCCC2185B,
0xCC1976D2,
0xCC0288D1,
0xCC0097A7,
0xCC00796B,
0xCC388E3C,
0xCC689F38,
0xCCF57C00,
0xCCE64A19
)
// view types
const val VIEW_TYPE_GRID = 1
const val VIEW_TYPE_LIST = 2
const val VIEW_TYPE_UNEVEN_GRID = 3
fun isOnMainThread() = Looper.myLooper() == Looper.getMainLooper()
fun ensureBackgroundThread(callback: () -> Unit) {
if (isOnMainThread()) {
Thread {
callback()
}.start()
} else {
callback()
}
}
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.N)
fun isNougatPlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.N_MR1)
fun isNougatMR1Plus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.O)
fun isOreoPlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.O_MR1)
fun isOreoMr1Plus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.P)
fun isPiePlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.Q)
fun isQPlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.R)
fun isRPlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.S)
fun isSPlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.TIRAMISU)
fun isTiramisuPlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
fun isUpsideDownCakePlus() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
fun getDateFormats() = arrayListOf(
"--MM-dd",
"yyyy-MM-dd",
"yyyyMMdd",
"yyyy.MM.dd",
"yy-MM-dd",
"yyMMdd",
"yy.MM.dd",
"yy/MM/dd",
"MM-dd",
"MMdd",
"MM/dd",
"MM.dd"
)
fun getDateFormatsWithYear() = arrayListOf(
DATE_FORMAT_FOUR,
DATE_FORMAT_NINE,
DATE_FORMAT_TEN,
DATE_FORMAT_ELEVEN,
DATE_FORMAT_TWELVE,
DATE_FORMAT_THIRTEEN,
DATE_FORMAT_FOURTEEN,
)
val normalizeRegex = "\\p{InCombiningDiacriticalMarks}+".toRegex()
fun getConflictResolution(resolutions: LinkedHashMap<String, Int>, path: String): Int {
return if (resolutions.size == 1 && resolutions.containsKey("")) {
resolutions[""]!!
} else if (resolutions.containsKey(path)) {
resolutions[path]!!
} else {
CONFLICT_SKIP
}
}
val proPackages = arrayListOf("draw", "gallery", "filemanager", "contacts", "notes", "calendar")
fun mydebug(message: String) = Log.e("DEBUG", message)
fun getQuestionMarks(size: Int) = ("?," * size).trimEnd(',')
fun getFilePlaceholderDrawables(context: Context): HashMap<String, Drawable> {
val fileDrawables = HashMap<String, Drawable>()
hashMapOf<String, Int>().apply {
put("aep", R.drawable.ic_file_aep)
put("ai", R.drawable.ic_file_ai)
put("avi", R.drawable.ic_file_avi)
put("css", R.drawable.ic_file_css)
put("csv", R.drawable.ic_file_csv)
put("dbf", R.drawable.ic_file_dbf)
put("doc", R.drawable.ic_file_doc)
put("docx", R.drawable.ic_file_doc)
put("dwg", R.drawable.ic_file_dwg)
put("exe", R.drawable.ic_file_exe)
put("fla", R.drawable.ic_file_fla)
put("flv", R.drawable.ic_file_flv)
put("htm", R.drawable.ic_file_html)
put("html", R.drawable.ic_file_html)
put("ics", R.drawable.ic_file_ics)
put("indd", R.drawable.ic_file_indd)
put("iso", R.drawable.ic_file_iso)
put("jpg", R.drawable.ic_file_jpg)
put("jpeg", R.drawable.ic_file_jpg)
put("js", R.drawable.ic_file_js)
put("json", R.drawable.ic_file_json)
put("m4a", R.drawable.ic_file_m4a)
put("mp3", R.drawable.ic_file_mp3)
put("mp4", R.drawable.ic_file_mp4)
put("ogg", R.drawable.ic_file_ogg)
put("pdf", R.drawable.ic_file_pdf)
put("plproj", R.drawable.ic_file_plproj)
put("ppt", R.drawable.ic_file_ppt)
put("pptx", R.drawable.ic_file_ppt)
put("prproj", R.drawable.ic_file_prproj)
put("psd", R.drawable.ic_file_psd)
put("rtf", R.drawable.ic_file_rtf)
put("sesx", R.drawable.ic_file_sesx)
put("sql", R.drawable.ic_file_sql)
put("svg", R.drawable.ic_file_svg)
put("txt", R.drawable.ic_file_txt)
put("vcf", R.drawable.ic_file_vcf)
put("wav", R.drawable.ic_file_wav)
put("wmv", R.drawable.ic_file_wmv)
put("xls", R.drawable.ic_file_xls)
put("xlsx", R.drawable.ic_file_xls)
put("xml", R.drawable.ic_file_xml)
put("zip", R.drawable.ic_file_zip)
}.forEach { (key, value) ->
fileDrawables[key] = context.resources.getDrawable(value)
}
return fileDrawables
}
const val FIRST_CONTACT_ID = 1000000
const val DEFAULT_FILE_NAME = "contacts.vcf"
// visible fields filtering
const val SHOW_PREFIX_FIELD = 1
const val SHOW_FIRST_NAME_FIELD = 2
const val SHOW_MIDDLE_NAME_FIELD = 4
const val SHOW_SURNAME_FIELD = 8
const val SHOW_SUFFIX_FIELD = 16
const val SHOW_PHONE_NUMBERS_FIELD = 32
const val SHOW_EMAILS_FIELD = 64
const val SHOW_ADDRESSES_FIELD = 128
const val SHOW_EVENTS_FIELD = 256
const val SHOW_NOTES_FIELD = 512
const val SHOW_ORGANIZATION_FIELD = 1024
const val SHOW_GROUPS_FIELD = 2048
const val SHOW_CONTACT_SOURCE_FIELD = 4096
const val SHOW_WEBSITES_FIELD = 8192
const val SHOW_NICKNAME_FIELD = 16384
const val SHOW_IMS_FIELD = 32768
const val SHOW_RINGTONE_FIELD = 65536
const val DEFAULT_EMAIL_TYPE = ContactsContract.CommonDataKinds.Email.TYPE_HOME
const val DEFAULT_PHONE_NUMBER_TYPE = ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE
const val DEFAULT_ADDRESS_TYPE = ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME
const val DEFAULT_EVENT_TYPE = ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY
const val DEFAULT_ORGANIZATION_TYPE = ContactsContract.CommonDataKinds.Organization.TYPE_WORK
const val DEFAULT_WEBSITE_TYPE = ContactsContract.CommonDataKinds.Website.TYPE_HOMEPAGE
const val DEFAULT_IM_TYPE = ContactsContract.CommonDataKinds.Im.PROTOCOL_SKYPE
const val DEFAULT_MIMETYPE = ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE
// contact photo changes
const val PHOTO_ADDED = 1
const val PHOTO_REMOVED = 2
const val PHOTO_CHANGED = 3
const val PHOTO_UNCHANGED = 4
const val ON_CLICK_CALL_CONTACT = 1
const val ON_CLICK_VIEW_CONTACT = 2
const val ON_CLICK_EDIT_CONTACT = 3
// apps with special handling
const val TELEGRAM_PACKAGE = "org.telegram.messenger"
const val SIGNAL_PACKAGE = "org.thoughtcrime.securesms"
const val WHATSAPP_PACKAGE = "com.whatsapp"
const val VIBER_PACKAGE = "com.viber.voip"
const val THREEMA_PACKAGE = "ch.threema.app"
const val SOCIAL_VOICE_CALL = 0
const val SOCIAL_VIDEO_CALL = 1
const val SOCIAL_MESSAGE = 2
fun getEmptyLocalContact() = LocalContact(
0,
"",
"",
"",
"",
"",
"",
null,
"",
ArrayList(),
ArrayList(),
ArrayList(),
0,
ArrayList(),
"",
ArrayList(),
"",
"",
ArrayList(),
ArrayList(),
null
)
fun getProperText(text: String, shouldNormalize: Boolean) = if (shouldNormalize) text.normalizeString() else text
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/helpers/Constants.kt | 59083090 |
package com.simplemobiletools.commons.interfaces
import androidx.biometric.auth.AuthPromptHost
import com.simplemobiletools.commons.views.MyScrollView
interface SecurityTab {
fun initTab(
requiredHash: String,
listener: HashListener,
scrollView: MyScrollView,
biometricPromptHost: AuthPromptHost,
showBiometricAuthentication: Boolean
)
fun visibilityChanged(isVisible: Boolean)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/SecurityTab.kt | 1633737762 |
package com.simplemobiletools.commons.interfaces
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView
import com.simplemobiletools.commons.adapters.MyRecyclerViewAdapter
open class ItemMoveCallback(private val mAdapter: ItemTouchHelperContract, private val allowHorizontalDrag: Boolean = false) : ItemTouchHelper.Callback() {
override fun isLongPressDragEnabled() = false
override fun isItemViewSwipeEnabled() = false
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, i: Int) {}
override fun getMovementFlags(recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder): Int {
var dragFlags = ItemTouchHelper.UP or ItemTouchHelper.DOWN
if (allowHorizontalDrag) {
dragFlags = dragFlags or ItemTouchHelper.LEFT or ItemTouchHelper.RIGHT
}
return makeMovementFlags(dragFlags, 0)
}
override fun onMove(recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder, target: RecyclerView.ViewHolder): Boolean {
mAdapter.onRowMoved(viewHolder.adapterPosition, target.adapterPosition)
return true
}
override fun onSelectedChanged(viewHolder: RecyclerView.ViewHolder?, actionState: Int) {
if (actionState != ItemTouchHelper.ACTION_STATE_IDLE) {
if (viewHolder is MyRecyclerViewAdapter.ViewHolder) {
mAdapter.onRowSelected(viewHolder)
}
}
super.onSelectedChanged(viewHolder, actionState)
}
override fun clearView(recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder) {
super.clearView(recyclerView, viewHolder)
if (viewHolder is MyRecyclerViewAdapter.ViewHolder) {
mAdapter.onRowClear(viewHolder)
}
}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/ItemMoveCallback.kt | 2578461425 |
package com.simplemobiletools.commons.interfaces
import com.simplemobiletools.commons.adapters.MyRecyclerViewAdapter
interface ItemTouchHelperContract {
fun onRowMoved(fromPosition: Int, toPosition: Int)
fun onRowSelected(myViewHolder: MyRecyclerViewAdapter.ViewHolder?)
fun onRowClear(myViewHolder: MyRecyclerViewAdapter.ViewHolder?)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/ItemTouchHelperContract.kt | 3721496169 |
package com.simplemobiletools.commons.interfaces
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.simplemobiletools.commons.models.contacts.LocalContact
@Dao
interface ContactsDao {
@Query("SELECT * FROM contacts")
fun getContacts(): List<LocalContact>
@Query("SELECT * FROM contacts WHERE starred = 1")
fun getFavoriteContacts(): List<LocalContact>
@Query("SELECT * FROM contacts WHERE id = :id")
fun getContactWithId(id: Int): LocalContact?
@Query("SELECT * FROM contacts WHERE phone_numbers LIKE :number")
fun getContactWithNumber(number: String): LocalContact?
@Query("UPDATE contacts SET starred = :isStarred WHERE id = :id")
fun updateStarred(isStarred: Int, id: Int)
@Query("UPDATE contacts SET ringtone = :ringtone WHERE id = :id")
fun updateRingtone(ringtone: String, id: Int)
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertOrUpdate(contact: LocalContact): Long
@Query("DELETE FROM contacts WHERE id = :id")
fun deleteContactId(id: Int)
@Query("DELETE FROM contacts WHERE id IN (:ids)")
fun deleteContactIds(ids: List<Long>)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/ContactsDao.kt | 3305964679 |
package com.simplemobiletools.commons.interfaces
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.simplemobiletools.commons.models.contacts.Group
@Dao
interface GroupsDao {
@Query("SELECT * FROM groups")
fun getGroups(): List<Group>
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertOrUpdate(group: Group): Long
@Query("DELETE FROM groups WHERE id = :id")
fun deleteGroupId(id: Long)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/GroupsDao.kt | 1698260027 |
package com.simplemobiletools.commons.interfaces
import android.view.ActionMode
abstract class MyActionModeCallback : ActionMode.Callback {
var isSelectable = false
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/MyActionModeCallback.kt | 4085280082 |
package com.simplemobiletools.commons.interfaces
import com.simplemobiletools.commons.activities.BaseSimpleActivity
interface RenameTab {
fun initTab(activity: BaseSimpleActivity, paths: ArrayList<String>)
fun dialogConfirmed(useMediaFileExtension: Boolean, callback: (success: Boolean) -> Unit)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/RenameTab.kt | 1441124640 |
package com.simplemobiletools.commons.interfaces
import android.content.Context
import android.os.Handler
import android.os.Looper
import android.util.AttributeSet
import android.widget.RelativeLayout
import android.widget.TextView
import androidx.annotation.ColorInt
import androidx.core.os.postDelayed
import com.simplemobiletools.commons.R
import com.simplemobiletools.commons.extensions.baseConfig
import com.simplemobiletools.commons.extensions.countdown
import com.simplemobiletools.commons.extensions.getProperTextColor
import com.simplemobiletools.commons.helpers.DEFAULT_PASSWORD_COUNTDOWN
import com.simplemobiletools.commons.helpers.MAX_PASSWORD_RETRY_COUNT
abstract class BaseSecurityTab(context: Context, attrs: AttributeSet) : RelativeLayout(context, attrs), SecurityTab {
abstract val protectionType: Int
abstract val defaultTextRes: Int
abstract val wrongTextRes: Int
abstract val titleTextView: TextView
lateinit var computedHash: String
lateinit var requiredHash: String
lateinit var hashListener: HashListener
private val config = context.baseConfig
private val handler = Handler(Looper.getMainLooper())
open fun onLockedOutChange(lockedOut: Boolean) {}
fun isLockedOut() = requiredHash.isNotEmpty() && getCountdown() > 0
fun onCorrectPassword() {
resetCountdown()
handler.postDelayed(delayInMillis = 300) {
hashListener.receivedHash(computedHash, protectionType)
}
}
fun onIncorrectPassword() {
config.passwordRetryCount += 1
if (requiredHash.isNotEmpty() && shouldStartCountdown()) {
onLockedOutChange(lockedOut = true)
startCountdown()
} else {
updateTitle(context.getString(wrongTextRes), context.getColor(R.color.md_red))
handler.postDelayed(delayInMillis = 1000) {
updateTitle(context.getString(defaultTextRes), context.getProperTextColor())
}
}
}
fun maybeShowCountdown() {
if (shouldStartCountdown()) {
startCountdown()
} else {
updateCountdownText(0)
}
}
private fun shouldStartCountdown() = config.passwordRetryCount >= MAX_PASSWORD_RETRY_COUNT
private fun resetCountdown() {
config.passwordRetryCount = 0
config.passwordCountdownStartMs = 0
}
private fun getCountdown(): Int {
val retryCount = config.passwordRetryCount
if (retryCount >= MAX_PASSWORD_RETRY_COUNT) {
val currentTimeMs = System.currentTimeMillis()
val countdownStartMs = config.passwordCountdownStartMs
if (countdownStartMs == 0L) {
config.passwordCountdownStartMs = currentTimeMs
return DEFAULT_PASSWORD_COUNTDOWN
}
val countdownWaitMs = DEFAULT_PASSWORD_COUNTDOWN * 1000L
val elapsedMs = currentTimeMs - countdownStartMs
return if (elapsedMs < countdownWaitMs) {
val remainingMs = countdownWaitMs - elapsedMs
val remainingSeconds = remainingMs / 1000L
remainingSeconds.toInt()
} else {
0
}
}
return 0
}
private fun startCountdown() {
getCountdown().countdown(intervalMillis = 1000L) { count ->
updateCountdownText(count)
if (count == 0) {
resetCountdown()
onLockedOutChange(lockedOut = false)
}
}
}
private fun updateCountdownText(count: Int) {
removeCallbacks()
if (count > 0) {
updateTitle(context.getString(R.string.too_many_incorrect_attempts, count), context.getColor(R.color.md_red))
} else {
updateTitle(context.getString(defaultTextRes), context.getProperTextColor())
}
}
private fun removeCallbacks() = handler.removeCallbacksAndMessages(null)
private fun updateTitle(text: String, @ColorInt color: Int) {
titleTextView.text = text
titleTextView.setTextColor(color)
}
override fun visibilityChanged(isVisible: Boolean) {}
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/BaseSecurityTab.kt | 3817595374 |
package com.simplemobiletools.commons.interfaces
fun interface LineColorPickerListener {
fun colorChanged(index: Int, color: Int)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/LineColorPickerListener.kt | 383153319 |
package com.simplemobiletools.commons.interfaces
interface RecyclerScrollCallback {
fun onScrolled(scrollY: Int)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/RecyclerScrollCallback.kt | 2896236529 |
package com.simplemobiletools.commons.interfaces
interface HashListener {
fun receivedHash(hash: String, type: Int)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/HashListener.kt | 2459153698 |
package com.simplemobiletools.commons.interfaces
interface RefreshRecyclerViewListener {
fun refreshItems()
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/RefreshRecyclerViewListener.kt | 3068105451 |
package com.simplemobiletools.commons.interfaces
import androidx.recyclerview.widget.RecyclerView
interface StartReorderDragListener {
fun requestDrag(viewHolder: RecyclerView.ViewHolder)
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/StartReorderDragListener.kt | 706306918 |
package com.simplemobiletools.commons.interfaces
interface CopyMoveListener {
fun copySucceeded(copyOnly: Boolean, copiedAll: Boolean, destinationPath: String, wasCopyingOneFileOnly: Boolean)
fun copyFailed()
}
| CT/commons/src/main/kotlin/com/simplemobiletools/commons/interfaces/CopyMoveListener.kt | 4023623062 |
package com.example.taskproximity
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.taskproximity", appContext.packageName)
}
} | TaskProximityKotlin/app/src/androidTest/java/com/example/taskproximity/ExampleInstrumentedTest.kt | 931554655 |
package com.example.taskproximity
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | TaskProximityKotlin/app/src/test/java/com/example/taskproximity/ExampleUnitTest.kt | 3631725841 |
package com.example.taskproximity
import android.Manifest
import android.app.Service
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.location.Location
import android.location.LocationListener
import android.location.LocationManager
import android.os.Bundle
import android.os.IBinder
import androidx.core.app.ActivityCompat
import androidx.localbroadcastmanager.content.LocalBroadcastManager
class locationTrack : Service() {
private lateinit var locationManager: LocationManager
private lateinit var locationListener: LocationListener
override fun onCreate() {
super.onCreate()
// Initialize LocationManager and LocationListener
locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
locationListener = object : LocationListener {
override fun onLocationChanged(location: Location) {
// Broadcast the updated location to the activity
val intent = Intent("location_updated")
intent.putExtra("latitude", location.latitude)
intent.putExtra("longitude", location.longitude)
LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(intent)
}
override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
override fun onProviderEnabled(provider: String) {}
override fun onProviderDisabled(provider: String) {}
}
// Request location updates
if (ActivityCompat.checkSelfPermission(
this,
Manifest.permission.ACCESS_FINE_LOCATION
) == PackageManager.PERMISSION_GRANTED
) {
locationManager.requestLocationUpdates(
LocationManager.GPS_PROVIDER,
1000, // Update interval in milliseconds (1 second)
0f, // Minimum distance between updates in meters
locationListener
)
}
}
override fun onBind(intent: Intent): IBinder? {
return null
}
override fun onDestroy() {
super.onDestroy()
// Remove location updates when the service is destroyed
locationManager.removeUpdates(locationListener)
}
} | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/locationTrack.kt | 808132045 |
package com.example.taskproximity
import android.content.Intent
import android.os.Bundle
import android.widget.Button
import android.widget.LinearLayout
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.google.firebase.firestore.FirebaseFirestore
class editTask : AppCompatActivity() {
private lateinit var editTaskLayout: LinearLayout
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_edit_task)
editTaskLayout = findViewById(R.id.editTaskLayout)
// Retrieve data from Firestore and populate the LinearLayout with buttons for each document
val db = FirebaseFirestore.getInstance()
val collectionRef = db.collection("tasks")
collectionRef.get()
.addOnSuccessListener { documents ->
for (document in documents) {
val description = document.getString("description")
val latitude = document.getDouble("latitude")
val longitude = document.getDouble("longitude")
val status = document.getString("status")
val taskId = document.id // Use document ID instead of getString("taskId")
// Create a new button for each document and set the field values
val editTaskButton = Button(this)
editTaskButton.text = "Description: $description\n" +
"Latitude: $latitude\n" +
"Longitude: $longitude\n" +
"Status: $status\n" +
"Task ID: $taskId\n"
// Set button layout parameters
val layoutParams = LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.WRAP_CONTENT
)
layoutParams.setMargins(0, 0, 0, 16) // Optional: Add some margin between each button
editTaskButton.layoutParams = layoutParams
// Add a click listener to the button
editTaskButton.setOnClickListener {
val intent = Intent(this, TaskEditDescActivity::class.java)
intent.putExtra("taskId", taskId)
intent.putExtra("description", description)
intent.putExtra("latitude", latitude)
intent.putExtra("longitude", longitude)
intent.putExtra("status", status)
startActivity(intent)
}
// Add the new button to the tasksLayout LinearLayout
editTaskLayout.addView(editTaskButton)
}
}
.addOnFailureListener { exception ->
// Handle any errors
Toast.makeText(this, "Error: ${exception.message}", Toast.LENGTH_SHORT).show()
}
}
} | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/editTask.kt | 1764598929 |
package com.example.taskproximity
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val button1 = findViewById<Button>(R.id.loginButton)
val button2 = findViewById<Button>(R.id.signupButton)
button1.setOnClickListener{
val intent = Intent(this, Login::class.java)
startActivity(intent)
}
button2.setOnClickListener{
val intent2 = Intent(this, SignUp::class.java)
startActivity(intent2)
}
}
} | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/MainActivity.kt | 4265089429 |
package com.example.taskproximity
import android.Manifest
import android.annotation.SuppressLint
import android.content.pm.PackageManager
import android.location.Location
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationServices
import com.google.firebase.firestore.FirebaseFirestore
class adminAddTask : AppCompatActivity() {
private lateinit var tvLatitude: TextView
private lateinit var tvLongitude: TextView
private lateinit var etDescription: EditText
private lateinit var btnLocation: Button
private lateinit var fusedLocationClient: FusedLocationProviderClient
private var latitudeString: String = ""
private var longitudeString: String = ""
private var statusString: String = "active"
private var descriptionString: String = ""
private var taskId: String = ""
private val firestore: FirebaseFirestore = FirebaseFirestore.getInstance()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_admin_add_task)
tvLatitude = findViewById(R.id.tv_latitude)
tvLongitude = findViewById(R.id.tv_longitude)
etDescription = findViewById(R.id.etDescription)
btnLocation = findViewById(R.id.btn_location)
fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
btnLocation.setOnClickListener {
checkLocationPermission()
saveDescription()
generateRandomTaskId()
//createTask()
}
}
private fun checkLocationPermission() {
if (ContextCompat.checkSelfPermission(
this,
Manifest.permission.ACCESS_FINE_LOCATION
) != PackageManager.PERMISSION_GRANTED
) {
ActivityCompat.requestPermissions(
this,
arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION
)
} else {
getLastKnownLocation()
}
}
@SuppressLint("MissingPermission")
private fun getLastKnownLocation() {
fusedLocationClient.lastLocation
.addOnSuccessListener { location: Location? ->
location?.let {
val latitude = location.latitude
val longitude = location.longitude
latitudeString = latitude.toString()
longitudeString = longitude.toString()
tvLatitude.text = latitudeString
tvLongitude.text = longitudeString
createTask(latitude, longitude)
}
}
}
private fun saveDescription() {
descriptionString = etDescription.text.toString()
}
private fun generateRandomTaskId() {
val charPool: List<Char> = ('a'..'z') + ('A'..'Z') + ('0'..'9')
taskId = (1..10)
.map { kotlin.random.Random.nextInt(0, charPool.size) }
.map(charPool::get)
.joinToString("")
println("Random Task ID: $taskId")
}
private fun createTask(latitude: Double, longitude: Double) {
val task = Task(taskId, latitude, longitude, statusString, descriptionString)
saveTaskToFirestore(task)
}
private fun saveTaskToFirestore(task: Task) {
firestore.collection("tasks")
.add(task)
.addOnSuccessListener { documentReference ->
// Task saved successfully
Toast.makeText(this, "Task added successfully", Toast.LENGTH_SHORT).show()
finish()
}
.addOnFailureListener { e ->
// Error occurred while saving the task
Toast.makeText(this, "Error adding task: $e", Toast.LENGTH_SHORT).show()
}
}
companion object {
private const val PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 100
}
}
data class Task(
val taskId: String,
val latitude: Double,
val longitude: Double,
val status: String,
val description: String
) | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/adminAddTask.kt | 2157834771 |
package com.example.taskproximity
import android.Manifest
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import com.example.taskproximity.AdminHome
import com.example.taskproximity.R
import com.google.firebase.auth.FirebaseAuth
class Login : AppCompatActivity() {
private lateinit var emailEditText: EditText
private lateinit var passwordEditText: EditText
private lateinit var firebaseAuth: FirebaseAuth
private val notificationChannelId = "LOGIN_CHANNEL"
private val notificationId = 1
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
emailEditText = findViewById(R.id.username)
passwordEditText = findViewById(R.id.password)
firebaseAuth = FirebaseAuth.getInstance()
val loginUser = findViewById<Button>(R.id.loginUser)
val loginAdmin = findViewById<Button>(R.id.loginAdmin)
loginUser.setOnClickListener {
val email = emailEditText.text.toString()
val password = passwordEditText.text.toString()
login(email, password)
}
loginAdmin.setOnClickListener {
val email = emailEditText.text.toString()
val password = passwordEditText.text.toString()
loginAsAdmin(email, password)
}
}
private fun login(email: String, password: String) {
firebaseAuth.signInWithEmailAndPassword(email, password)
.addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
Toast.makeText(this, "Login successful!", Toast.LENGTH_SHORT).show()
val intent = Intent(this, userHome::class.java)
startActivity(intent)
finish()
} else {
Toast.makeText(this, "Login failed! Please try again.", Toast.LENGTH_SHORT).show()
}
}
}
private fun loginAsAdmin(email: String, password: String) {
if (!email.contains("admin")) {
showLoginNotification()
return
}
firebaseAuth.signInWithEmailAndPassword(email, password)
.addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
Toast.makeText(this, "Login successful!", Toast.LENGTH_SHORT).show()
val intent = Intent(this, AdminHome::class.java)
startActivity(intent)
finish()
} else {
Toast.makeText(this, "Login failed! Please try again.", Toast.LENGTH_SHORT).show()
}
}
}
private fun showLoginNotification() {
createNotificationChannel()
val builder = NotificationCompat.Builder(this, notificationChannelId)
.setSmallIcon(android.R.drawable.ic_dialog_info)
.setContentTitle("Login Failed")
.setContentText("Users can't log in as admin")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setAutoCancel(true)
val notificationManager = NotificationManagerCompat.from(this)
if (ActivityCompat.checkSelfPermission(
this,
Manifest.permission.POST_NOTIFICATIONS
) != PackageManager.PERMISSION_GRANTED
) {
ActivityCompat.requestPermissions(
this,
arrayOf(Manifest.permission.POST_NOTIFICATIONS),
0
)
} else {
notificationManager.notify(notificationId, builder.build())
}
}
private fun createNotificationChannel() {
// Create the NotificationChannel on devices running Android 8.0 and higher
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
val name = "Login Channel"
val descriptionText = "Channel for login notifications"
val importance = NotificationManager.IMPORTANCE_DEFAULT
val channel = NotificationChannel(notificationChannelId, name, importance).apply {
description = descriptionText
}
// Register the channel with the system
val notificationManager = getSystemService(NotificationManager::class.java)
notificationManager.createNotificationChannel(channel)
}
}
}
| TaskProximityKotlin/app/src/main/java/com/example/taskproximity/Login.kt | 938089063 |
package com.example.taskproximity
import android.Manifest
import android.annotation.SuppressLint
import android.content.Context
import android.location.Location
import android.location.LocationListener
import android.location.LocationManager
import android.os.Build
import android.os.Bundle
import androidx.annotation.NonNull
import androidx.annotation.RequiresPermission
class LocationTracker constructor(
val minTimeBetweenUpdates: Long = 5000.toLong(),
val minDistanceBetweenUpdates: Float = 10f,
val shouldUseGPS: Boolean = true,
val shouldUseNetwork: Boolean = true,
val shouldUsePassive: Boolean = true
) {
// Android LocationManager
private lateinit var locationManager: LocationManager
// Last known location
private var lastKnownLocation: Location? = null
// Custom Listener for the LocationManager
private val listener = object : LocationListener {
override fun onLocationChanged(p0: Location) {
Location(p0).let { currentLocation ->
lastKnownLocation = currentLocation
hasLocationFound = true
listeners.forEach { l -> l.onLocationFound(currentLocation) }
}
}
override fun onProviderDisabled(provider: String) {
behaviorListener.forEach { l -> l.onProviderDisabled(provider) }
}
override fun onProviderEnabled(provider: String) {
behaviorListener.forEach { l -> l.onProviderEnabled(provider) }
}
override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {
behaviorListener.forEach { l -> l.onStatusChanged(provider, status, extras) }
}
}
// List used to register the listeners to notify
private val listeners: MutableSet<Listener> = mutableSetOf()
// List used to register the behavior listeners to notify
private val behaviorListener: MutableSet<BehaviorListener> = mutableSetOf()
var isListening = false
private set
var hasLocationFound = false
private set
fun addListener(listener: Listener): Boolean = listeners.add(listener)
fun removeListener(listener: Listener): Boolean = listeners.remove(listener)
fun addBehaviorListener(listener: BehaviorListener): Boolean = behaviorListener.add(listener)
fun removeBehaviorListener(listener: BehaviorListener): Boolean = behaviorListener.remove(listener)
@RequiresPermission(anyOf = [Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION])
fun startListening(context: Context) {
initManagerAndUpdateLastKnownLocation(context)
if (!isListening) {
// Listen for GPS Updates
if (shouldUseGPS) {
registerForLocationUpdates(LocationManager.GPS_PROVIDER)
}
// Listen for Network Updates
if (shouldUseNetwork) {
registerForLocationUpdates(LocationManager.NETWORK_PROVIDER)
}
// Listen for Passive Updates
if (shouldUseNetwork) {
registerForLocationUpdates(LocationManager.PASSIVE_PROVIDER)
}
isListening = true
}
}
fun stopListening(clearListeners: Boolean = false) {
if (isListening) {
locationManager.removeUpdates(listener)
isListening = false
if (clearListeners) {
listeners.clear()
}
}
}
@RequiresPermission(anyOf = [Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION])
fun quickFix(@NonNull context: Context) {
initManagerAndUpdateLastKnownLocation(context)
lastKnownLocation?.let { lastLocation ->
listeners.forEach { l -> l.onLocationFound(lastLocation) }
}
}
@SuppressLint("MissingPermission")
private fun initManagerAndUpdateLastKnownLocation(context: Context) {
// Init the manager
locationManager = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
context.getSystemService(LocationManager::class.java)
} else {
context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
}
// Update the lastKnownLocation
if (lastKnownLocation == null && shouldUseGPS) {
lastKnownLocation = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER)
}
if (lastKnownLocation == null && shouldUseNetwork) {
lastKnownLocation = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER)
}
if (lastKnownLocation == null && shouldUsePassive) {
lastKnownLocation = locationManager.getLastKnownLocation(LocationManager.PASSIVE_PROVIDER)
}
}
@SuppressLint("MissingPermission")
private fun registerForLocationUpdates(provider: String) {
if (locationManager.isProviderEnabled(provider)) {
locationManager.requestLocationUpdates(provider, minTimeBetweenUpdates, minDistanceBetweenUpdates, listener)
} else {
//nothing
}
}
interface Listener {
fun onLocationFound(location: Location)
//nothing fun onProviderError(providerError: ProviderError)
}
interface BehaviorListener {
fun onProviderDisabled(provider: String)
fun onProviderEnabled(provider: String)
fun onStatusChanged(provider: String, status: Int, extras: Bundle)
}
}
| TaskProximityKotlin/app/src/main/java/com/example/taskproximity/LocationTracker.kt | 3061937971 |
package com.example.taskproximity
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.example.taskproximity.R
import com.example.taskproximity.databinding.ActivitySignUpBinding
import com.google.firebase.FirebaseApp
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.FirebaseUser
import com.google.firebase.firestore.FirebaseFirestore
class SignUp : AppCompatActivity() {
private lateinit var firebaseAuth: FirebaseAuth
private lateinit var binding: ActivitySignUpBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivitySignUpBinding.inflate(layoutInflater)
setContentView(binding.root)
firebaseAuth = FirebaseAuth.getInstance()
val db = FirebaseFirestore.getInstance()
val usersCollection = db.collection("users")
fun signup(email: String, password: String) {
firebaseAuth.createUserWithEmailAndPassword(email, password)
.addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
val user: FirebaseUser? = firebaseAuth.currentUser
Toast.makeText(this, "Signup successful!", Toast.LENGTH_SHORT).show()
// Proceed to the next activity or perform other actions
} else {
Toast.makeText(this, "Signup failed! Please try again.", Toast.LENGTH_SHORT).show()
}
}
}
binding.button.setOnClickListener {
val username = binding.username.text.toString()
val password = binding.password.text.toString()
if (username.isNotEmpty() && password.isNotEmpty()) {
val user = hashMapOf(
"email" to username,
"password" to password
)
usersCollection.add(user)
.addOnSuccessListener {
// User data added successfully
val intent = Intent(this, Login::class.java)
startActivity(intent)
}
.addOnFailureListener { e ->
// Error adding user data
Toast.makeText(this, "Error: ${e.message}", Toast.LENGTH_SHORT).show()
}
firebaseAuth.createUserWithEmailAndPassword(username, password)
.addOnCompleteListener {
if (it.isSuccessful) {
val intent = Intent(this, Login::class.java)
startActivity(intent)
} else {
Toast.makeText(this, it.exception.toString(), Toast.LENGTH_SHORT).show()
}
}
} else {
Toast.makeText(this, "Empty Fields are not allowed", Toast.LENGTH_SHORT).show()
}
}
//button2
binding.button2.setOnClickListener {
val username = binding.username.text.toString()
val password = binding.password.text.toString()
if (username.isNotEmpty() && password.isNotEmpty()) {
val user = hashMapOf(
"email" to username,
"password" to password
)
usersCollection.add(user)
.addOnSuccessListener {
// User data added successfully
val intent = Intent(this, Login::class.java)
startActivity(intent)
}
.addOnFailureListener { e ->
// Error adding user data
Toast.makeText(this, "Error: ${e.message}", Toast.LENGTH_SHORT).show()
}
firebaseAuth.createUserWithEmailAndPassword(username, password)
.addOnCompleteListener {
if (it.isSuccessful) {
val intent = Intent(this, Login::class.java)
startActivity(intent)
} else {
Toast.makeText(this, it.exception.toString(), Toast.LENGTH_SHORT).show()
}
}
} else {
Toast.makeText(this, "Empty Fields are not allowed", Toast.LENGTH_SHORT).show()
}
}
}
} | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/SignUp.kt | 2831234755 |
package com.example.taskproximity
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
class AdminHome : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_adminhome)
val button1 = findViewById<Button>(R.id.addTask)
val button2 = findViewById<Button>(R.id.editTask)
button1.setOnClickListener{
val intent = Intent(this, adminAddTask::class.java)
startActivity(intent)
}
button2.setOnClickListener{
val intent = Intent(this, editTask::class.java)
startActivity(intent)
}
}
} | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/AdminHome.kt | 2986808824 |
package com.example.taskproximity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.google.firebase.firestore.FirebaseFirestore
class TaskEditDescActivity : AppCompatActivity() {
private lateinit var taskId: String
private lateinit var descriptionEditText: EditText
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_task_edit_desc)
taskId = intent.getStringExtra("taskId") ?: ""
val description = intent.getStringExtra("description") ?: ""
descriptionEditText = findViewById(R.id.editTextDescription)
descriptionEditText.setText(description)
val confirmButton: Button = findViewById(R.id.buttonConfirm)
confirmButton.setOnClickListener {
val updatedDescription = descriptionEditText.text.toString()
val db = FirebaseFirestore.getInstance()
val taskRef = db.collection("tasks").document(taskId)
taskRef.update("description", updatedDescription)
.addOnSuccessListener {
Toast.makeText(this, "Description updated successfully", Toast.LENGTH_SHORT).show()
finish()
}
.addOnFailureListener { exception ->
Toast.makeText(this, "Error: ${exception.message}", Toast.LENGTH_SHORT).show()
}
}
}
} | TaskProximityKotlin/app/src/main/java/com/example/taskproximity/TaskEditDescActivity.kt | 4018217766 |
package com.example.taskproximity
import android.Manifest
import android.annotation.SuppressLint
import android.content.pm.PackageManager
import android.location.Location
import android.os.Bundle
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import kotlin.math.atan2
import kotlin.math.cos
import kotlin.math.sin
import kotlin.math.sqrt
class OGC : AppCompatActivity() {
private lateinit var latitudeTv: TextView
private lateinit var longitudeTv: TextView
private lateinit var startStopBtn: Button
lateinit var listViewAdapter: ArrayAdapter<String>
private var latLngStrings = ArrayList<String>()
private var tracker: LocationTracker = LocationTracker(
minTimeBetweenUpdates = 500L, // 0.5 second
minDistanceBetweenUpdates = 1F, // one meter
shouldUseGPS = true,
shouldUseNetwork = true,
shouldUsePassive = true
).also {
it.addListener(object : LocationTracker.Listener {
@SuppressLint("SetTextI18n")
override fun onLocationFound(location: Location) {
val latT = location.latitude.toString()
val lngT = location.longitude.toString()
val lat = location.latitude
val long = location.longitude
val tLat = 31.783089
val tLong = 35.804489
val distance = calDistance(tLat, tLong, lat, long)
if(distance<=200)
{
Toast.makeText(applicationContext, "You are $distance away from the task", Toast.LENGTH_SHORT).show()
listViewAdapter.add("$latT, $lngT")
}
runOnUiThread {
latitudeTv.text = latT
longitudeTv.text = lngT
}
}
})
}
private fun calDistance(latT: Double, longT: Double, lat: Double, long: Double): Double {
// Radius of the Earth in meters
val R = 6371000.0
// Convert coordinates from degrees to radians
val lat1Rad = Math.toRadians(latT)
val lng1Rad = Math.toRadians(longT)
val lat2Rad = Math.toRadians(lat)
val lng2Rad = Math.toRadians(long)
// Calculate differences
val dlat = lat2Rad - lat1Rad
val dlng = lng2Rad - lng1Rad
// Haversine formula
val a = sin(dlat / 2) * sin(dlat / 2) +
cos(lat1Rad) * cos(lat2Rad) * sin(dlng / 2) * sin(dlng / 2)
val c = 2 * atan2(sqrt(a), sqrt(1 - a))
val distance = R * c
return distance
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_ogc)
latitudeTv = findViewById(R.id.tv_lat)
longitudeTv = findViewById(R.id.tv_long)
startStopBtn = findViewById(R.id.btn_start_stop)
listViewAdapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, latLngStrings)
// list_view.adapter = listViewAdapter
startStopBtn.setOnClickListener {
startStop()
}
}
override fun onStart() {
super.onStart()
initTracker()
}
override fun onDestroy() {
super.onDestroy()
tracker.stopListening(clearListeners = true)
}
override fun onRequestPermissionsResult(
requestCode: Int,
permissions: Array<out String>,
grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
initTracker()
}
private fun initTracker() {
val hasFineLocation =
ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
val hasCoarseLocation =
ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
if (!hasFineLocation || !hasCoarseLocation) {
return ActivityCompat.requestPermissions(
this,
arrayOf(
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION
),
1337
)
}
}
@SuppressLint("MissingPermission")
private fun startStop() {
if (tracker.isListening) {
startStopBtn.text = "Start"
tracker.stopListening()
} else {
startStopBtn.text = "Stop"
tracker.startListening(context = baseContext)
}
}
}
| TaskProximityKotlin/app/src/main/java/com/example/taskproximity/OGC.kt | 2129217051 |
package com.example.taskproximity
import android.Manifest
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import java.lang.Math.atan2
import java.lang.Math.cos
import java.lang.Math.sin
import java.lang.Math.sqrt
class taskDetails : AppCompatActivity() {
private lateinit var descriptionTextView: TextView
private lateinit var latitudeTextView: TextView
private lateinit var longitudeTextView: TextView
private lateinit var statusTextView: TextView
private lateinit var taskIdTextView: TextView
lateinit var listViewAdapter: ArrayAdapter<String>
var latitude: Double = 0.0
var latitudeT: Double = 0.0
var longitude: Double = 0.0
var longitudeT: Double = 0.0
private val CHANNEL_ID = "TASK_PROXIMITY_CHANNEL"
private val locationUpdateReceiver: BroadcastReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
val latitude = intent.getDoubleExtra("latitude", 0.0)
val longitude = intent.getDoubleExtra("longitude", 0.0)
// Update the UI with the new location
latitudeTextView.text = "Latitude: $latitude"
longitudeTextView.text = "Longitude: $longitude"
//checkTaskProximity(latitude, longitude)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_task_details)
descriptionTextView = findViewById(R.id.descriptionTextView)
latitudeTextView = findViewById(R.id.latitudeTextView)
longitudeTextView = findViewById(R.id.longitudeTextView)
statusTextView = findViewById(R.id.statusTextView)
taskIdTextView = findViewById(R.id.taskIdTextView)
// Start the location tracker service
val serviceIntent = Intent(this, locationTrack::class.java)
startService(serviceIntent)
// Register the location update receiver
LocalBroadcastManager.getInstance(this)
.registerReceiver(locationUpdateReceiver, IntentFilter("location_updated"))
// Retrieve the task information from the intent extras
val description = intent.getStringExtra("description")
latitudeT = intent.getDoubleExtra("latitude", 0.0)
longitudeT = intent.getDoubleExtra("longitude", 0.0)
val status = intent.getStringExtra("status")
val taskId = intent.getStringExtra("taskId")
// Set the task information in the respective TextView elements
descriptionTextView.text = "Description: $description"
latitudeTextView.text = "Latitude: $latitudeT"
longitudeTextView.text = "longitude: $longitudeT"
statusTextView.text = "Status: $status"
taskIdTextView.text = "Task Id: $taskId"
// Create the notification channel
createNotificationChannel()
//push long and lat here
val openActivityButton = findViewById<Button>(R.id.openActivityButton)
openActivityButton.setOnClickListener {
val intent = Intent(this, OGC::class.java)
startActivity(intent)
}
}
override fun onDestroy() {
super.onDestroy()
// Stop the location tracker service
val serviceIntent = Intent(this, locationTrack::class.java)
stopService(serviceIntent)
// Unregister the location update receiver
LocalBroadcastManager.getInstance(this).unregisterReceiver(locationUpdateReceiver)
}
private fun createNotificationChannel() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val name = "Task Proximity Channel"
val descriptionText = "Channel for Task Proximity Notifications"
val importance = NotificationManager.IMPORTANCE_DEFAULT
val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
description = descriptionText
}
val notificationManager: NotificationManager =
getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(channel)
}
}
}
| TaskProximityKotlin/app/src/main/java/com/example/taskproximity/taskDetails.kt | 2737677899 |
package com.example.taskproximity
import android.content.ClipData
import android.content.ClipboardManager
import android.content.Context
import android.content.Intent
import android.media.MediaPlayer
import android.view.ViewGroup.LayoutParams
import android.widget.LinearLayout
import com.google.firebase.firestore.FirebaseFirestore
import android.Manifest
import android.annotation.SuppressLint
import android.content.pm.PackageManager
import android.location.Location
import android.os.Bundle
import android.util.Log
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import com.google.android.material.textfield.TextInputEditText
import kotlin.math.atan2
import kotlin.math.cos
import kotlin.math.sin
import kotlin.math.sqrt
class userHome : AppCompatActivity() {
val dataMap = mutableMapOf<String?, MutableSet<Pair<Double?, Double?>>>()
var NotifyDist = 200.0
private lateinit var tasksLayout: LinearLayout
@SuppressLint("SetTextI18n")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_user_home)
tasksLayout = findViewById(R.id.tasksLayout)
latitudeTv = findViewById(R.id.tv_lat)
longitudeTv = findViewById(R.id.tv_long)
startStopBtn = findViewById(R.id.btn_start_stop)
startStopBtn.setOnClickListener {
startStop()
}
// Retrieve data from Firestore and populate the LinearLayout with buttons for each document
val db = FirebaseFirestore.getInstance()
val collectionRef = db.collection("tasks")
val distBtn = findViewById<Button>(R.id.distanceConfitmBtn)
distBtn.setOnClickListener{
val Edit = findViewById<EditText>(R.id.editTextNumberDecimal)
val inputText = Edit.text.toString()
NotifyDist = inputText.toDouble()
}
collectionRef.get()
.addOnSuccessListener { documents ->
for (document in documents) {
val description = document.getString("description")
val latitude = document.getDouble("latitude")
val longitude = document.getDouble("longitude")
val status = document.getString("status")
val taskId = document.getString("taskId")
val coordinatePair = Pair(latitude, longitude)
val coordinateSet = dataMap.getOrDefault(taskId, mutableSetOf())
coordinateSet.add(coordinatePair)
dataMap[taskId] = coordinateSet
// Create a new button for each document and set the field values
val taskButton = Button(this)
taskButton.text = "Description: $description\n" +
"Latitude: $latitude\n" +
"Longitude: $longitude\n" +
"Status: $status\n" +
"Task ID: $taskId\n"
// Set button layout parameters
val layoutParams = LinearLayout.LayoutParams(
LayoutParams.MATCH_PARENT,
LayoutParams.WRAP_CONTENT
)
layoutParams.setMargins(0, 0, 0, 16) // Optional: Add some margin between each button
taskButton.layoutParams = layoutParams
// Add a click listener to the button takes you to details of task
taskButton.setOnClickListener { //for now it copies to clip board, where u can use the long lat in google maps
// Copy latitude and longitude to clipboard
val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
val clip = ClipData.newPlainText("Coordinates", "Latitude: $latitude\nLongitude: $longitude")
clipboard.setPrimaryClip(clip)
//
// // Start the TaskDetailsActivity and pass the description as an extra
// val intent = Intent(this, taskDetails::class.java)
// intent.putExtra("description", description)
// intent.putExtra("latitude", latitude)
// intent.putExtra("longitude", longitude)
// intent.putExtra("status", status)
// intent.putExtra("taskId", taskId)
// startActivity(intent)
//
// // Show a toast indicating that the latitude and longitude are copied to the clipboard
// Toast.makeText(this, "Latitude and Longitude copied to clipboard", Toast.LENGTH_SHORT).show()
}
// Add the new button to the tasksLayout LinearLayout
tasksLayout.addView(taskButton)
}
}
.addOnFailureListener { exception ->
// Handle any errors
Toast.makeText(this, "Error: ${exception.message}", Toast.LENGTH_SHORT).show()
}
}
private lateinit var latitudeTv: TextView
private lateinit var longitudeTv: TextView
private lateinit var startStopBtn: Button
private var tracker: LocationTracker = LocationTracker(
minTimeBetweenUpdates = 500L, // 0.5 second
minDistanceBetweenUpdates = 1F, // one meter
shouldUseGPS = true,
shouldUseNetwork = true,
shouldUsePassive = true
).also {
it.addListener(object : LocationTracker.Listener {
@SuppressLint("SetTextI18n", "SuspiciousIndentation")
override fun onLocationFound(location: Location) {
val latT = location.latitude.toString()
val lngT = location.longitude.toString()
val lat = location.latitude
val long = location.longitude
val tLat = 4.0
val tLong = 3.0
dataMap.entries.forEach { entry ->
val taskId: String? = entry.key
val coordinateSet: Set<Pair<Double?, Double?>>? = entry.value
if (taskId != null && coordinateSet != null) {
coordinateSet.forEach { coordinatePair ->
val latitude: Double? = coordinatePair.first
val longitude: Double? = coordinatePair.second
if (latitude != null && longitude != null) {
// Perform operations with the taskId, latitude, and longitude
// For example, you can log or process the values here
val distance = calDistance(latitude,longitude,lat,long)
if(distance<=NotifyDist)
{
runOnUiThread {
//when you make toast, take description and id of task, add finish button under start/stop
//when pressed -> changes status of task, and makes it done in db and in task in xml- Saleh
Toast.makeText(applicationContext, "You are $distance away from the task", Toast.LENGTH_SHORT).show()
// Play the sound file
val mediaPlayer = MediaPlayer.create(applicationContext, R.raw.my_sound) // Replace "your_sound_file" with the actual name of your sound file
mediaPlayer.start()
}
}
}
}
}
}
//commented because they affect the correct distance that is displayed
//val distance = calDistance(tLat, tLong, lat, long)
// if(distance<=NotifyDist)
// {
// Toast.makeText(applicationContext, "You are $distance away from the task", Toast.LENGTH_SHORT).show()
//
// // Play the sound file
// val mediaPlayer = MediaPlayer.create(applicationContext, R.raw.my_sound) // Replace "your_sound_file" with the actual name of your sound file
// mediaPlayer.start()
// }
runOnUiThread {
latitudeTv.text = "Latitude: $latT"
longitudeTv.text = "Longitude: $lngT"
}
}
})
}
private fun calDistance(latT: Double, longT: Double, lat: Double, long: Double): Double {
// Radius of the Earth in meters
val R = 6371000.0
// Convert coordinates from degrees to radians
val lat1Rad = Math.toRadians(latT)
val lng1Rad = Math.toRadians(longT)
val lat2Rad = Math.toRadians(lat)
val lng2Rad = Math.toRadians(long)
// Calculate differences
val dlat = lat2Rad - lat1Rad
val dlng = lng2Rad - lng1Rad
// Haversine formula
val a = sin(dlat / 2) * sin(dlat / 2) +
cos(lat1Rad) * cos(lat2Rad) * sin(dlng / 2) * sin(dlng / 2)
val c = 2 * atan2(sqrt(a), sqrt(1 - a))
val distance = R * c
return distance
}
override fun onStart() {
super.onStart()
initTracker()
}
override fun onDestroy() {
super.onDestroy()
tracker.stopListening(clearListeners = true)
}
override fun onRequestPermissionsResult(
requestCode: Int,
permissions: Array<out String>,
grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
initTracker()
}
private fun initTracker() {
val hasFineLocation =
ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
val hasCoarseLocation =
ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
if (!hasFineLocation || !hasCoarseLocation) {
return ActivityCompat.requestPermissions(
this,
arrayOf(
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION
),
1337
)
}
}
@SuppressLint("MissingPermission")
private fun startStop() {
if (tracker.isListening) {
startStopBtn.text = "Start"
tracker.stopListening()
} else {
startStopBtn.text = "Stop"
tracker.startListening(context = baseContext)
}
}
}
| TaskProximityKotlin/app/src/main/java/com/example/taskproximity/userHome.kt | 2700782541 |
package com.ubaya.anmp_week1
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.navigation.NavController
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.ui.NavigationUI
import androidx.navigation.ui.setupWithNavController
import com.ubaya.anmp_week1.databinding.ActivityMainBinding
import java.security.AccessController
class MainActivity : AppCompatActivity() {
private lateinit var navController:NavController
private lateinit var binding:ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
//setup binding di activity
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
navController = (supportFragmentManager.findFragmentById(R.id.navHost) as NavHostFragment).navController
NavigationUI.setupActionBarWithNavController(this,navController,binding.drawerLayout)
//setupActionBarWithNavController yg diatas. paramenter ke3 drawer klo ada
//menyuruh agar nav vontroler menghanlde navview(ygsembunyi)
NavigationUI.setupWithNavController(binding.navView,navController)
//handle navigation
binding.bottomNav.setupWithNavController(navController)
}
override fun onSupportNavigateUp(): Boolean {
//automaticly pindah ke back stack yang diatasnya
return NavigationUI.navigateUp(navController,binding.drawerLayout) || super.onSupportNavigateUp()
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/MainActivity.kt | 1979688132 |
package com.ubaya.anmp_week1
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ArrayAdapter
import com.google.android.material.bottomsheet.BottomSheetDialogFragment
import com.ubaya.anmp_week1.databinding.FragmentOptionBinding
class OptionFragment : BottomSheetDialogFragment() {
private val level = arrayOf("Easy","Medium","Hard")
private lateinit var binding:FragmentOptionBinding
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentOptionBinding.inflate(inflater,container,false)
// Inflate the layout for this fragment
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val adapter = ArrayAdapter<String>(requireContext(),
android.R.layout.simple_dropdown_item_1line,level
)
binding.txtLevel.setAdapter(adapter)
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/OptionFragment.kt | 3608266124 |
package com.ubaya.anmp_week1
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [HistoryFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class HistoryFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_history, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment HistoryFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
HistoryFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/HistoryFragment.kt | 1230530680 |
package com.ubaya.anmp_week1
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class LoginAtivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login_ativity)
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/LoginAtivity.kt | 3515892022 |
package com.ubaya.anmp_week1
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.Navigation
import com.ubaya.anmp_week1.databinding.FragmentMainBinding
import com.ubaya.anmp_week1.databinding.FragmentResultBinding
class ResultFragment : Fragment() {
private lateinit var binding:FragmentResultBinding
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
binding = FragmentResultBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if(arguments != null){
val score = ResultFragmentArgs.fromBundle(requireArguments()).resultScore
binding.txtScore.text = "Your Score is $score"
}
binding.btnBackMain.setOnClickListener{
val action = ResultFragmentDirections.actionBackMainFragment()
Navigation.findNavController(it).navigate(action)
}
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/ResultFragment.kt | 1790748864 |
package com.ubaya.anmp_week1
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ArrayAdapter
import androidx.navigation.Navigation
import com.ubaya.anmp_week1.databinding.FragmentMainBinding
import java.util.logging.Level
import kotlin.random.Random
class MainFragment : Fragment() {
private lateinit var binding: FragmentMainBinding
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
binding = FragmentMainBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
var num1 = Random.nextInt(1,1000)
var num2 = Random.nextInt(1,1000)
var answer = num1 + num2
binding.txtQuestion.text = "$num1 + $num2"
var score = 0
binding.btnSubmit.setOnClickListener{
if(binding.txtAnswer.text.toString() == answer.toString()){
score = score + 1
num1 = Random.nextInt(1,1000)
num2 = Random.nextInt(1,1000)
answer = num1 + num2
binding.txtQuestion.text = "$num1 + $num2"
binding.txtAnswer.text = null
}
else{
//val name = binding.txtName.text.toString()
val action = MainFragmentDirections.actionResultFragment(score)
//memintakan contorler untuk mencari controler yg ada di
//bernavigasi ke action yg dipilih
Navigation.findNavController(it).navigate(action)
}
}
binding.btnSetting.setOnClickListener{
val action = MainFragmentDirections.actionOptionFagment()
Navigation.findNavController(it).navigate(action)
}
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/MainFragment.kt | 760618645 |
package com.ubaya.anmp_week1
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class SignUpActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
//signup for user
//1.check existing account
//2.check password
//3.implement
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_sign_up)
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/SignUpActivity.kt | 357153827 |
package com.ubaya.anmp_week1
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.Navigation
import com.ubaya.anmp_week1.databinding.FragmentGameBinding
class GameFragment : Fragment() {
private lateinit var binding:FragmentGameBinding
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentGameBinding.inflate(inflater,container,false)
// Inflate the layout for this fragment
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if(arguments != null){
val name = GameFragmentArgs.fromBundle(requireArguments()).playerName
binding.txtTurn.text = "$name 's turn"
}
binding.btnBack.setOnClickListener{
val action = GameFragmentDirections.actionMainFragment()
Navigation.findNavController(it).navigate(action)
}
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/GameFragment.kt | 1995561012 |
package com.ubaya.anmp_week1
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [ProfileFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class ProfileFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_profile, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment ProfileFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
ProfileFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | test1/app/src/main/java/com/ubaya/anmp_week1/ProfileFragment.kt | 129123690 |
package com.ubaya.studentapp.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.ubaya.studentapp.model.Student
class DetailViewModel(application: Application): AndroidViewModel(application) {
private val listStudent = MutableLiveData<ArrayList<Student>>()
val studentLD = MutableLiveData<Student>()
val TAG = "volleyTag"
private var queue: RequestQueue? = null
fun fetch(idStudent:String?) {
queue = Volley.newRequestQueue(getApplication())
val url = "http://adv.jitusolution.com/student.php?id="+idStudent
val stringRequest = StringRequest(
Request.Method.GET, url,
{
val sType = object: TypeToken<Student>(){}.type
val result = Gson().fromJson<Student>(it, sType)
studentLD.value = result as Student
Log.d("showvoleyid", studentLD.value.toString())
},
{
Log.d("showvoley", it.toString())
})
stringRequest.tag = TAG
queue?.add(stringRequest)
}
}
| test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/viewmodel/DetailViewModel.kt | 2923771696 |
package com.ubaya.studentapp.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.ubaya.studentapp.model.Student
import com.android.volley.Request
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
class ListViewModel(application: Application): AndroidViewModel(application) {
val studentsLD = MutableLiveData<ArrayList<Student>>()
//buat liat loding ato gk
val loadingLD = MutableLiveData<Boolean>()
val studentLoadErrorLD = MutableLiveData<Boolean>()
val TAG = "volleyTag"
private var queue: RequestQueue?= null
fun refresh(){
//karna dummy jdi gk mungkin salah
//studentLoadErrorLD.value = false
//loadingLD.value = false
studentLoadErrorLD.value = false
loadingLD.value = true
queue = Volley.newRequestQueue(getApplication())
val url = "http://adv.jitusolution.com/student.php"
val stringRequest = StringRequest(
Request.Method.GET,
url,
{//callback jk voley succes
loadingLD.value =false
Log.d("show_volley",it)
val sType = object: TypeToken<List<Student>>(){}.type
//gson berusaha mengubah json sesuai dengan list student
val result = Gson().fromJson<List<Student>>(it,sType)
studentsLD.value = result as ArrayList<Student>
},
{
loadingLD.value =false
Log.e("show_volley",it.toString())
}
)
stringRequest.tag = TAG
queue?.add(stringRequest)
}
//klo viewmodel g dipake
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/viewmodel/ListViewModel.kt | 3536791165 |
package com.ubaya.studentapp.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.ubaya.studentapp.model.Song
import com.ubaya.studentapp.model.Student
class SongListViewModel(application: Application):AndroidViewModel(application) {
val songsLD = MutableLiveData<ArrayList<Song>>()
//buat liat loding ato gk
val loadingLD = MutableLiveData<Boolean>()
val songLoadErrorLD = MutableLiveData<Boolean>()
val TAG = "volleyTag"
private var queue: RequestQueue?= null
fun refresh(){
songLoadErrorLD.value = false
loadingLD.value = true
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.152.27/songs.json"
val stringRequest = StringRequest(
Request.Method.GET,
url,
{//callback jk voley succes
loadingLD.value =false
Log.d("show_volley",it)
val sType = object: TypeToken<List<Song>>(){}.type
//gson berusaha mengubah json sesuai dengan list student
val result = Gson().fromJson<List<Song>>(it,sType)
songsLD.value = result as ArrayList<Song>
},
{
loadingLD.value =false
Log.e("show_volley",it.toString())
}
)
stringRequest.tag = TAG
queue?.add(stringRequest)
}
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/viewmodel/SongListViewModel.kt | 2790330287 |
package com.ubaya.studentapp.util
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import android.view.View
import android.widget.ImageView
import android.widget.ProgressBar
import com.squareup.picasso.Callback
import com.squareup.picasso.Picasso
import com.ubaya.studentapp.R
fun createNotificationChannel(context: Context, importance:Int, showBadge:Boolean, name:String, description:String)
{
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
val channelId = "${context.packageName}-$name"
val channel = NotificationChannel(channelId, name, importance)
channel.description = description
channel.setShowBadge(showBadge)
val notificationManager = context.getSystemService(NotificationManager::class.java)
notificationManager.createNotificationChannel(channel)
}
}
fun ImageView.loadImage(url: String?, progressBar: ProgressBar) {
Picasso.get()
.load(url)
.resize(400, 400)
.centerCrop()
.error(R.drawable.ic_launcher_background)
.into(this, object: Callback {
override fun onSuccess() {
progressBar.visibility = View.GONE
}
override fun onError(e: Exception?) {
}
})
}
| test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/util/util.kt | 1022604207 |
package com.ubaya.studentapp.model
data class Album(
var name:String?,
var year:Int?
)
| test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/model/Album.kt | 3379252362 |
package com.ubaya.studentapp.model
import java.util.ArrayList
data class Song(
var id:String?,
var title:String?,
var artist:String?,
var genre:ArrayList<String>,
var album:Album,
var images:String?
)
| test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/model/Song.kt | 201414453 |
package com.ubaya.studentapp.model
import com.google.gson.annotations.SerializedName
data class Student(
var id:String?,
@SerializedName("student_name")
var name:String?,
@SerializedName("birth_of_date")
var dob:String?,
var phone:String?,
@SerializedName("photo_url")
var photoUrl:String?
) {
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/model/Student.kt | 2487976391 |
package com.ubaya.studentapp.view
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.navigation.Navigation
import androidx.recyclerview.widget.RecyclerView
import com.ubaya.studentapp.databinding.SongListItemBinding
import com.ubaya.studentapp.databinding.StudentListItemBinding
import com.ubaya.studentapp.model.Song
import com.ubaya.studentapp.model.Student
import com.ubaya.studentapp.util.loadImage
class SongListAdapter(val songList: ArrayList<Song>): RecyclerView.Adapter<SongListAdapter.SongViewHolder>() {
class SongViewHolder(var binding: SongListItemBinding):RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): SongViewHolder {
var binding = SongListItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return SongViewHolder(binding)
}
override fun onBindViewHolder(holder: SongViewHolder, position: Int) {
holder.binding.txtID.text = "ID: " + songList[position].id
holder.binding.txtTitle.text = "Title: " +songList[position].title
holder.binding.txtArtist.text = "Artist: " +songList[position].artist
holder.binding.txtAlbum.text = "Album Name: " +songList[position].album.name
holder.binding.txtYear.text = "Year: " +songList[position].album.year.toString()
var listGenre= "Genre: "
songList[position].genre?.forEach{
listGenre += "\n" + it
}
holder.binding.txtGenre.text = listGenre
var imageView = holder.binding.imageViewSong
var progressBar = holder.binding.progressBar
imageView.loadImage(songList[position].images, progressBar)
}
override fun getItemCount(): Int {
return songList.size
}
fun updateSongList(newSongList:ArrayList<Song>){
songList.clear()
songList.addAll(newSongList)
notifyDataSetChanged()
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/SongListAdapter.kt | 800154463 |
package com.ubaya.studentapp.view
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import com.ubaya.studentapp.R
import com.ubaya.studentapp.databinding.ActivityMainBinding
import com.ubaya.studentapp.util.createNotificationChannel
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.core.Observer
import io.reactivex.rxjava3.disposables.Disposable
import io.reactivex.rxjava3.schedulers.Schedulers
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
//program yg dijalankan saat construktor diciptakan
init{
instance = this
}
//bisa diakses tanpa menciptakan objecknya
//di companion gk bisa akses contect objek
companion object{
private var instance:MainActivity ?= null
fun showNotification(title:String, content:String, icon:Int) {
val channelId = "${instance?.packageName}-${instance?.getString(R.string.app_name)}"
val builder = NotificationCompat.Builder(instance!!.applicationContext,channelId)
.apply{
setSmallIcon(icon)
setContentTitle(title)
setContentText(content)
setStyle(NotificationCompat.BigTextStyle())
priority = NotificationCompat.PRIORITY_DEFAULT
setAutoCancel(true)
}
val notif = NotificationManagerCompat.from(instance!!.applicationContext)
notif.notify(1001,builder.build())
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
createNotificationChannel(this, NotificationManagerCompat.IMPORTANCE_DEFAULT, true, getString(R.string.app_name), "App channel")
// val observable = Observable.just("a stream of data","hellow","world")
// .observeOn(AndroidSchedulers.mainThread())
// .subscribe(observer)
// .subscribe(
// {Log.d("Messages", "data captured: ${it}")},
// {Log.d("Messages", "error: ${message.toString()}")},
// {Log.d("Messages", "Complete Subscribe")}
// )
//objek yang subscrivbe/listen observabe
// val observer = object: Observer<String> {
// //ngasi tau klo observer muali sbucribe
// override fun onSubscribe(d: Disposable) {
// Log.d("Messages", "Begin Subscribe")
// }
//
// //muncul klo ada data yg dimunculkan observer
// override fun onNext(t: String) {
// Log.d("Messages", "data captured: ${t.toString()}")
// }
// override fun onError(e: Throwable) {
// Log.d("Messages", "error: ${e.message.toString()}")
// }
//
// override fun onComplete() {
// Log.d("Messages", "Complete Subscribe")
// }
//
// }
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/MainActivity.kt | 2302697719 |
package com.ubaya.studentapp.view
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.ubaya.studentapp.R
class SonsListFragment : Fragment() {
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_sons_list, container, false)
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/SonsListFragment.kt | 3310270699 |
package com.ubaya.studentapp.view
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import com.ubaya.studentapp.R
import com.ubaya.studentapp.databinding.FragmentSongListBinding
import com.ubaya.studentapp.databinding.FragmentStudentListBinding
import com.ubaya.studentapp.viewmodel.ListViewModel
import com.ubaya.studentapp.viewmodel.SongListViewModel
class SongListFragment : Fragment() {
private lateinit var binding:FragmentSongListBinding
private lateinit var viewModel: SongListViewModel
private val songListAdapter = SongListAdapter(arrayListOf())
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentSongListBinding.inflate(inflater,container,false)
// Inflate the layout for this fragment
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(SongListViewModel::class.java)
viewModel.refresh()
binding.recView.layoutManager = LinearLayoutManager(context)
binding.recView.adapter = songListAdapter
observerViewModel()
binding.refreshLayout.setOnRefreshListener {
viewModel.refresh()
binding.recView.visibility = View.GONE
binding.txtError.visibility = View.GONE
binding.progressLoad.visibility = View.VISIBLE
binding.refreshLayout.isRefreshing = false
}
}
fun observerViewModel(){
viewModel.songsLD.observe(viewLifecycleOwner, Observer {
songListAdapter.updateSongList(it)
})
viewModel.songLoadErrorLD.observe(viewLifecycleOwner, Observer {
if(it == true){
binding.txtError.visibility = View.VISIBLE
}else{
binding.txtError.visibility = View.GONE
}
})
viewModel.loadingLD.observe(viewLifecycleOwner, Observer {
if(it == true){
binding.progressLoad.visibility = View.VISIBLE
binding.recView.visibility = View.GONE
}else{
binding.progressLoad.visibility = View.GONE
binding.recView.visibility = View.VISIBLE
}
})
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/SongListFragment.kt | 70810700 |
package com.ubaya.studentapp.view
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import com.ubaya.studentapp.R
import com.ubaya.studentapp.databinding.FragmentStudentListBinding
import com.ubaya.studentapp.viewmodel.ListViewModel
class StudentListFragment : Fragment() {
private lateinit var binding:FragmentStudentListBinding
private lateinit var viewModel: ListViewModel
private val studentListAdapter = StudentListAdapter(arrayListOf())
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentStudentListBinding.inflate(inflater,container,false)
// Inflate the layout for this fragment
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(ListViewModel::class.java)
viewModel.refresh()
binding.recView.layoutManager = LinearLayoutManager(context)
binding.recView.adapter = studentListAdapter
observerViewModel()
binding.refreshLayout.setOnRefreshListener {
viewModel.refresh()
binding.recView.visibility = View.GONE
binding.txtError.visibility = View.GONE
binding.progressLoad.visibility = View.VISIBLE
binding.refreshLayout.isRefreshing = false
}
}
fun observerViewModel(){
//it berisi arraylistofstudent yang teraktual
viewModel.studentsLD.observe(viewLifecycleOwner, Observer {
studentListAdapter.updateStudentList(it)
})
viewModel.studentLoadErrorLD.observe(viewLifecycleOwner, Observer {
if(it == true){
binding.txtError.visibility = View.VISIBLE
}else{
binding.txtError.visibility = View.GONE
}
})
viewModel.loadingLD.observe(viewLifecycleOwner, Observer {
if(it == true){
binding.progressLoad.visibility = View.VISIBLE
binding.recView.visibility = View.GONE
}else{
binding.progressLoad.visibility = View.GONE
binding.recView.visibility = View.VISIBLE
}
})
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/StudentListFragment.kt | 4268522785 |
package com.ubaya.studentapp.view
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.navigation.Navigation
import androidx.recyclerview.widget.RecyclerView
import com.ubaya.studentapp.databinding.StudentListItemBinding
import com.ubaya.studentapp.model.Student
class StudentListAdapter(val studentList:ArrayList<Student>): RecyclerView.Adapter<StudentListAdapter.StudentViewHolder>()
{
class StudentViewHolder(var binding:StudentListItemBinding):RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): StudentViewHolder {
var binding = StudentListItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
return StudentViewHolder(binding)
}
override fun getItemCount(): Int {
return studentList.size
}
override fun onBindViewHolder(holder: StudentViewHolder, position: Int) {
holder.binding.txtId.text = studentList[position].id
holder.binding.txtName.text = studentList[position].name
holder.binding.btnDetail.setOnClickListener{
val action = StudentListFragmentDirections.actionStudentDetailFragment()
Navigation.findNavController(it).navigate(action)
}
}
fun updateStudentList(newStudentList:ArrayList<Student>){
studentList.clear()
studentList.addAll(newStudentList)
notifyDataSetChanged()
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/StudentListAdapter.kt | 3065295544 |
package com.ubaya.studentapp.view
import android.os.Bundle
import android.util.Log
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.lifecycle.ViewModelProvider
import com.squareup.picasso.Callback
import com.squareup.picasso.Picasso
import com.ubaya.studentapp.R
import com.ubaya.studentapp.databinding.FragmentStudentDetailBinding
import com.ubaya.studentapp.model.Student
import com.ubaya.studentapp.viewmodel.DetailViewModel
import com.ubaya.studentapp.viewmodel.ListViewModel
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.core.Observer
import io.reactivex.rxjava3.schedulers.Schedulers
import java.util.concurrent.TimeUnit
class StudentDetailFragment : Fragment() {
private lateinit var binding:FragmentStudentDetailBinding
private lateinit var viewModel: DetailViewModel
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentStudentDetailBinding.inflate(inflater,container,false)
// Inflate the layout for this fragment
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(DetailViewModel::class.java)
var id = ""
if(arguments != null){
id = StudentDetailFragmentArgs.fromBundle(requireArguments()).studentId
}
viewModel.fetch(id)
binding.txtID.setText(id)
viewModel.studentLD.observe(viewLifecycleOwner, {
var student = it
binding.btnUpdate?.setOnClickListener {
Observable.timer(5, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe {
Log.d("Messages", "five seconds")
MainActivity.showNotification(student.name.toString(),
"created new notification ",
R.drawable.baseline_person_2_24)
}
}
binding.txtName.setText(it.name)
binding.txtBod.setText(it.dob)
binding.txtPhone.setText(it.phone)
val picasso = Picasso.Builder(requireContext())
picasso.listener { picasso, uri, exception ->
exception.printStackTrace()
}
picasso.build().load(it.photoUrl)
.into(binding.imageView, object: Callback {
override fun onSuccess() {
binding.progressBar2.visibility = View.INVISIBLE
binding.imageView.visibility = View.VISIBLE
}
override fun onError(e: Exception?) {
Log.e("picasso_error", e.toString())
}
})
})
}
} | test1/Works/W4App/app/src/main/java/com/ubaya/studentapp/view/StudentDetailFragment.kt | 1977123133 |
package com.ubaya.uts_160421038
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.ubaya.uts_160421038", appContext.packageName)
}
} | test1/Works/UTS/app/src/androidTest/java/com/ubaya/uts_160421038/ExampleInstrumentedTest.kt | 1895745257 |
package com.ubaya.uts_160421038
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | test1/Works/UTS/app/src/test/java/com/ubaya/uts_160421038/ExampleUnitTest.kt | 74663865 |
package com.ubaya.uts_160421038.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.ubaya.uts_160421038.model.Game
import com.ubaya.uts_160421038.model.Page
import org.json.JSONObject
class DetailViewModel(application: Application): AndroidViewModel(application) {
val listPage = MutableLiveData<ArrayList<Page>>()
val gameLD = MutableLiveData<Game>()
val TAG = "volleyTag"
private var queue: RequestQueue? = null
fun fetch(id:Int) {
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/gameWId.php?id="+id.toString()
val stringRequest = StringRequest(
Request.Method.GET, url,
{
Log.d("apiresult2", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "OK") {
val data = obj.getJSONArray("data")
val sType = object: TypeToken<Game>(){}.type
gameLD.value = Gson().fromJson(data[0].toString(), sType) as Game
Log.d("showvoley2", gameLD.value.toString())
detailNews(id)
}
},
{
Log.d("showvoley", it.toString())
})
stringRequest.tag = TAG
queue?.add(stringRequest)
}
fun detailNews(id:Int) {
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/detailNews.php?id="+id.toString()
val stringRequest = StringRequest(
Request.Method.GET, url,
{
Log.d("apiresult3", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "OK") {
val data = obj.getJSONArray("data")
val sType = object: TypeToken<List<Page>>(){}.type
listPage.value = Gson().fromJson(data.toString(), sType) as ArrayList<Page>?
Log.d("showvoley3", listPage.value.toString())
}
},
{
Log.d("showvoley", it.toString())
})
stringRequest.tag = TAG
queue?.add(stringRequest)
}
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/viewmodel/DetailViewModel.kt | 230627624 |
package com.ubaya.uts_160421038.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.ubaya.uts_160421038.model.Game
import org.json.JSONObject
class ListViewModel(application: Application): AndroidViewModel(application) {
val gameLD = MutableLiveData<ArrayList<Game>>()
val studentLoadErrorLD = MutableLiveData<Boolean>()
val loadingLD = MutableLiveData<Boolean>()
val TAG = "volleyTag"
private var queue: RequestQueue? = null
fun refresh() {
loadingLD.value = true
studentLoadErrorLD.value = false
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/game.php"
val stringRequest = StringRequest(
Request.Method.GET, url,
{
Log.d("apiresult", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "OK") {
val data = obj.getJSONArray("data")
val sType = object: TypeToken<List<Game>>(){}.type
gameLD.value = Gson().fromJson(data.toString(), sType) as ArrayList<Game>?
loadingLD.value = false
Log.d("showvoley", gameLD.value.toString())
}
},
{
Log.d("showvoley", it.toString())
studentLoadErrorLD.value = false
loadingLD.value = false
})
stringRequest.tag = TAG
queue?.add(stringRequest)
}
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/viewmodel/ListViewModel.kt | 788796248 |
package com.ubaya.uts_160421038.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.ubaya.uts_160421038.model.User
import org.json.JSONObject
class LoginViewModel(application: Application): AndroidViewModel(application) {
val userLD = MutableLiveData<User>()
val loginStatLD = MutableLiveData<Boolean>()
val passErrorLD = MutableLiveData<Boolean>()
val TAG = "volleyTag"
private var queue: RequestQueue? = null
fun fetch(username: String, password:String) {
passErrorLD.value = false
loginStatLD.value = false
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/login.php"
val stringRequest = object : StringRequest(
Request.Method.POST, url,
{
Log.d("apilogin", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "success") {
val data = obj.getJSONArray("data")
val sType = object : TypeToken<User>() {}.type
userLD.value = Gson().fromJson(data[0].toString(), sType) as User
Log.d("showprofile", userLD.value.toString())
loginStatLD.value = true
passErrorLD.value = false
Log.d("showlogin", it.toString())
}
else{
loginStatLD.value = false
passErrorLD.value = true
}
},
{
Log.d("showlogin", it.toString())
loginStatLD.value = false
passErrorLD.value = true
})
{
override fun getParams(): MutableMap<String, String> {
val params = HashMap<String, String>()
params["username"] = username
params["password"] = password
return params
}
}
stringRequest.tag = TAG
queue?.add(stringRequest)
}
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/viewmodel/LoginViewModel.kt | 2466996029 |
package com.ubaya.uts_160421038.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.ubaya.uts_160421038.model.User
import org.json.JSONObject
class ProfileViewModel(application: Application): AndroidViewModel(application) {
val userLD = MutableLiveData<User>()
val updatePassLD = MutableLiveData<Boolean>()
val updateDataLD = MutableLiveData<Boolean>()
val TAG = "volleyTag"
private var queue: RequestQueue? = null
fun fetch(username: String) {
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/userWId.php"
val stringRequest = object : StringRequest(
Request.Method.POST, url,
{
Log.d("apiprofile", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "OK") {
val data = obj.getJSONArray("data")
val sType = object : TypeToken<User>() {}.type
userLD.value = Gson().fromJson(data[0].toString(), sType) as User
Log.d("showprofile", userLD.value.toString())
}
},
{
Log.d("showprofile", it.toString())
})
{
override fun getParams(): MutableMap<String, String> {
val params = HashMap<String, String>()
params["username"] = username
return params
}
}
stringRequest.tag = TAG
queue?.add(stringRequest)
}
fun updateData(username:String, firstName:String, lastName:String ){
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/updateData.php"
val stringRequest = object : StringRequest(
Request.Method.POST, url,
{
Log.d("apichangeddata", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "success") {
updateDataLD.value = true
}
},
{
Log.d("showchangeddata", it.toString())
updateDataLD.value = false
})
{
override fun getParams(): MutableMap<String, String> {
val params = HashMap<String, String>()
params["username"] = username
params["first_name"] = firstName
params["last_name"] = lastName
return params
}
}
stringRequest.tag = TAG
queue?.add(stringRequest)
}
fun updatePassword(username: String, password:String){
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/updatePassword.php"
val stringRequest = object : StringRequest(
Request.Method.POST, url,
{
Log.d("apichangepassword", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "success") {
updatePassLD.value = true
}
},
{
Log.d("showpassword", it.toString())
updatePassLD.value = false
})
{
override fun getParams(): MutableMap<String, String> {
val params = HashMap<String, String>()
params["username"] = username
params["password"] = password
return params
}
}
stringRequest.tag = TAG
queue?.add(stringRequest)
}
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/viewmodel/ProfileViewModel.kt | 3017439936 |
package com.ubaya.uts_160421038.viewmodel
import android.app.Application
import android.util.Log
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.android.volley.Request
import com.android.volley.RequestQueue
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import com.ubaya.uts_160421038.model.User
import org.json.JSONObject
class RegisterViewModel(application: Application): AndroidViewModel(application) {
val userLD = MutableLiveData<User>()
val registerLD = MutableLiveData<Boolean>()
val TAG = "volleyTag"
private var queue: RequestQueue? = null
fun fetch(username: String, firstName:String, lastName:String,email:String, password:String) {
queue = Volley.newRequestQueue(getApplication())
val url = "http://192.168.73.27/hobby_uts/register.php"
val stringRequest = object : StringRequest(
Request.Method.POST, url,
{
Log.d("apiregister", it.toString())
val obj = JSONObject(it)
if (obj.getString("result") == "success") {
Log.d("showregister", it.toString())
registerLD.value = true
}
},
{
Log.d("showregister", it.toString())
registerLD.value = false
})
{
override fun getParams(): MutableMap<String, String> {
val params = HashMap<String, String>()
params["username"] = username
params["first_name"] = firstName
params["last_name"] = lastName
params["email"] = email
params["password"] = password
return params
}
}
stringRequest.tag = TAG
queue?.add(stringRequest)
}
override fun onCleared() {
super.onCleared()
queue?.cancelAll(TAG)
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/viewmodel/RegisterViewModel.kt | 3190483419 |
package com.ubaya.uts_160421038.model
data class User (
var username: String?,
var first_name: String?,
var last_name: String?,
var email: String?,
var password: String?
) | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/model/User.kt | 641049844 |
package com.ubaya.uts_160421038.model
data class Page(
var id:Int?,
var idGame:Int?,
var newsContent: String?,
)
| test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/model/Page.kt | 9005383 |
package com.ubaya.uts_160421038.model
data class Game (
var id: Int?,
var title: String?,
var author: String?,
var description: String?,
var images: String?,
var date:String?
)
| test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/model/Game.kt | 1299200678 |
package com.ubaya.uts_160421038.view
import android.content.Context
import android.content.SharedPreferences
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import androidx.navigation.NavController
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.ui.NavigationUI
import androidx.navigation.ui.setupWithNavController
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity() {
private lateinit var navController: NavController
private lateinit var binding: ActivityMainBinding
private var username:String = ""
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
getLoginInfo()
navController = (supportFragmentManager.findFragmentById(R.id.navHost) as NavHostFragment).navController
NavigationUI.setupActionBarWithNavController(this, navController, binding.drawerLayout)
NavigationUI.setupWithNavController(binding.navView, navController)
binding.bottomNav.setupWithNavController(navController)
}
override fun onSupportNavigateUp(): Boolean {
return NavigationUI.navigateUp(navController, binding.drawerLayout)
|| super.onSupportNavigateUp()
}
fun getLoginInfo(){
var loginInfo = "com.ubaya.uts_160421038"
var shared: SharedPreferences = getSharedPreferences(loginInfo,
Context.MODE_PRIVATE )
username = shared.getString("username","").toString()
}
override fun onBackPressed() {
if(username != "")
{
Toast.makeText(this, "Please Log Out", Toast.LENGTH_SHORT).show()
}
else{
super.onBackPressed()
}
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/MainActivity.kt | 2765106959 |
package com.ubaya.uts_160421038.view
import android.content.Context
import android.content.Intent
import android.content.SharedPreferences
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.Navigation
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.FragmentLoginBinding
import com.ubaya.uts_160421038.viewmodel.LoginViewModel
class LoginFragment : Fragment() {
private lateinit var binding: FragmentLoginBinding
private lateinit var viewModel: LoginViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
}
viewModel = ViewModelProvider(this).get(LoginViewModel::class.java)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentLoginBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.btnLogin.setOnClickListener {
var username = binding.txtUsername.text.toString()
var password = binding.txtPassword.text.toString()
if (username == "" || password == ""){
Toast.makeText(requireContext(), "Isi semua field", Toast.LENGTH_SHORT).show()
}
else{
viewModel.fetch(username, password)
}
}
viewModel.passErrorLD.observe(viewLifecycleOwner, Observer {
if (it == true){
Toast.makeText(requireContext(), "gagal login", Toast.LENGTH_SHORT).show()
}
})
viewModel.loginStatLD.observe(viewLifecycleOwner, Observer{
if(it == true) {
Toast.makeText(requireContext(), "sukses login", Toast.LENGTH_SHORT).show()
var loginInfo = "com.ubaya.uts_160421038"
var shared: SharedPreferences = requireContext().getSharedPreferences(loginInfo,
Context.MODE_PRIVATE )
var editor: SharedPreferences.Editor = shared.edit()
editor.putString("username", binding.txtUsername.text.toString())
editor.apply()
binding.txtUsername.setText("")
binding.txtPassword.setText("")
val intent = Intent(requireContext(), MainActivity::class.java)
startActivity(intent)
viewModel.loginStatLD.value = false
}
})
binding.btnRegister.setOnClickListener {
val action = LoginFragmentDirections.actionLoginFragmentToRegisterFragment()
Navigation.findNavController(it).navigate(action)
}
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/LoginFragment.kt | 2738285015 |
package com.ubaya.uts_160421038.view
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.navigation.NavController
import androidx.navigation.fragment.NavHostFragment
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.ActivityStartBinding
class StartActivity : AppCompatActivity() {
private lateinit var navController: NavController
private lateinit var binding: ActivityStartBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityStartBinding.inflate(layoutInflater)
setContentView(binding.root)
navController = (supportFragmentManager.findFragmentById(R.id.navHostStart) as NavHostFragment).navController
}
override fun onBackPressed() {
super.onBackPressed()
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/StartActivity.kt | 2713753137 |
package com.ubaya.uts_160421038.view
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.FragmentDetailBinding
import com.ubaya.uts_160421038.databinding.FragmentHistoryBinding
class HistoryFragment : Fragment() {
private lateinit var binding: FragmentHistoryBinding
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentHistoryBinding.inflate(inflater, container, false)
return binding.root
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/HistoryFragment.kt | 2536257352 |
package com.ubaya.uts_160421038.view
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.Navigation
import androidx.recyclerview.widget.RecyclerView
import com.squareup.picasso.Callback
import com.squareup.picasso.Picasso
import com.ubaya.uts_160421038.databinding.NewsListItemBinding
import com.ubaya.uts_160421038.model.Game
class NewsAdapter(val newsList:ArrayList<Game>):RecyclerView.Adapter<NewsAdapter.GameViewHolder>() {
class GameViewHolder(var binding: NewsListItemBinding):
RecyclerView.ViewHolder(binding.root)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GameViewHolder {
val binding = NewsListItemBinding.inflate(
LayoutInflater.from(parent.context), parent, false)
return GameViewHolder(binding)
}
override fun getItemCount(): Int {
return newsList.size
}
override fun onBindViewHolder(holder: GameViewHolder, position: Int) {
holder.binding.txtTitle.text = newsList[position].title
holder.binding.txtAuthor.text = "by " + newsList[position].author
holder.binding.txtDate.text = "(" + newsList[position].date +")"
holder.binding.txtDesc.text = newsList[position].description
holder.binding.btnRead.setOnClickListener {
val gameId = newsList[position].id
val action = HomeFragmentDirections.actionHomeFragmentToDetailFragment(gameId!!)
Navigation.findNavController(it).navigate(action)
}
val picasso = Picasso.Builder(holder.itemView.context)
picasso.listener { picasso, uri, exception ->
exception.printStackTrace()
}
picasso.build().load(newsList[position].images)
.into(holder.binding.imageView2, object: Callback {
override fun onSuccess() {
holder.binding.progressBar2.visibility = View.INVISIBLE
holder.binding.imageView2.visibility = View.VISIBLE
}
override fun onError(e: Exception?) {
Log.e("picasso_error", e.toString())
}
})
}
fun updateGameList(newGameList:ArrayList<Game>){
newsList.clear()
newsList.addAll(newGameList)
notifyDataSetChanged()
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/NewsAdapter.kt | 48642826 |
package com.ubaya.uts_160421038.view
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.FragmentHomeBinding
import com.ubaya.uts_160421038.viewmodel.ListViewModel
class HomeFragment : Fragment() {
private lateinit var viewModel:ListViewModel
private val beritaListAdapter = NewsAdapter(arrayListOf())
private lateinit var binding: FragmentHomeBinding
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
binding = FragmentHomeBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(ListViewModel::class.java)
viewModel.refresh()
binding.recView.layoutManager = LinearLayoutManager(context)
binding.recView.adapter = beritaListAdapter
observeViewModel()
binding.refreshLayout.setOnRefreshListener {
viewModel.refresh()
binding.recView.visibility = View.GONE
binding.txtError.visibility = View.GONE
binding.progressBar.visibility = View.VISIBLE
binding.refreshLayout.isRefreshing = false
}
}
fun observeViewModel() {
viewModel.gameLD.observe(viewLifecycleOwner, Observer {
beritaListAdapter.updateGameList(it)
})
viewModel.studentLoadErrorLD.observe(viewLifecycleOwner, Observer {
if(it == true) {
binding.txtError?.visibility = View.VISIBLE
} else {
binding.txtError?.visibility = View.GONE
}
})
viewModel.loadingLD.observe(viewLifecycleOwner, Observer {
if(it == true) {
binding.recView.visibility = View.GONE
binding.progressBar.visibility = View.VISIBLE
} else {
binding.recView.visibility = View.VISIBLE
binding.progressBar.visibility = View.GONE
}
})
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/HomeFragment.kt | 511668702 |
package com.ubaya.uts_160421038.view
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.Navigation
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.FragmentRegisterBinding
import com.ubaya.uts_160421038.viewmodel.RegisterViewModel
class RegisterFragment : Fragment() {
private lateinit var binding: FragmentRegisterBinding
private lateinit var viewModel: RegisterViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProvider(this).get(RegisterViewModel::class.java)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentRegisterBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
binding.btnRegister.setOnClickListener {
var username = binding.txtUsername.text.toString()
var firstName = binding.txtFirst.text.toString()
var lastName = binding.txtLast.text.toString()
var password = binding.txtPassword.text.toString()
var confirm = binding.txtConfirm.text.toString()
var email = binding.txtEmail.text.toString()
if ((password == confirm) &&
(username != "" && password != "" && confirm != "" && firstName != "" && lastName != "" && email != "")
) {
viewModel.fetch(username, firstName, lastName, email,password )
} else if (username == "" || password == "" || confirm == "" || firstName == "" || lastName == "" || email == "") {
Toast.makeText(requireContext(), "Fill all Field", Toast.LENGTH_SHORT).show()
} else {
Toast.makeText(requireContext(), "Wrong Password", Toast.LENGTH_SHORT).show()
}
}
binding.btnBack.setOnClickListener{
val action = RegisterFragmentDirections.actionRegisterFragmentToLoginFragment()
Navigation.findNavController(it).navigate(action)
}
viewModel.registerLD.observe(viewLifecycleOwner, Observer{
if(it == true) {
Toast.makeText(requireContext(), "Succesfully Registered", Toast.LENGTH_SHORT).show()
}
else{
Toast.makeText(requireContext(), "Failed to Register", Toast.LENGTH_SHORT).show()
}
})
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/RegisterFragment.kt | 1669547263 |
package com.ubaya.uts_160421038.view
import android.content.Context
import android.content.SharedPreferences
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.FragmentProfileBinding
import com.ubaya.uts_160421038.model.User
import com.ubaya.uts_160421038.viewmodel.ProfileViewModel
class ProfileFragment : Fragment() {
private lateinit var binding: FragmentProfileBinding
private lateinit var viewModel: ProfileViewModel
private var username:String = ""
private var user: User = User("","","","","")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProvider(this).get(ProfileViewModel::class.java)
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentProfileBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel.updateDataLD.value = false
var loginInfo = "com.ubaya.uts_160421038"
var shared: SharedPreferences = requireContext().getSharedPreferences(loginInfo,
Context.MODE_PRIVATE )
username = shared.getString("username","").toString()
viewModel.fetch(username)
binding.btnLogout.setOnClickListener {
var loginInfo = "com.ubaya.uts_160421038"
var shared: SharedPreferences =
requireContext().getSharedPreferences(loginInfo, Context.MODE_PRIVATE)
var editor: SharedPreferences.Editor = shared.edit()
editor.clear()
editor.apply()
requireActivity().finish()
}
fun UpdateUI(userLog: User){
binding.txtFirst.setText(userLog.first_name)
binding.txtLast.setText(userLog.last_name)
binding.txtInfo.setText(userLog.username+"("+userLog.email+")")
}
viewModel.userLD.observe(viewLifecycleOwner, Observer {
user = it
UpdateUI(it)
//Update Data
binding.btnUpdate.setOnClickListener {
val newFirstName = binding.txtFirst.text.toString()
val newLastName = binding.txtLast.text.toString()
viewModel.updateData(user.username!!, newFirstName, newLastName)
}
//Update Pass
binding.btnChange.setOnClickListener {
val oldPass = binding.txtOldPass.text.toString()
val newPass = binding.txtNewPass.text.toString()
val confPass = binding.txtConfPass.text.toString()
if (newPass == confPass && oldPass == user.password)
{
viewModel.updatePassword(user.username!!, newPass)
binding.txtOldPass.setText("")
binding.txtNewPass.setText("")
binding.txtConfPass.setText("")
Toast.makeText(requireContext(), "Password Updated Succesfully", Toast.LENGTH_SHORT).show()
}
else if (confPass == "" || newPass == "" ||oldPass == "")
{
Toast.makeText(requireContext(), "Please Fill Every Field ", Toast.LENGTH_SHORT)
.show()
}
else
{
Toast.makeText(requireContext(), "Field not Matched", Toast.LENGTH_SHORT)
.show()
}
}
})
viewModel.updateDataLD.observe(viewLifecycleOwner, Observer{
if(it == true) {
Toast.makeText(requireContext(), "Data Succesfully Updated", Toast.LENGTH_SHORT).show()
}
})
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/ProfileFragment.kt | 4242751616 |
package com.ubaya.uts_160421038.view
import android.os.Bundle
import android.util.Log
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import com.squareup.picasso.Callback
import com.squareup.picasso.Picasso
import com.ubaya.uts_160421038.R
import com.ubaya.uts_160421038.databinding.FragmentDetailBinding
import com.ubaya.uts_160421038.model.Page
import com.ubaya.uts_160421038.viewmodel.DetailViewModel
class DetailFragment : Fragment() {
private lateinit var binding: FragmentDetailBinding
private lateinit var viewModel: DetailViewModel
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = FragmentDetailBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(DetailViewModel::class.java)
var id = 0
if(arguments != null){
id = DetailFragmentArgs.fromBundle(requireArguments()).idGame
}
binding.btnPrev.visibility = View.GONE
viewModel.fetch(id)
viewModel.gameLD.observe(viewLifecycleOwner, Observer {
binding.txtTitle2.setText(it.title)
binding.txtAuthor2.setText("by " + it.author)
binding.txtDate2.setText(" (" + it.date+")")
binding.txtDesc2.setText(it.description)
val picasso = Picasso.Builder(requireContext())
picasso.listener { picasso, uri, exception ->
exception.printStackTrace()
}
picasso.build().load(it.images)
.into(binding.imageView4, object: Callback {
override fun onSuccess() {
binding.progressBar4.visibility = View.INVISIBLE
binding.imageView4.visibility = View.VISIBLE
}
override fun onError(e: Exception?) {
Log.e("picasso_error", e.toString())
}
})
})
var currPagee = 1
fun each(it:List<Page>, idx:Int){
it.forEach {
if (it.id == idx){
currPagee = idx
binding.txtContent.setText(it.newsContent)
}
}
}
viewModel.listPage.observe(viewLifecycleOwner, Observer{
var page = it
each(it, 1)
binding.btnNext.setOnClickListener {
if (currPagee == 1){
each(page,currPagee+1)
binding.btnPrev.visibility = View.VISIBLE
binding.btnNext.visibility = View.VISIBLE
}
else if (currPagee == 2){
each(page,currPagee+1)
binding.btnNext.visibility = View.GONE
binding.btnPrev.visibility = View.VISIBLE
}
}
binding.btnPrev.setOnClickListener {
if (currPagee == 3) {
each(page, currPagee-1)
binding.btnNext.visibility = View.VISIBLE
binding.btnPrev.visibility = View.VISIBLE
}
else if (currPagee == 2) {
each(page, currPagee-1)
binding.btnPrev.visibility = View.GONE
binding.btnNext.visibility = View.VISIBLE
}
}
})
}
} | test1/Works/UTS/app/src/main/java/com/ubaya/uts_160421038/view/DetailFragment.kt | 827248316 |
package com.ubaya.advweek4160421038
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.ubaya.advweek4160421038", appContext.packageName)
}
} | test1/Works/W4/app/src/androidTest/java/com/ubaya/advweek4160421038/ExampleInstrumentedTest.kt | 259575117 |
package com.ubaya.advweek4160421038
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | test1/Works/W4/app/src/test/java/com/ubaya/advweek4160421038/ExampleUnitTest.kt | 1625729702 |
package io.android.startrack
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("io.android.startrack.test", appContext.packageName)
}
}
| startrack-android/startrack/src/androidTest/java/io/android/startrack/ExampleInstrumentedTest.kt | 3511616927 |
package io.android.startrack
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
}
| startrack-android/startrack/src/test/java/io/android/startrack/ExampleUnitTest.kt | 928263710 |
package io.android.startrack
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("io.android.startrack", appContext.packageName)
}
}
| startrack-android/sample/src/androidTest/java/io/android/startrack/ExampleInstrumentedTest.kt | 2579039295 |
package io.android.startrack
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
}
| startrack-android/sample/src/test/java/io/android/startrack/ExampleUnitTest.kt | 928263710 |
package io.android.startrack
import android.content.Context
import io.android.startrack.entities.Error
import io.android.startrack.entities.Event
interface StarTrack {
/**
* Initialize the library
*/
fun init(context: Context, config: StarTrackConfig)
/**
* Send event data
*
* @param event a custom event list
* @see Event
*/
fun reportEvent(event: Event)
/**
* Send error data
*
* @param error a custom error
* @see Error
*/
fun reportError(error: Error)
}
| startrack-android/sample/src/main/java/io/android/startrack/StarTrack.kt | 2585539054 |
package io.android.startrack
class StarTrackConfig(
val baseUrl: String,
)
| startrack-android/sample/src/main/java/io/android/startrack/StarTrackConfig.kt | 1926206377 |
package io.android.startrack.tracker
import io.android.startrack.entities.Error
import io.android.startrack.entities.Event
/**
* @author ext.nzmitrovich
*/
internal interface Tracker {
fun reportEvent(event: Event)
fun reportError(error: Error)
}
| startrack-android/sample/src/main/java/io/android/startrack/tracker/Tracker.kt | 1271432390 |
package io.android.startrack.tracker
import io.android.startrack.entities.Error
import io.android.startrack.entities.Event
import io.android.startrack.tracker.task.ReportEventTaskFactory
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledExecutorService
import java.util.concurrent.TimeUnit
internal class ScheduledTracker(
private val executorService: ScheduledExecutorService,
private val taskFactory: ReportEventTaskFactory,
) : Tracker {
override fun reportEvent(event: Event) {
executorService.schedule(taskFactory.create(event), 1, TimeUnit.SECONDS)
}
override fun reportError(error: Error) {
executorService.schedule(taskFactory.create(error), 1, TimeUnit.SECONDS)
}
}
| startrack-android/sample/src/main/java/io/android/startrack/tracker/ScheduledTracker.kt | 1754791056 |
package io.android.startrack.tracker.task
import android.util.JsonWriter
import io.android.startrack.StarTrackConfig
import io.android.startrack.entities.Event
import okhttp3.HttpUrl
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody
import okhttp3.RequestBody.Companion.toRequestBody
internal class ReportEventTask(
private val httpClient: OkHttpClient,
private val configuration: StarTrackConfig,
private val event: Event,
) : Runnable {
override fun run() {
val url = HttpUrl.Builder()
.scheme("https")
.host(configuration.baseUrl)
.build()
// val request = Request.Builder()
// .url(url)
// .post()
// .build()
//
// httpClient.newCall(request)
}
private companion object {
val MEDIA_TYPE = "application/json; charset=UTF-8".toMediaType()
}
}
| startrack-android/sample/src/main/java/io/android/startrack/tracker/task/ReportEventTask.kt | 1001660656 |
package io.android.startrack.tracker.task
import io.android.startrack.StarTrackConfig
import io.android.startrack.entities.Error
import io.android.startrack.entities.Event
import okhttp3.OkHttpClient
/**
* @author ext.nzmitrovich
*/
internal class ReportEventTaskFactory(
private val httpClient: OkHttpClient,
private val configuration: StarTrackConfig,
) {
fun create(event: Event): ReportEventTask {
return ReportEventTask(httpClient, configuration, event)
}
fun create(error: Error): ReportEventTask {
TODO()
}
}
| startrack-android/sample/src/main/java/io/android/startrack/tracker/task/ReportEventTaskFactory.kt | 4250364625 |
package io.android.startrack.entities
class Error(val error: Throwable)
| startrack-android/sample/src/main/java/io/android/startrack/entities/Error.kt | 3468769533 |
package io.android.startrack.entities
class Property<T>(
val name: String,
val value: T,
)
| startrack-android/sample/src/main/java/io/android/startrack/entities/Property.kt | 287656424 |
package io.android.startrack.entities
class Event(
val name: String,
val properties: Set<Property<*>>,
)
| startrack-android/sample/src/main/java/io/android/startrack/entities/Event.kt | 1383994702 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.