frida-rcs-hack/scripts/spoof_gms.js

const mcc = "{{mcc}}"
const mnc = "{{mnc}}"
const simOperator = "{{simOperator}}"
const networkOperator = "{{networkOperator}}"
const simSerialNumber = "{{simSerialNumber}}"
const iccId = "{{iccId}}"
const number = "{{number}}"
const imei = "{{imei}}"
const imsi = "{{imsi}}"
const countryIso = "{{countryIso}}"
const subId = "{{subId}}"
function trace(tag) {
    Log.e(
        (tag || "") +
            Java.use("android.util.Log").getStackTraceString(
                Java.use("java.lang.Throwable").$new()
            )
    )
}

class Log {
    static TAG = "[GMS]"
    static format(...msg) {
        let m = []
        for (let i = 0; i < msg.length; i++) {
            if (typeof msg[i] === "object") {
                m.push(msg[i] + "")
            } else {
                m.push(msg[i])
            }
        }
        m = m.join(" ")
        return m
    }
    static i(...msg) {
        console.log(`\x1b[30m${this.TAG} ${this.format(...msg)}\x1b[0m`)
    }
    static w(...msg) {
        console.log(`\x1b[33m${this.TAG} ${this.format(...msg)}\x1b[0m`)
    }
    static e(...msg) {
        console.log(`\x1b[31m${this.TAG} ${this.format(...msg)}\x1b[0m`)
    }
    static s(...msg) {
        console.log(`\x1b[32m${this.TAG} ${this.format(...msg)}\x1b[0m`)
    }
}

