OpenEUICC/app/src/main/java/im/angry/openeuicc/service/OpenEuiccService.kt

182 lines
6.6 KiB
Kotlin

package im.angry.openeuicc.service
import android.service.euicc.*
import android.telephony.euicc.DownloadableSubscription
import android.telephony.euicc.EuiccInfo
import com.truphone.lpa.LocalProfileInfo
import com.truphone.lpad.progress.Progress
import im.angry.openeuicc.OpenEuiccApplication
import im.angry.openeuicc.core.EuiccChannel
import im.angry.openeuicc.util.*
class OpenEuiccService : EuiccService() {
private val openEuiccApplication
get() = application as OpenEuiccApplication
private fun findChannel(slotId: Int): EuiccChannel? =
openEuiccApplication.euiccChannelManager
.findEuiccChannelBySlotBlocking(slotId)
override fun onGetEid(slotId: Int): String? =
findChannel(slotId)?.lpa?.eid
// When two eSIM cards are present on one device, the Android settings UI
// gets confused and sets the incorrect slotId for profiles from one of
// the cards. This function helps Detect this case and abort early.
private fun EuiccChannel.profileExists(iccid: String?) =
lpa.profiles.any { it.iccid == iccid }
override fun onGetOtaStatus(slotId: Int): Int {
// Not implemented
return 5 // EUICC_OTA_STATUS_UNAVAILABLE
}
override fun onStartOtaIfNecessary(
slotId: Int,
statusChangedCallback: OtaStatusChangedCallback?
) {
// Not implemented
}
override fun onGetDownloadableSubscriptionMetadata(
slotId: Int,
subscription: DownloadableSubscription?,
forceDeactivateSim: Boolean
): GetDownloadableSubscriptionMetadataResult {
// Stub: return as-is and do not fetch anything
// This is incompatible with carrier eSIM apps; should we make it compatible?
return GetDownloadableSubscriptionMetadataResult(RESULT_OK, subscription)
}
override fun onGetDefaultDownloadableSubscriptionList(
slotId: Int,
forceDeactivateSim: Boolean
): GetDefaultDownloadableSubscriptionListResult {
// Stub: we do not implement this (as this would require phoning in a central GSMA server)
return GetDefaultDownloadableSubscriptionListResult(RESULT_OK, arrayOf())
}
override fun onGetEuiccProfileInfoList(slotId: Int): GetEuiccProfileInfoListResult? {
val channel = findChannel(slotId) ?: return null
val profiles = channel.lpa.profiles.operational.map {
EuiccProfileInfo.Builder(it.iccid).apply {
setProfileName(it.name)
setNickname(it.displayName)
setServiceProviderName(it.providerName)
setState(
when (it.state) {
LocalProfileInfo.State.Enabled -> EuiccProfileInfo.PROFILE_STATE_ENABLED
LocalProfileInfo.State.Disabled -> EuiccProfileInfo.PROFILE_STATE_DISABLED
}
)
setProfileClass(
when (it.profileClass) {
LocalProfileInfo.Clazz.Testing -> EuiccProfileInfo.PROFILE_CLASS_TESTING
LocalProfileInfo.Clazz.Provisioning -> EuiccProfileInfo.PROFILE_CLASS_PROVISIONING
LocalProfileInfo.Clazz.Operational -> EuiccProfileInfo.PROFILE_CLASS_OPERATIONAL
}
)
}.build()
}
return GetEuiccProfileInfoListResult(RESULT_OK, profiles.toTypedArray(), channel.removable)
}
override fun onGetEuiccInfo(slotId: Int): EuiccInfo {
return EuiccInfo("Unknown") // TODO: Can we actually implement this?
}
override fun onDeleteSubscription(slotId: Int, iccid: String): Int {
try {
val channel = findChannel(slotId) ?: return RESULT_FIRST_USER
if (!channel.profileExists(iccid)) {
return RESULT_FIRST_USER
}
val profile = channel.lpa.profiles.find {
it.iccid == iccid
} ?: return RESULT_FIRST_USER
if (profile.state == LocalProfileInfo.State.Enabled) {
// Must disable the profile first
return RESULT_FIRST_USER
}
return if (channel.lpa.deleteProfile(iccid, Progress()) == "0") {
RESULT_OK
} else {
RESULT_FIRST_USER
}
} catch (e: Exception) {
return RESULT_FIRST_USER
}
}
// TODO: on some devices we need to update the mapping (and potentially disable a pSIM)
// for eSIM to be usable, in which case we will have to respect forceDeactivateSim.
// This is the same for our custom LUI. Both have to take this into consideration.
@Deprecated("Deprecated in Java")
override fun onSwitchToSubscription(
slotId: Int,
iccid: String?,
forceDeactivateSim: Boolean
): Int {
try {
val channel = findChannel(slotId) ?: return RESULT_FIRST_USER
if (!channel.profileExists(iccid)) {
return RESULT_FIRST_USER
}
if (iccid == null) {
// Disable active profile
val activeProfile = channel.lpa.profiles.find {
it.state == LocalProfileInfo.State.Enabled
} ?: return RESULT_OK
return if (channel.lpa.disableProfile(activeProfile.iccid, Progress()) == "0") {
RESULT_OK
} else {
RESULT_FIRST_USER
}
} else {
return if (channel.lpa.enableProfile(iccid, Progress()) == "0") {
RESULT_OK
} else {
RESULT_FIRST_USER
}
}
} catch (e: Exception) {
return RESULT_FIRST_USER
} finally {
openEuiccApplication.euiccChannelManager.invalidate()
}
}
override fun onUpdateSubscriptionNickname(slotId: Int, iccid: String, nickname: String?): Int {
val channel = findChannel(slotId) ?: return RESULT_FIRST_USER
if (!channel.profileExists(iccid)) {
return RESULT_FIRST_USER
}
val success = channel.lpa
.setNickname(iccid, nickname)
openEuiccApplication.subscriptionManager.tryRefreshCachedEuiccInfo(channel.cardId)
return if (success) {
RESULT_OK
} else {
RESULT_FIRST_USER
}
}
@Deprecated("Deprecated in Java")
override fun onEraseSubscriptions(slotId: Int): Int {
// No-op
return RESULT_FIRST_USER
}
override fun onRetainSubscriptionsForFactoryReset(slotId: Int): Int {
// No-op -- we do not care
return RESULT_FIRST_USER
}
}