182 lines
6.6 KiB
Kotlin
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
|
|
}
|
|
} |