Java.perform(function () {
    const GsonClass = Java.openClassFile(
        "/data/data/com.google.android.gms/gson.dex"
    )
    GsonClass.load()
    Log.s("gson class loaded")

    const SmsManager = Java.use("android.telephony.SmsManager")
    SmsManager.getSmsManagerForSubscriptionId.overload("int").implementation =
        function (i) {
            const _smsManager = this.getSmsManagerForSubscriptionId(i)
            Log.i(`SmsManager.getSmsManagerForSubscriptionId: ${i}`)
            return _smsManager
        }

    SmsManager.getDefault.overload().implementation = function () {
        const _smsManager = this.getDefault(i)
        Log.i(`SmsManager.getDefault`)
        return _smsManager
    }

    SmsManager.getDefaultSmsSubscriptionId.overload().implementation =
        function () {
            const _subId = this.getDefaultSmsSubscriptionId()
            Log.i(
                `spoof SmsManager.getDefaultSmsSubscriptionId: ${_subId} -> ${subId}`
            )
            return parseInt(subId)
        }

    SmsManager.getSubscriptionId.overload().implementation = function () {
        const _subId = this.getSubscriptionId()
        Log.i(`SmsManager.getSubscriptionId: ${_subId} -> ${subId}`)
        return parseInt(subId)
    }
    SmsManager.getCarrierConfigValues.overload().implementation = function () {
        const _config = this.getCarrierConfigValues()
        Log.i(`SmsManager.getCarrierConfigValues: ${_config}`)
        return _config
    }

    const CarrierConfigManager = Java.use(
        "android.telephony.CarrierConfigManager"
    )
    CarrierConfigManager.getConfigForSubId.overload("int").implementation =
        function (i) {
            const _config = this.getConfigForSubId(i)
            Log.i(`CarrierConfigManager.getConfigForSubId: ${i}`)
            return _config
        }

    const SubscriptionManager = Java.use(
        "android.telephony.SubscriptionManager"
    )
    SubscriptionManager.getActiveSubscriptionInfoCount.overload().implementation =
        function () {
            const _count = this.getActiveSubscriptionInfoCount()
            Log.i(
                `SubscriptionManager.getActiveSubscriptionInfoCount: ${_count}`
            )
            return _count
        }
    SubscriptionManager.getDefaultSubscriptionId.overload().implementation =
        function () {
            const _subId = this.getDefaultSubscriptionId()
            Log.i(
                `spoof SubscriptionManager.getDefaultSubscriptionId: ${_subId} -> ${subId}`
            )
            return parseInt(subId)
        }
    SubscriptionManager.getDefaultSmsSubscriptionId.overload().implementation =
        function () {
            const _subId = this.getDefaultSmsSubscriptionId()
            Log.i(
                `spoof SubscriptionManager.getDefaultSmsSubscriptionId: ${_subId} -> ${subId}`
            )
            return parseInt(subId)
        }
    SubscriptionManager.getDefaultVoiceSubscriptionId.overload().implementation =
        function () {
            const _subId = this.getDefaultVoiceSubscriptionId()
            Log.i(
                `spoof SubscriptionManager.getDefaultVoiceSubscriptionId: ${_subId} -> ${subId}`
            )
            return parseInt(subId)
        }
    SubscriptionManager.getActiveDataSubscriptionId.overload().implementation =
        function () {
            const _subId = this.getActiveDataSubscriptionId()
            Log.i(
                `spoof SubscriptionManager.getActiveDataSubscriptionId: ${_subId} -> ${subId}`
            )
            return parseInt(subId)
        }
    SubscriptionManager.getSlotIndex.overload("int").implementation = function (
        i
    ) {
        const _slotIndex = this.getSlotIndex(i)
        Log.i(`spoof SubscriptionManager.getSlotIndex: ${_slotIndex} -> 0`)
        return 0
    }
    SubscriptionManager.isUsableSubscriptionId.overload("int").implementation =
        function (i) {
            const _isUsable = this.isUsableSubscriptionId(i)
            Log.i(`SubscriptionManager.isUsableSubscriptionId: ${_isUsable}`)
            return _isUsable
        }
    SubscriptionManager.isValidSubscriptionId.overload("int").implementation =
        function (i) {
            const _isValid = this.isValidSubscriptionId(i)
            Log.i(
                `spoof SubscriptionManager.isValidSubscriptionId(${i}): ${_isValid} -> true`
            )
            return true
        }
    SubscriptionManager.getPhoneNumber.overload("int").implementation =
        function (i) {
            Log.i(
                `spoof SubscriptionManager.getPhoneNumber(${i}): -> ${number}`
            )
            return number
        }
    SubscriptionManager.getPhoneNumber.overload("int", "int").implementation =
        function (i, i2) {
            Log.i(
                `spoof SubscriptionManager.getPhoneNumber(${i},${i2}): -> ${number}`
            )
            return number
        }
    SubscriptionManager.getActiveSubscriptionInfoList.overload().implementation =
        function () {
            const _list = this.getActiveSubscriptionInfoList()
            Log.i(
                `SubscriptionManager.getActiveSubscriptionInfoList ${_list.size()}`
            )
            return _list
        }
    SubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex.overload(
        "int"
    ).implementation = function (i) {
        const _info = this.getActiveSubscriptionInfoForSimSlotIndex(i)
        Log.i(
            `SubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(${i}): ${
                _info ? "ok" : "null"
            }`
        )
        return _info
    }
    SubscriptionManager.getActiveSubscriptionIdList.overload().implementation =
        function () {
            const _list = this.getActiveSubscriptionIdList()
            Log.i(
                `spoof SubscriptionManager.getActiveSubscriptionIdList ${_list} -> ${subId}`
            )
            return [parseInt(subId)]
        }
    SubscriptionManager.getActiveSubscriptionInfo.overload(
        "int"
    ).implementation = function (i) {
        const _info = this.getActiveSubscriptionInfo(i)

        const simCount = this.getActiveSubscriptionInfoCountMax()

        let subInfo = null
        try {
            for (let i = 0; i < simCount; i++) {
                subInfo = this.getActiveSubscriptionInfoForSimSlotIndex(i)
                if (subInfo) {
                    break
                }
            }
            Log.i(`spoof SubscriptionManager.getActiveSubscriptionInfo(${i})`)
        } catch (error) {
            console.error(
                `spoof error SubscriptionManager.getActiveSubscriptionInfo(${i})`
            )
            error.printStackTrace()
        }
        return subInfo
    }
    SubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex.overload(
        "int"
    ).implementation = function (s) {
        const _info = this.getActiveSubscriptionInfoForSimSlotIndex(i)
        Log.i(
            `SubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex: ${_info}`
        )
        return _info
    }
    SubscriptionManager.isActiveSubscriptionId.overload("int").implementation =
        function (i) {
            const _isActive = this.isActiveSubscriptionId(i)
            Log.i(
                `spoof SubscriptionManager.isActiveSubscriptionId(${i}): ${_isActive} -> true`
            )
            return true
        }

    const SubscriptionInfo = Java.use("android.telephony.SubscriptionInfo")
    SubscriptionInfo.getMcc.overload().implementation = function () {
        const _mcc = this.getMcc()
        Log.i(`spoof SubscriptionInfo.getMcc: ${_mcc} -> ${mcc}`)
        return parseInt(mcc)
    }

    SubscriptionInfo.getMnc.overload().implementation = function () {
        const _mnc = this.getMnc()
        Log.i(`spoof SubscriptionInfo.getMnc: ${_mnc} -> ${mnc}`)
        return parseInt(mnc)
    }

    SubscriptionInfo.getMccString.overload().implementation = function () {
        const _mccString = this.getMccString()
        Log.i(`spoof SubscriptionInfo.getMccString: ${_mccString} -> ${mcc}`)
        return mcc
    }

    SubscriptionInfo.getMncString.overload().implementation = function () {
        const _mncString = this.getMncString()
        Log.i(`spoof SubscriptionInfo.getMncString: ${_mncString} -> ${mnc}`)
        return mnc
    }

    SubscriptionInfo.getNumber.overload().implementation = function () {
        const _number = this.getNumber()
        Log.i(`spoof SubscriptionInfo.getNumber: ${_number} -> ${number}`)
        return number
    }

    SubscriptionInfo.getIccId.overload().implementation = function () {
        const _iccId = this.getIccId()
        Log.i(`spoof SubscriptionInfo.getIccId: ${_iccId} -> ${iccId}`)
        return iccId
    }

    SubscriptionInfo.getCountryIso.overload().implementation = function () {
        const _countryIso = this.getCountryIso()
        Log.i(
            `spoof SubscriptionInfo.getCountryIso: ${_countryIso} -> ${countryIso}`
        )
        return countryIso
    }

    SubscriptionInfo.getSubscriptionId.overload().implementation = function () {
        const _subId = this.getSubscriptionId()
        if (!subId) {
            Log.i(_subId)
            return _subId
        }
        Log.i(`spoof SubscriptionInfo.getSubscriptionId: ${_subId} -> ${subId}`)
        return parseInt(subId)
    }

    const TelephonyManager = Java.use("android.telephony.TelephonyManager")
    TelephonyManager.createForSubscriptionId.overload("int").implementation =
        function (i) {
            Log.i(`spoof TelephonyManager.createForSubscriptionId: ${i}`)
            return this
        }

    TelephonyManager.getLine1Number.overload().implementation = function () {
        const _number = this.getLine1Number()
        Log.i(`spoof TelephonyManager.getLine1Number: ${_number} -> ${number}`)
        return number
    }

    TelephonyManager.getSimOperator.overload().implementation = function () {
        const _simOperator = this.getSimOperator()
        Log.i(
            `spoof TelephonyManager.getSimOperator: ${_simOperator} -> ${simOperator}`
        )
        return simOperator
    }

    TelephonyManager.getNetworkOperator.overload().implementation =
        function () {
            const _networkOperator = this.getNetworkOperator()
            Log.i(
                `spoof TelephonyManager.getNetworkOperator: ${_networkOperator} -> ${networkOperator}`
            )
            return networkOperator
        }

    TelephonyManager.getSimSerialNumber.overload().implementation =
        function () {
            const _simSerialNumber = this.getSimSerialNumber()
            Log.i(
                `spoof TelephonyManager.getSimSerialNumber: ${_simSerialNumber} -> ${simSerialNumber}`
            )
            return simSerialNumber
        }

    TelephonyManager.getSubscriberId.overload().implementation = function () {
        const _imsi = this.getSubscriberId()
        Log.i(`spoof TelephonyManager.getSubscriberId: ${_imsi} -> ${imsi}`)
        return imsi
    }

    TelephonyManager.getImei.overload().implementation = function () {
        const _imei = this.getImei()
        Log.i(`spoof TelephonyManager.getImei: ${_imei} -> ${imei}`)
        return imei
    }

    TelephonyManager.getNetworkCountryIso.overload().implementation =
        function () {
            const _countryIso = this.getNetworkCountryIso()
            Log.i(
                `spoof TelephonyManager.getNetworkCountryIso: ${_countryIso} -> ${countryIso}`
            )
            return countryIso
        }

    TelephonyManager.getSimCountryIso.overload().implementation = function () {
        const _countryIso = this.getSimCountryIso()
        Log.i(
            `spoof TelephonyManager.getSimCountryIso: ${_countryIso} -> ${countryIso}`
        )
        return countryIso
    }

    TelephonyManager.getSubscriptionId.overload().implementation = function () {
        const _subId = this.getSubscriptionId()
        if (!subId) {
            Log.i(_subId)
            return _subId
        }
        Log.i(`spoof TelephonyManager.getSubscriptionId: ${_subId} -> ${subId}`)
        return parseInt(subId)
    }

    TelephonyManager.getSimState.overload().implementation = function () {
        const _simState = this.getSimState()
        Log.i(`spoof TelephonyManager.getSimState: ${_simState} -> 5`)
        return 5
    }

    const PhoneNumberVerification = Java.use(
        "com.google.android.gms.constellation.PhoneNumberVerification"
    )
    PhoneNumberVerification.$init.overload(
        "java.lang.String",
        "long",
        "int",
        "int",
        "java.lang.String",
        "android.os.Bundle",
        "int",
        "long"
    ).implementation = function (str, j, i, i2, str2, bundle, i3, l) {
        Log.e("PhoneNumberVerification.$init")

        Log.e(
            `str: ${str}, j: ${j}, i: ${i}, i2: ${i2}, str2: ${str2}, i3: ${i3}, l: ${l}`
        )
        // print bundle
        const keySet = bundle.keySet().toArray()

        for (let i = 0; i < keySet.length; i++) {
            const key = keySet[i]
            Log.i(`key: ${key}, value: ${bundle.get(key)}`)
        }

        return this.$init(str, j, i, i2, str2, bundle, i3, l)
    }

    const SetAsterismConsentRequest = Java.use(
        "com.google.android.gms.asterism.SetAsterismConsentRequest"
    )
    SetAsterismConsentRequest.$init.overload(
        "int",
        "int",
        "int",
        "[I",
        "java.lang.Long",
        "int",
        "android.os.Bundle",
        "int",
        "java.lang.String",
        "java.lang.String",
        "java.lang.String",
        "java.lang.String",
        "java.lang.String",
        "java.lang.String",
        "java.lang.String",
        "java.lang.String",
        "int"
    ).implementation = function (
        i,
        i2,
        i3,
        iArr,
        l,
        i4,
        bundle,
        i5,
        str,
        str2,
        str3,
        str4,
        str5,
        str6,
        str7,
        str8,
        i6
    ) {
        Log.i("SetAsterismConsentRequest.$init")

        Log.i(
            `i: ${i}, i2: ${i2}, i3: ${i3}, iArr: ${iArr}, l: ${l}, i4: ${i4}, i5: ${i5}, str: ${str}, str2: ${str2}, str3: ${str3}, str4: ${str4}, str5: ${str5}, str6: ${str6}, str7: ${str7}, str8: ${str8}, i6: ${i6}`
        )
        // print bundle
        const keySet = bundle.keySet().toArray()
        for (let i = 0; i < keySet.length; i++) {
            const key = keySet[i]
            Log.i(`key: ${key}, value: ${bundle.get(key)}`)
        }

        return this.$init(
            i,
            i2,
            i3,
            iArr,
            l,
            i4,
            bundle,
            i5,
            str,
            str2,
            str3,
            str4,
            str5,
            str6,
            str7,
            str8,
            i6
        )
    }

    const SetAsterismConsentResponse = Java.use(
        "com.google.android.gms.asterism.SetAsterismConsentResponse"
    )
    SetAsterismConsentResponse.$init.overload(
        "int",
        "java.lang.String",
        "java.lang.String"
    ).implementation = function (i, str, str2) {
        Log.i("SetAsterismConsentResponse.$init")
        Log.i(`i: ${i}, str: ${str}, str2: ${str2}`)
        return this.$init(i, str, str2)
    }

    const amac = Java.use("amac")
    const amlo = Java.use("amlo")
    const emiy = Java.use("emiy")
    const emiz = Java.use("emiz")
    const emis = Java.use("emis")
    const fiwu = Java.use("fiwu")
    const ambs = Java.use("ambs")
    const emkm = Java.use("emkm")
    const fivh = Java.use("fivh")
    const fivk = Java.use("fivk")
    const fivn = Java.use("fivn")
    const emjr = Java.use("emjr")
    const amag = Java.use("amag")
    const ftha = Java.use("ftha")
    const ftgy = Java.use("ftgy")
    const fuem = Java.use("fuem")
    const fiwt = Java.use("fiwt")
    const TimeUnit = Java.use("java.util.concurrent.TimeUnit")
    const ambi = Java.use("ambi")
    const fivj = Java.use("fivj")
    amac.o.overload("amlu", "boolean", "boolean", "fiwt").implementation =
        function (amluVar, z, z2, fiwtVar) {
            Log.i("amac.o", amluVar, z, z2, fiwtVar)
            try {
                var z3
                var z4
                const eq = fiwtVar.eQ()
                const arr0 = Java.array("java.lang.Object", [this.z(eq)])
                this._a.value.d("SetConsentRequest: %s", arr0)

                var amloVar = this._d.value
                var emiyVar = Java.cast(emiz.h.value.eV(), emiy)

                if (!emiyVar._b.value.fm()) {
                    emiyVar.O()
                }
                var emizVar = Java.cast(emiyVar._b.value, emiz)
                emizVar.b = emkm.a(10)
                Log.i(emizVar, emizVar.b, emizVar.a)

                emizVar.a = emizVar.a | 1
                var eV = emis.d.value.eV()

                if ((fiwtVar.a.value & 2) != 0) {
                    var fivnVar = fiwtVar.e.value
                    if (fivnVar == null) {
                        fivnVar = fivn.c.value
                    }
                    var b = fivh.b(fivnVar.a.value)
                    if (b == 0) {
                        z3 = false
                    } else if (b == 3) {
                        z3 = true
                    } else {
                        z3 = false
                    }
                    if (!eV._b.value.fm()) {
                        eV.O()
                    }
                    var fbzbVar = eV._b.value
                    var emisVar = Java.cast(fbzbVar, emis)
                    emisVar.a |= 1
                    emisVar.b = z3
                    var fivnVar2 = fiwtVar.e.value
                    if (fivnVar2 == null) {
                        fivnVar2 = fivn.c.value
                    }
                    var a2 = fivk.a(fivnVar2.b.value)
                    if (a2 == 0) {
                        z4 = false
                    } else if (a2 == 3) {
                        z4 = true
                    } else {
                        z4 = false
                    }
                    if (!fbzbVar.fm()) {
                        eV.O()
                    }
                    var emisVar2 = Java.cast(eV._b.value, emis)
                    emisVar2.a |= 2
                    emisVar2.c = z4
                }
                if (!emiyVar._b.value.fm()) {
                    emiyVar.O()
                }
                var emizVar2 = Java.cast(emiyVar._b.value, emiz)
                var emisVar3 = Java.cast(eV.K(), emis)
                emisVar3.getClass()
                emizVar2.c = emisVar3
                emizVar2.a |= 2
                amloVar.A(amluVar, emjr.b(5), Java.cast(emiyVar.K(), emiz))

                var v = this.v()
                var akxiVar = this._c.value
                var j = this._e.value
                if (amag._a.value == null) {
                    amag._a.value = ftha.b(
                        ftgy._a.value,
                        "google.internal.communications.phonedeviceverification.v1.PhoneDeviceVerification/SetConsent",
                        fuem.a(fiwt.k.value),
                        fuem.a(fiwu.a.value)
                    )
                }
                // const vdg = v.d.value.g(
                //     amag._a.value,
                //     akxiVar,
                //     fiwtVar,
                //     Java.use('java.lang.Long').valueOf(j).longValue(),
                //     TimeUnit.MILLISECONDS.value,
                //     v.e.value
                // )
                // Log.i("aaaaa")
                // const eqres = Java.cast(vdg, fiwu).eQ()
                // Log.i("bbbbb")
                // const res = this.z(eqres)
                // Log.i("SetConsentResponse: ", res)
                // const arr = Java.array("java.lang.Object", [res])
                // this._a.value.d("SetConsentResponse: %s", arr)
                var amloVar2 = this._d.value
                var emiyVar2 = Java.cast(emiz.h.value.eV(), emiy)
                if (!emiyVar2._b.value.fm()) {
                    emiyVar2.O()
                }
                var emizVar3 = Java.cast(emiyVar2._b.value, emiz)

                emizVar3.b = emkm.a(10)
                emizVar3.a |= 1
                amloVar2.A(amluVar, emjr.b(6), Java.cast(emiyVar2.K(), emiz))
                var a3 = ambi.b().a(this._b.value.getApplicationContext())
                a3.n(z)
                a3.m(Java.use("java.lang.Boolean").valueOf(z2))
                var b2 = fivj.b(fiwtVar.g.value)
                if (b2 == 0) {
                    b2 = 1
                }
                var a4 = fivj.a(b2)
                var edit = Java.cast(a3, ambs)._c.value.edit()
                edit.putInt("device_consent_version", a4)
                edit.apply()
                Log.i("oooooooooo")
            } catch (e) {
                Log.i("2222222", e)
                trace()
            }
            // this.o(amluVar, z, z2, fiwtVar)
        }

    const ConscryptFileDescriptorSocket = Java.use(
        "com.google.android.gms.org.conscrypt.ConscryptFileDescriptorSocket"
    )
    ConscryptFileDescriptorSocket.setSoWriteTimeout.overload(
        "int"
    ).implementation = function (i) {
        Log.i("ConscryptFileDescriptorSocket.setSoWriteTimeout: ", i)
        return this.setSoWriteTimeout(i)
    }
    // ConscryptFileDescriptorSocket.verifyCertificateChain.overload(
    //     //byte[][] bArr, String str
    //     "[[B",
    //     "java.lang.String"
    // ).implementation = function (bArr, str) {
    //     Log.i(
    //         "ConscryptFileDescriptorSocket.verifyCertificateChain: ",
    //         bArr,
    //         str
    //     )
    // }

    const alja = Java.use("alja")
    alja.u.overload("java.lang.Exception").implementation = function (e) {
        Log.i("alja.u", JSON.stringify(e))
        Log.i(Object.keys(e))

        const b = e.b.value
        Log.i("b", b.toString())
        return this.u(e)
    }

    const albf = Java.use("albf")
    albf.h.overload("java.lang.String", "[Ljava.lang.Object;").implementation =
        function (str, objArr) {
            Log.e("albf.h", str, objArr)
            if (str.includes("Verification failed")) {
                trace()
            }
            return this.h(str, objArr)
        }

    const alyx = Java.use("alyx")
    const fixf = Java.use("fixf")
    alyx.a.overload("fixf").implementation = function (fixf) {
        Log.i("alyx.a", fixf)
        const b = this.a(fixf)
        const keySet = b.keySet().toArray()
        for (let i = 0; i < keySet.length; i++) {
            const key = keySet[i]
            Log.w(`key: ${key}, value: ${b.get(key)}`)
        }
        return b
    }
    alyx.m.overload("amlu", "java.util.List").implementation = function (
        amlu,
        list
    ) {
        Log.e("alyx.m", amlu, list)
        for (let i = 0; i < list.size(); i++) {
            Log.e(`list[${i}]=${list.get(i)}`)
        }
        const a = amlu._a.value // string
        Log.e(`\ta=${a}`)
        const f = amlu.f.value // string
        Log.e(`\tf=${f}`)
        const g = amlu.g.value // list
        for (let i = 0; i < g.size(); i++) {
            Log.e(`\tg[${i}]=${g.get(i)}`)
        }

        const h = amlu.h.value // list
        if (h) {
            for (let i = 0; i < h.size(); i++) {
                Log.e(`\th[${i}]=${h.get(i)}`)
            }
        }

        const HashMap = Java.use("java.util.HashMap")
        const d = Java.cast(amlu.d.value, HashMap) // map
        const keySet = d.keySet().toArray()
        for (let key of keySet) {
            Log.e(`\td[${key}]=${d.get(key)}`)
            Log.e(Object.getOwnPropertyNames(d.get(key).__proto__).join("\n"))
            const gson = Java.use("com.google.gson.Gson").$new()
            const json = gson.toJson(d.get(key))
            Log.e(json)
        }

        const e = Java.cast(amlu.e.value, HashMap) // map
        const keySet2 = e.keySet().toArray()
        for (let key of keySet2) {
            Log.e(`\te[${key}]=${e.get(key)}`)
        }
        return this.m(amlu, list)
    }

    const Bundle = Java.use("android.os.Bundle")
    Bundle.getInt.overload("java.lang.String").implementation = function (str) {
        Log.e(`Bundle.getInt: ${str}`)
        if (str === "sim_slot_index") {
          
            trace()
            return 0
        }
        return this.getInt(str)
    }
})