tree b2ecee2c34a99ff87a20f5d4d5334ca37298c6bb
parent aacc16067b22f2eae941bbe01eb6d0a48c1990d2
author Oliver Gjoneski <ogjoneski@gmail.com> 1354512762 -0500
committer Shareef Ali <shareefalis@gmail.com> 1354659076 -0500

cm: apns-conf.xml: (eHRPD/LTE handoff) Change pdp type for default APNs

This is to address hang-ups in eHRPD-LTE hand-offs as witnessed on d2spr.

Log of problem:

[GsmDC-6] Connecting to carrier: 'APN2 EHRPD internet' APN: 'n.ispsn' proxy: 'null' port: 'null'
[0319]> SETUP_DATA_CALL 15 0 n.ispsn null null 0 IPV4V6
....
qmi_ril(0/281): [event] qcril_data_event_hdlr: Dual-IP Partial Retry: Failure
qcril_data_event_hdlr: Dual-IP Partial Retry: Sending setup data call failure code

On stock rom:

[GsmDC-50] Connecting to carrier: 'APN2 EHRPD internet' APN: 'n.ispsn' proxy: '' port: '
[GsmDC-50] Allow IPv6 type request: false
[9240]> SETUP_DATA_CALL 15 0 n.ispsn 0 IP

Note, PDP type on stock rom/APN is not Dual-IP. Without information on how
"Allow IPv6 type request" is tested, for now force the PDP change via apns-conf.xml

Change-Id: I938bf9d1a0b50ec72283fbdba3785832519f3f48
