From 81616af6df75867320c6eb7ed21219a67706b7a2 Mon Sep 17 00:00:00 2001 From: AndyCGYan Date: Tue, 3 Sep 2019 12:42:00 +0000 Subject: [PATCH] Sync up to v119 --- ...1-Fix-backlight-control-on-Galaxy-S9.patch | 12 +- ...erty-to-use-linear-brightness-slider.patch | 37 + ...samsung-touch-proximity-sensor-as-fa.patch | 53 + ...enable-for-under-display-fingerprint.patch | 107 ++ .../0039-Use-Samsung-power-HAL.patch | 30 + ...sung.sensor.physical_proximity-if-av.patch | 31 + ...ng-devices-requires-lying-colorspace.patch | 31 + ...ed-to-send-a-hack-message-to-HAL-to-.patch | 35 + ...adioIndication-RadioResponse-to-get-.patch | 1094 +++++++++++++++++ ...feplace-remover.-It-will-reboot-to-r.patch | 76 ++ ...t-file-descriptor.-This-lead-to-zygo.patch | 70 ++ 11 files changed, 1570 insertions(+), 6 deletions(-) create mode 100644 patches/platform_frameworks_base/0036-Add-property-to-use-linear-brightness-slider.patch create mode 100644 patches/platform_frameworks_base/0037-Add-support-for-samsung-touch-proximity-sensor-as-fa.patch create mode 100644 patches/platform_frameworks_base/0038-Add-Samsung-fod_enable-for-under-display-fingerprint.patch create mode 100644 patches/platform_frameworks_base/0039-Use-Samsung-power-HAL.patch create mode 100644 patches/platform_frameworks_base/0040-Also-add-com.samsung.sensor.physical_proximity-if-av.patch create mode 100644 patches/platform_frameworks_native/0005-Some-Samsung-devices-requires-lying-colorspace.patch create mode 100644 patches/platform_frameworks_native/0006-On-Samsung-we-need-to-send-a-hack-message-to-HAL-to-.patch create mode 100644 patches/platform_frameworks_opt_telephony/0008-Plugin-Samsung-RadioIndication-RadioResponse-to-get-.patch create mode 100644 patches/platform_system_core/0009-Add-a-Samsung-safeplace-remover.-It-will-reboot-to-r.patch create mode 100644 patches/platform_system_core/0010-Always-close-boot-file-descriptor.-This-lead-to-zygo.patch diff --git a/patches/platform_frameworks_base/0001-Fix-backlight-control-on-Galaxy-S9.patch b/patches/platform_frameworks_base/0001-Fix-backlight-control-on-Galaxy-S9.patch index ce6407a..82a0e8d 100644 --- a/patches/platform_frameworks_base/0001-Fix-backlight-control-on-Galaxy-S9.patch +++ b/patches/platform_frameworks_base/0001-Fix-backlight-control-on-Galaxy-S9.patch @@ -1,25 +1,25 @@ -From e3f08c02ab7d0bc5d0efcc9eb3ad98d9a3a98e32 Mon Sep 17 00:00:00 2001 +From 7369d2c37720cc88bbb28c6487b0209732ac52fa Mon Sep 17 00:00:00 2001 From: Pierre-Hugues Husson Date: Sat, 24 Mar 2018 08:01:48 +0100 -Subject: [PATCH 01/31] Fix backlight control on Galaxy S9(+) +Subject: [PATCH] Fix backlight control on Galaxy S9(+) --- .../core/java/com/android/server/lights/LightsService.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/services/core/java/com/android/server/lights/LightsService.java b/services/core/java/com/android/server/lights/LightsService.java -index a94ed608b9c..762b0ae4037 100644 +index 9dee0171683..378e7c367b1 100644 --- a/services/core/java/com/android/server/lights/LightsService.java +++ b/services/core/java/com/android/server/lights/LightsService.java -@@ -21,6 +21,7 @@ import android.app.ActivityManager; - import android.content.Context; +@@ -23,6 +23,7 @@ import android.content.Context; + import android.content.pm.PackageManager; import android.os.Handler; import android.os.Message; +import android.os.SystemProperties; import android.os.Trace; import android.provider.Settings; import android.util.Slog; -@@ -52,6 +53,12 @@ public class LightsService extends SystemService { +@@ -54,6 +55,12 @@ public class LightsService extends SystemService { return; } diff --git a/patches/platform_frameworks_base/0036-Add-property-to-use-linear-brightness-slider.patch b/patches/platform_frameworks_base/0036-Add-property-to-use-linear-brightness-slider.patch new file mode 100644 index 0000000..0bd46c6 --- /dev/null +++ b/patches/platform_frameworks_base/0036-Add-property-to-use-linear-brightness-slider.patch @@ -0,0 +1,37 @@ +From 2dcdcc26c6f48915fc9b036f7c72adc29b110901 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Sun, 11 Aug 2019 10:30:37 +0200 +Subject: [PATCH 36/40] Add property to use linear brightness slider + +--- + .../com/android/settingslib/display/BrightnessUtils.java | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/packages/SettingsLib/src/com/android/settingslib/display/BrightnessUtils.java b/packages/SettingsLib/src/com/android/settingslib/display/BrightnessUtils.java +index 55723f9d8ed..da8ce4a67e9 100644 +--- a/packages/SettingsLib/src/com/android/settingslib/display/BrightnessUtils.java ++++ b/packages/SettingsLib/src/com/android/settingslib/display/BrightnessUtils.java +@@ -50,7 +50,12 @@ public class BrightnessUtils { + * @param max The maximum acceptable value for the setting. + * @return The corresponding setting value. + */ ++ private static final boolean useLinearBrightness = android.os.SystemProperties.getBoolean("persist.sys.phh.linear_brightness", false); + public static final int convertGammaToLinear(int val, int min, int max) { ++ if(useLinearBrightness) { ++ if(val < 4) return 1; ++ return val/4; ++ } + final float normalizedVal = MathUtils.norm(0, GAMMA_SPACE_MAX, val); + final float ret; + if (normalizedVal <= R) { +@@ -87,6 +92,7 @@ public class BrightnessUtils { + * @return The corresponding slider value + */ + public static final int convertLinearToGamma(int val, int min, int max) { ++ if(useLinearBrightness) return val*4; + // For some reason, HLG normalizes to the range [0, 12] rather than [0, 1] + final float normalizedVal = MathUtils.norm(min, max, val) * 12; + final float ret; +-- +2.17.1 + diff --git a/patches/platform_frameworks_base/0037-Add-support-for-samsung-touch-proximity-sensor-as-fa.patch b/patches/platform_frameworks_base/0037-Add-support-for-samsung-touch-proximity-sensor-as-fa.patch new file mode 100644 index 0000000..a8a50c4 --- /dev/null +++ b/patches/platform_frameworks_base/0037-Add-support-for-samsung-touch-proximity-sensor-as-fa.patch @@ -0,0 +1,53 @@ +From 2b3f995ecdc7c8c8c066d698f66d2ea4f9f6cb56 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Mon, 12 Aug 2019 23:08:26 +0200 +Subject: [PATCH 37/40] Add support for samsung touch proximity sensor as + fallback to real proximity sensor + +--- + .../server/display/DisplayPowerController.java | 15 +++++++++++++++ + 1 file changed, 15 insertions(+) + +diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java +index 6f0a51bf107..32cece6f893 100644 +--- a/services/core/java/com/android/server/display/DisplayPowerController.java ++++ b/services/core/java/com/android/server/display/DisplayPowerController.java +@@ -62,6 +62,7 @@ import com.android.server.am.BatteryStatsService; + import com.android.server.policy.WindowManagerPolicy; + + import java.io.PrintWriter; ++import java.util.List; + + /** + * Controls the power state of the display. +@@ -501,6 +502,13 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call + + if (!DEBUG_PRETEND_PROXIMITY_SENSOR_ABSENT) { + mProximitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY); ++ if(mProximitySensor == null) { ++ List sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL); ++ for(Sensor sensor: sensors) { ++ if("com.samsung.sensor.touch_proximity".equals(sensor.getStringType())) ++ mProximitySensor = sensor; ++ } ++ } + if (mProximitySensor != null) { + mProximityThreshold = Math.min(mProximitySensor.getMaximumRange(), + TYPICAL_PROXIMITY_THRESHOLD); +@@ -1816,6 +1824,13 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call + public void onSensorChanged(SensorEvent event) { + if (mProximitySensorEnabled) { + final long time = SystemClock.uptimeMillis(); ++ if("com.samsung.sensor.touch_proximity".equals(mProximitySensor.getStringType())) { ++ int v = (int)event.values[0]; ++ boolean positive = (v <= 4); ++ android.util.Log.d("PHH", "Samsung sensor changed " + positive + ":" + v); ++ handleProximitySensorEvent(time, positive); ++ return; ++ } + final float distance = event.values[0]; + boolean positive = distance >= 0.0f && distance < mProximityThreshold; + handleProximitySensorEvent(time, positive); +-- +2.17.1 + diff --git a/patches/platform_frameworks_base/0038-Add-Samsung-fod_enable-for-under-display-fingerprint.patch b/patches/platform_frameworks_base/0038-Add-Samsung-fod_enable-for-under-display-fingerprint.patch new file mode 100644 index 0000000..722d5b1 --- /dev/null +++ b/patches/platform_frameworks_base/0038-Add-Samsung-fod_enable-for-under-display-fingerprint.patch @@ -0,0 +1,107 @@ +From 400520d763e99653b8ebf81ed38e178bea2443b5 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Mon, 12 Aug 2019 23:10:21 +0200 +Subject: [PATCH 38/40] Add Samsung `fod_enable` for under-display fingerprint. + For the moment only ultra-sonic works + +--- + .../server/fingerprint/FacolaView.java | 54 +++++++++++++++++++ + 1 file changed, 54 insertions(+) + +diff --git a/services/core/java/com/android/server/fingerprint/FacolaView.java b/services/core/java/com/android/server/fingerprint/FacolaView.java +index 86f03360ad0..254c1f99b44 100644 +--- a/services/core/java/com/android/server/fingerprint/FacolaView.java ++++ b/services/core/java/com/android/server/fingerprint/FacolaView.java +@@ -32,6 +32,9 @@ import android.view.Gravity; + import android.os.Handler; + import android.os.Looper; + ++import java.io.BufferedReader; ++import java.io.File; ++import java.io.FileReader; + import java.io.PrintWriter; + + import vendor.xiaomi.hardware.fingerprintextension.V1_0.IXiaomiFingerprint; +@@ -53,9 +56,12 @@ public class FacolaView extends ImageView implements OnTouchListener { + private boolean visible = false; + + private final WindowManager mWM; ++ private final boolean samsungFod = samsungHasCmd("fod_enable"); + FacolaView(Context context) { + super(context); + ++ android.util.Log.d("PHH", "Samsung FOD " + samsungFod); ++ + mMainHandler = new Handler(Looper.getMainLooper()); + + String[] location = android.os.SystemProperties.get("persist.vendor.sys.fp.fod.location.X_Y", "").split(","); +@@ -157,6 +163,9 @@ public class FacolaView extends ImageView implements OnTouchListener { + } + + public void show() { ++ if(samsungFod) { ++ samsungCmd("fod_enable,1,1"); ++ } + if(mX == -1 || mY == -1 || mW == -1 || mH == -1) return; + + try { +@@ -191,6 +200,9 @@ public class FacolaView extends ImageView implements OnTouchListener { + } + + public void hide() { ++ if(samsungFod) { ++ samsungCmd("fod_enable,0"); ++ } + if(mX == -1 || mY == -1 || mW == -1 || mH == -1) return; + + try { +@@ -211,4 +223,46 @@ public class FacolaView extends ImageView implements OnTouchListener { + mWM.removeView(this); + visible = false; + } ++ ++ private static boolean samsungHasCmd(String cmd) { ++ try { ++ File f = new File("/sys/devices/virtual/sec/tsp/cmd_list"); ++ if(!f.exists()) return false; ++ ++ BufferedReader b = new BufferedReader(new FileReader(f)); ++ String line = null; ++ while( (line = b.readLine()) != null) { ++ if(line.equals(cmd)) return true; ++ } ++ return false; ++ } catch(Exception e) { ++ return false; ++ } ++ } ++ ++ private static String readFile(String path) { ++ try { ++ File f = new File(path); ++ ++ BufferedReader b = new BufferedReader(new FileReader(f)); ++ return b.readLine(); ++ } catch(Exception e) { ++ return null; ++ } ++ } ++ ++ private static void samsungCmd(String cmd) { ++ try { ++ PrintWriter writer = new PrintWriter("/sys/devices/virtual/sec/tsp/cmd", "UTF-8"); ++ writer.println(cmd); ++ writer.close(); ++ ++ String status = readFile("/sys/devices/virtual/sec/tsp/cmd_status"); ++ String ret = readFile("/sys/devices/virtual/sec/tsp/cmd_result"); ++ ++ android.util.Log.d("PHH", "Sending command " + cmd + " returned " + ret + ":" + status); ++ } catch(Exception e) { ++ android.util.Log.d("PHH", "Failed sending command " + cmd, e); ++ } ++ } + } +-- +2.17.1 + diff --git a/patches/platform_frameworks_base/0039-Use-Samsung-power-HAL.patch b/patches/platform_frameworks_base/0039-Use-Samsung-power-HAL.patch new file mode 100644 index 0000000..ae24c68 --- /dev/null +++ b/patches/platform_frameworks_base/0039-Use-Samsung-power-HAL.patch @@ -0,0 +1,30 @@ +From 2699dc1cb20a07e8bccf60b47d556d10289bb3b3 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Wed, 14 Aug 2019 08:50:47 +0200 +Subject: [PATCH 39/40] Use Samsung power HAL + +Samsung likes to have two android.hardware.power@1.0 implementation +side-by-side, one that works, one that doesn't. +Pick the one that works. +--- + .../core/jni/com_android_server_power_PowerManagerService.cpp | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/services/core/jni/com_android_server_power_PowerManagerService.cpp b/services/core/jni/com_android_server_power_PowerManagerService.cpp +index b2d35d4153a..3cac85139c5 100644 +--- a/services/core/jni/com_android_server_power_PowerManagerService.cpp ++++ b/services/core/jni/com_android_server_power_PowerManagerService.cpp +@@ -84,7 +84,9 @@ static bool checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodNa + // The caller must be holding gPowerHalMutex. + static void connectPowerHalLocked() { + if (gPowerHalExists && gPowerHalV1_0_ == nullptr) { +- gPowerHalV1_0_ = IPowerV1_0::getService(); ++ gPowerHalV1_0_ = IPowerV1_0::getService("miscpower"); ++ if(gPowerHalV1_0_ == nullptr) ++ gPowerHalV1_0_ = IPowerV1_0::getService(); + if (gPowerHalV1_0_ != nullptr) { + ALOGI("Loaded power HAL 1.0 service"); + // Try cast to powerHAL V1_1 +-- +2.17.1 + diff --git a/patches/platform_frameworks_base/0040-Also-add-com.samsung.sensor.physical_proximity-if-av.patch b/patches/platform_frameworks_base/0040-Also-add-com.samsung.sensor.physical_proximity-if-av.patch new file mode 100644 index 0000000..4d8475f --- /dev/null +++ b/patches/platform_frameworks_base/0040-Also-add-com.samsung.sensor.physical_proximity-if-av.patch @@ -0,0 +1,31 @@ +From ad4d27e4be4048fa178d4755be4e2063e3204246 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Wed, 14 Aug 2019 23:36:45 +0200 +Subject: [PATCH 40/40] Also add com.samsung.sensor.physical_proximity (if + available, it is more a true proximity sensor than touch proximity sensor) + +--- + .../com/android/server/display/DisplayPowerController.java | 7 +++++++ + 1 file changed, 7 insertions(+) + +diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java +index 32cece6f893..9ffc8a817e2 100644 +--- a/services/core/java/com/android/server/display/DisplayPowerController.java ++++ b/services/core/java/com/android/server/display/DisplayPowerController.java +@@ -502,6 +502,13 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call + + if (!DEBUG_PRETEND_PROXIMITY_SENSOR_ABSENT) { + mProximitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY); ++ if(mProximitySensor == null) { ++ List sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL); ++ for(Sensor sensor: sensors) { ++ if("com.samsung.sensor.physical_proximity".equals(sensor.getStringType())) ++ mProximitySensor = sensor; ++ } ++ } + if(mProximitySensor == null) { + List sensors = mSensorManager.getSensorList(Sensor.TYPE_ALL); + for(Sensor sensor: sensors) { +-- +2.17.1 + diff --git a/patches/platform_frameworks_native/0005-Some-Samsung-devices-requires-lying-colorspace.patch b/patches/platform_frameworks_native/0005-Some-Samsung-devices-requires-lying-colorspace.patch new file mode 100644 index 0000000..d6a4cd3 --- /dev/null +++ b/patches/platform_frameworks_native/0005-Some-Samsung-devices-requires-lying-colorspace.patch @@ -0,0 +1,31 @@ +From 725b2c6c7b45072c96531656711b89bf9b6b502a Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Mon, 12 Aug 2019 23:48:37 +0200 +Subject: [PATCH 5/6] Some Samsung devices requires lying colorspace + +--- + opengl/libs/EGL/eglApi.cpp | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp +index c65bddfbb..3cde19af1 100644 +--- a/opengl/libs/EGL/eglApi.cpp ++++ b/opengl/libs/EGL/eglApi.cpp +@@ -454,8 +454,14 @@ EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, + // ---------------------------------------------------------------------------- + + // Translates EGL color spaces to Android data spaces. ++static int samsungColorspace = -1; + static android_dataspace dataSpaceFromEGLColorSpace(EGLint colorspace) { ++ if(samsungColorspace == -1) { ++ samsungColorspace = property_get_bool("persist.sys.phh.samsung_colorspace", false); ++ } + if (colorspace == EGL_GL_COLORSPACE_LINEAR_KHR) { ++ if(samsungColorspace) ++ return HAL_DATASPACE_UNKNOWN; + return HAL_DATASPACE_SRGB_LINEAR; + } else if (colorspace == EGL_GL_COLORSPACE_SRGB_KHR) { + return HAL_DATASPACE_SRGB; +-- +2.17.1 + diff --git a/patches/platform_frameworks_native/0006-On-Samsung-we-need-to-send-a-hack-message-to-HAL-to-.patch b/patches/platform_frameworks_native/0006-On-Samsung-we-need-to-send-a-hack-message-to-HAL-to-.patch new file mode 100644 index 0000000..9e3b511 --- /dev/null +++ b/patches/platform_frameworks_native/0006-On-Samsung-we-need-to-send-a-hack-message-to-HAL-to-.patch @@ -0,0 +1,35 @@ +From 663f83cdb9628315a8501a24d85eee6df707e1ae Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Wed, 14 Aug 2019 23:37:10 +0200 +Subject: [PATCH 6/6] On Samsung, we need to send a hack-message to HAL to get + all Sensors + +--- + services/sensorservice/SensorDevice.cpp | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/services/sensorservice/SensorDevice.cpp b/services/sensorservice/SensorDevice.cpp +index 115a983bc..7fe05190e 100644 +--- a/services/sensorservice/SensorDevice.cpp ++++ b/services/sensorservice/SensorDevice.cpp +@@ -26,6 +26,8 @@ + #include + #include + ++#include ++ + using namespace android::hardware::sensors::V1_0; + using namespace android::hardware::sensors::V1_0::implementation; + using android::hardware::hidl_vec; +@@ -59,6 +61,8 @@ SensorDevice::SensorDevice() + + float minPowerMa = 0.001; // 1 microAmp + ++ if(::android::base::GetBoolProperty("persist.sys.phh.samsung_sensors", false)) ++ setMode(5555); + checkReturn(mSensors->getSensorsList( + [&](const auto &list) { + const size_t count = list.size(); +-- +2.17.1 + diff --git a/patches/platform_frameworks_opt_telephony/0008-Plugin-Samsung-RadioIndication-RadioResponse-to-get-.patch b/patches/platform_frameworks_opt_telephony/0008-Plugin-Samsung-RadioIndication-RadioResponse-to-get-.patch new file mode 100644 index 0000000..099c793 --- /dev/null +++ b/patches/platform_frameworks_opt_telephony/0008-Plugin-Samsung-RadioIndication-RadioResponse-to-get-.patch @@ -0,0 +1,1094 @@ +From 1fe282e9e4a684bfb4814021f7afc086f6c9bc60 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Mon, 12 Aug 2019 23:49:56 +0200 +Subject: [PATCH] Plugin Samsung RadioIndication/RadioResponse to get signal + strength + +Change-Id: Ic3d5801627bf3dd72d2e7b6bb3741b9d368d1f07 +--- + Android.mk | 4 +- + .../com/android/internal/telephony/RIL.java | 28 +- + .../telephony/SamsungRadioIndication.java | 303 ++++++++ + .../telephony/SamsungRadioResponse.java | 684 ++++++++++++++++++ + 4 files changed, 1014 insertions(+), 5 deletions(-) + create mode 100644 src/java/com/android/internal/telephony/SamsungRadioIndication.java + create mode 100644 src/java/com/android/internal/telephony/SamsungRadioResponse.java + +diff --git a/Android.mk b/Android.mk +index 5917dcf63..dccbad15d 100644 +--- a/Android.mk ++++ b/Android.mk +@@ -35,7 +35,9 @@ LOCAL_STATIC_JAVA_LIBRARIES := \ + android.hidl.base-V1.0-java \ + ims-ext-common + +-LOCAL_STATIC_JAVA_LIBRARIES += vendor.mediatek.hardware.radio-V2.0-java ++LOCAL_STATIC_JAVA_LIBRARIES += \ ++ vendor.mediatek.hardware.radio-V2.0-java \ ++ vendor.samsung.hardware.radio-V1.2-java \ + + LOCAL_MODULE_TAGS := optional + LOCAL_MODULE := telephony-common +diff --git a/src/java/com/android/internal/telephony/RIL.java b/src/java/com/android/internal/telephony/RIL.java +index 4a8c95641..64395d286 100644 +--- a/src/java/com/android/internal/telephony/RIL.java ++++ b/src/java/com/android/internal/telephony/RIL.java +@@ -198,6 +198,7 @@ public class RIL extends BaseCommands implements CommandsInterface { + vendor.mediatek.hardware.radio.V2_0.IRadioResponse mMtkRadioResponse; + vendor.mediatek.hardware.radio.V2_0.IRadioIndication mMtkRadioIndication; + volatile vendor.mediatek.hardware.radio.V2_0.IRadio mMtkRadioProxy = null; ++ volatile vendor.samsung.hardware.radio.V1_2.IRadio mSamsungRadioProxy = null; + + //***** Events + static final int EVENT_WAKE_LOCK_TIMEOUT = 2; +@@ -369,9 +370,28 @@ public class RIL extends BaseCommands implements CommandsInterface { + return mRadioProxy; + } + ++ String halName = HIDL_SERVICE_NAME[mPhoneId == null ? 0 : mPhoneId]; ++ ++ try { ++ mSamsungRadioProxy = vendor.samsung.hardware.radio.V1_2.IRadio.getService(halName); ++ mRadioProxy = mSamsungRadioProxy; ++ Rlog.e("PHH", "Got samsung radio proxy " + mSamsungRadioProxy); ++ if(mSamsungRadioProxy != null) { ++ Rlog.e("PHH", "Setting response"); ++ mRadioProxy.linkToDeath(mRadioProxyDeathRecipient, ++ mRadioProxyCookie.incrementAndGet()); ++ mSamsungRadioProxy.setResponseFunctions( ++ new SamsungRadioResponse(this, mRadioResponse), ++ new SamsungRadioIndication(this, mRadioIndication) ++ ); ++ } ++ return mRadioProxy; ++ } catch(Exception e) { ++ Rlog.e("PHH", "Failed getting samsung hardware radio", e); ++ } ++ + try { +- mRadioProxy = IRadio.getService(HIDL_SERVICE_NAME[mPhoneId == null ? 0 : mPhoneId], +- true); ++ mRadioProxy = IRadio.getService(halName, true); + if (mRadioProxy != null) { + mRadioProxy.linkToDeath(mRadioProxyDeathRecipient, + mRadioProxyCookie.incrementAndGet()); +@@ -397,8 +417,7 @@ public class RIL extends BaseCommands implements CommandsInterface { + if (mRadioProxy != null) { + try { + mMtkRadioProxy = +- vendor.mediatek.hardware.radio.V2_0.IRadio.getService( +- HIDL_SERVICE_NAME[mPhoneId == null ? 0 : mPhoneId]); ++ vendor.mediatek.hardware.radio.V2_0.IRadio.getService(halName); + if (mMtkRadioProxy != null) { + if (mMtkRadioResponse == null && mMtkRadioIndication == null) { + mMtkRadioResponse = new MtkRadioResponse(this, mRadioResponse); +@@ -409,6 +428,7 @@ public class RIL extends BaseCommands implements CommandsInterface { + } catch (RemoteException | RuntimeException e) { + riljLog("MTK RadioProxy is not available"); + } ++ + } + return mRadioProxy; + } +diff --git a/src/java/com/android/internal/telephony/SamsungRadioIndication.java b/src/java/com/android/internal/telephony/SamsungRadioIndication.java +new file mode 100644 +index 000000000..9eadec147 +--- /dev/null ++++ b/src/java/com/android/internal/telephony/SamsungRadioIndication.java +@@ -0,0 +1,303 @@ ++package com.android.internal.telephony; ++ ++import android.hardware.radio.V1_0.SetupDataCallResult; ++ ++import java.util.ArrayList; ++ ++import vendor.samsung.hardware.radio.V1_2.IRadioIndication; ++ ++import vendor.samsung.hardware.radio.V1_2.ApnProfile; ++import vendor.samsung.hardware.radio.V1_2.SecSignalStrength; ++import vendor.samsung.hardware.radio.V1_2.OemSSReleaseComplete; ++import vendor.samsung.hardware.radio.V1_2.DcParam; ++import vendor.samsung.hardware.radio.V1_2.NrSignalStrength; ++import android.hardware.radio.V1_2.PhysicalChannelConfig; ++ ++public class SamsungRadioIndication extends IRadioIndication.Stub { ++ RIL mRil; ++ RadioIndication mIndication; ++ ++ SamsungRadioIndication(RIL ril, RadioIndication indication) { ++ mRil = ril; ++ mIndication = indication; ++ } ++ ++ //++ Radio V1_0 ++ public void radioStateChanged(int type, int radioState) { ++ mIndication.radioStateChanged(type, radioState); ++ } ++ ++ public void callStateChanged(int type) { ++ mIndication.callStateChanged(type); ++ } ++ ++ public void networkStateChanged(int type) { ++ mIndication.networkStateChanged(type); ++ } ++ ++ public void newSms(int type, ArrayList pdu) { ++ mIndication.newSms(type, pdu); ++ } ++ ++ public void newSmsStatusReport(int type, ArrayList pdu) { ++ mIndication.newSmsStatusReport(type, pdu); ++ } ++ ++ public void newSmsOnSim(int type, int recordNumber) { ++ mIndication.newSmsOnSim(type, recordNumber); ++ } ++ ++ public void onUssd(int type, int modeType, String msg) { ++ mIndication.onUssd(type, modeType, msg); ++ } ++ ++ public void nitzTimeReceived(int type, String nitzTime, long receivedTime) { ++ mIndication.nitzTimeReceived(type, nitzTime, receivedTime); ++ } ++ ++ public void currentSignalStrength(int type, android.hardware.radio.V1_0.SignalStrength signalStrength) { ++ mIndication.currentSignalStrength(type, signalStrength); ++ } ++ ++ public void dataCallListChanged(int type, ArrayList dcList) { ++ mIndication.dataCallListChanged(type, dcList); ++ } ++ ++ public void suppSvcNotify(int type, android.hardware.radio.V1_0.SuppSvcNotification suppSvc) { ++ mIndication.suppSvcNotify(type, suppSvc); ++ } ++ ++ public void stkSessionEnd(int type) { ++ mIndication.stkSessionEnd(type); ++ } ++ ++ public void stkProactiveCommand(int type, String cmd) { ++ mIndication.stkProactiveCommand(type, cmd); ++ } ++ ++ public void stkEventNotify(int type, String cmd) { ++ mIndication.stkEventNotify(type, cmd); ++ } ++ ++ public void stkCallSetup(int type, long timeout) { ++ mIndication.stkCallSetup(type, timeout); ++ } ++ ++ public void simSmsStorageFull(int type) { ++ mIndication.simSmsStorageFull(type); ++ } ++ ++ public void simRefresh(int type, android.hardware.radio.V1_0.SimRefreshResult refreshResult) { ++ mIndication.simRefresh(type, refreshResult); ++ } ++ ++ public void callRing(int type, boolean isGsm, android.hardware.radio.V1_0.CdmaSignalInfoRecord record) { ++ mIndication.callRing(type, isGsm, record); ++ } ++ ++ public void simStatusChanged(int type) { ++ mIndication.simStatusChanged(type); ++ } ++ ++ public void cdmaNewSms(int type, android.hardware.radio.V1_0.CdmaSmsMessage msg) { ++ mIndication.cdmaNewSms(type, msg); ++ } ++ ++ public void newBroadcastSms(int type, ArrayList data) { ++ mIndication.newBroadcastSms(type, data); ++ } ++ ++ public void cdmaRuimSmsStorageFull(int type) { ++ mIndication.cdmaRuimSmsStorageFull(type); ++ } ++ ++ public void restrictedStateChanged(int type, int state) { ++ mIndication.restrictedStateChanged(type, state); ++ } ++ ++ public void enterEmergencyCallbackMode(int type) { ++ mIndication.enterEmergencyCallbackMode(type); ++ } ++ ++ public void cdmaCallWaiting(int type, android.hardware.radio.V1_0.CdmaCallWaiting callWaitingRecord) { ++ mIndication.cdmaCallWaiting(type, callWaitingRecord); ++ } ++ ++ public void cdmaOtaProvisionStatus(int type, int status) { ++ mIndication.cdmaOtaProvisionStatus(type, status); ++ } ++ ++ public void cdmaInfoRec(int type, android.hardware.radio.V1_0.CdmaInformationRecords records) { ++ mIndication.cdmaInfoRec(type, records); ++ } ++ ++ public void indicateRingbackTone(int type, boolean start) { ++ mIndication.indicateRingbackTone(type, start); ++ } ++ ++ public void resendIncallMute(int type) { ++ mIndication.resendIncallMute(type); ++ } ++ ++ public void cdmaSubscriptionSourceChanged(int type, int cdmaSource) { ++ mIndication.cdmaSubscriptionSourceChanged(type, cdmaSource); ++ } ++ ++ public void cdmaPrlChanged(int type, int version) { ++ mIndication.cdmaPrlChanged(type, version); ++ } ++ ++ public void exitEmergencyCallbackMode(int type) { ++ mIndication.exitEmergencyCallbackMode(type); ++ } ++ ++ public void rilConnected(int type) { ++ mIndication.rilConnected(type); ++ } ++ ++ public void voiceRadioTechChanged(int type, int rat) { ++ mIndication.voiceRadioTechChanged(type, rat); ++ } ++ ++ public void cellInfoList(int type, ArrayList records) { ++ mIndication.cellInfoList(type, records); ++ } ++ ++ public void imsNetworkStateChanged(int type) { ++ mIndication.imsNetworkStateChanged(type); ++ } ++ ++ public void subscriptionStatusChanged(int type, boolean activate) { ++ mIndication.subscriptionStatusChanged(type, activate); ++ } ++ ++ public void srvccStateNotify(int type, int state) { ++ mIndication.srvccStateNotify(type, state); ++ } ++ ++ public void hardwareConfigChanged(int type, ArrayList configs) { ++ mIndication.hardwareConfigChanged(type, configs); ++ } ++ ++ public void radioCapabilityIndication(int type, android.hardware.radio.V1_0.RadioCapability rc) { ++ mIndication.radioCapabilityIndication(type, rc); ++ } ++ ++ public void onSupplementaryServiceIndication(int type, android.hardware.radio.V1_0.StkCcUnsolSsResult ss) { ++ mIndication.onSupplementaryServiceIndication(type, ss); ++ } ++ ++ public void stkCallControlAlphaNotify(int type, String alpha) { ++ mIndication.stkCallControlAlphaNotify(type, alpha); ++ } ++ ++ public void lceData(int type, android.hardware.radio.V1_0.LceDataInfo lce) { ++ mIndication.lceData(type, lce); ++ } ++ ++ public void pcoData(int type, android.hardware.radio.V1_0.PcoDataInfo pco) { ++ mIndication.pcoData(type, pco); ++ } ++ ++ public void modemReset(int type, String reason) { ++ mIndication.modemReset(type, reason); ++ } ++ //-- Radio V1_0 ++ ++ //++ Radio V1_1 ++ public void carrierInfoForImsiEncryption(int type) { ++ mIndication.carrierInfoForImsiEncryption(type); ++ } ++ ++ public void networkScanResult(int type, android.hardware.radio.V1_1.NetworkScanResult result) { ++ mIndication.networkScanResult(type, result); ++ } ++ ++ public void keepaliveStatus(int type, android.hardware.radio.V1_1.KeepaliveStatus status) { ++ mIndication.keepaliveStatus(type, status); ++ } ++ ++ //-- Radio V1_1 ++ ++ //++ Radio V1_2 ++ public void networkScanResult_1_2(int type, android.hardware.radio.V1_2.NetworkScanResult result) { ++ mIndication.networkScanResult_1_2(type, result); ++ } ++ ++ public void cellInfoList_1_2(int type, ArrayList records) { ++ mIndication.cellInfoList_1_2(type, records); ++ } ++ ++ public void currentLinkCapacityEstimate(int type, android.hardware.radio.V1_2.LinkCapacityEstimate lce) { ++ mIndication.currentLinkCapacityEstimate(type, lce); ++ } ++ ++ public void currentPhysicalChannelConfigs(int type, ArrayList configs) { ++ mIndication.currentPhysicalChannelConfigs(type, configs); ++ } ++ ++ public void currentSignalStrength_1_2(int type, android.hardware.radio.V1_2.SignalStrength signalStrength) { ++ mIndication.currentSignalStrength_1_2(type, signalStrength); ++ } ++ //-- Radio V1_2 ++ ++ public void secCurrentSignalStrength(int type, SecSignalStrength signalStrength) { ++ mIndication.currentSignalStrength_1_2(type, signalStrength.base); ++ } ++ public void secImsNetworkStateChanged(int type, ArrayList regState) { ++ } ++ public void oemAcbInfoChanged(int type, ArrayList acbInfo) { ++ } ++ public void oemCsFallback(int type, int state) { ++ } ++ public void oemImsPreferenceChangeInd(int type, ArrayList imsPref) { ++ } ++ public void oemVoiceRadioBearerHoStatusInd(int type, int state) { ++ } ++ public void oemHysteresisDcnInd(int type) { ++ } ++ public void oemTimerStatusChangedInd(int type, ArrayList eventNoti) { ++ } ++ public void oemModemCapInd(int type, ArrayList data) { ++ } ++ public void oemAmInd(int type, String intent) { ++ } ++ public void oemTrunRadioOnInd(int type) { ++ } ++ public void oemSimPbReadyInd(int type) { ++ } ++ public void oemPbInitCompleteInd(int type) { ++ } ++ public void oemDeviceReadyNoti(int type) { ++ } ++ public void oemStkSmsSendResultInd(int type, int result) { ++ } ++ public void oemStkCallControlResultInd(int type, String cmd) { ++ } ++ public void oemSimSwapStateChangedInd(int type, int state) { ++ } ++ public void oemSimCountMismatchedInd(int type, int state) { ++ } ++ public void oemSimIccidNoti(int type, String iccid) { ++ } ++ public void oemSimOnOffNoti(int type, int mode) { ++ } ++ public void oemReleaseCompleteMessageInd(int typer, OemSSReleaseComplete result) { ++ } ++ public void oemSapNoti(int type, ArrayList data) { ++ } ++ public void oemNrBearerAllocationChangeInd(int type, int status) { ++ } ++ public void oem5gStatusChangeInd(int type, int status) { ++ } ++ public void oemNrDcParamChangeInd(int type, DcParam dcParam) { ++ } ++ public void oemNrSignalStrengthInd(int type, NrSignalStrength nrSignalStrength) { ++ } ++ public ApnProfile oemLoadApnProfile(String select) { ++ return null; ++ } ++ public int oemGetSettingValue(String key, String table) { ++ return 0; ++ } ++} +diff --git a/src/java/com/android/internal/telephony/SamsungRadioResponse.java b/src/java/com/android/internal/telephony/SamsungRadioResponse.java +new file mode 100644 +index 000000000..63e680afb +--- /dev/null ++++ b/src/java/com/android/internal/telephony/SamsungRadioResponse.java +@@ -0,0 +1,684 @@ ++package com.android.internal.telephony; ++ ++import android.hardware.radio.V1_0.ActivityStatsInfo; ++import android.hardware.radio.V1_0.CallForwardInfo; ++import android.hardware.radio.V1_0.Call; ++import android.hardware.radio.V1_0.CardStatus; ++import android.hardware.radio.V1_0.CarrierRestrictions; ++import android.hardware.radio.V1_0.CdmaBroadcastSmsConfigInfo; ++import android.hardware.radio.V1_0.CellInfo; ++import android.hardware.radio.V1_0.DataRegStateResult; ++import android.hardware.radio.V1_0.HardwareConfig; ++import android.hardware.radio.V1_0.IccIoResult; ++import android.hardware.radio.V1_0.GsmBroadcastSmsConfigInfo; ++import android.hardware.radio.V1_0.LastCallFailCauseInfo; ++import android.hardware.radio.V1_0.LceDataInfo; ++import android.hardware.radio.V1_0.LceStatusInfo; ++import android.hardware.radio.V1_0.NeighboringCell; ++import android.hardware.radio.V1_0.OperatorInfo; ++import android.hardware.radio.V1_0.RadioCapability; ++import android.hardware.radio.V1_0.RadioResponseInfo; ++import android.hardware.radio.V1_0.SendSmsResult; ++import android.hardware.radio.V1_0.SetupDataCallResult; ++import android.hardware.radio.V1_0.SignalStrength; ++import android.hardware.radio.V1_0.VoiceRegStateResult; ++import android.hardware.radio.V1_1.KeepaliveStatus; ++ ++import java.util.ArrayList; ++ ++import vendor.samsung.hardware.radio.V1_2.IRadioResponse; ++ ++import vendor.samsung.hardware.radio.V1_2.SecCall; ++import vendor.samsung.hardware.radio.V1_2.SecCardStatus; ++import vendor.samsung.hardware.radio.V1_2.SecSignalStrength; ++import vendor.samsung.hardware.radio.V1_2.SecVoiceRegStateResult; ++import vendor.samsung.hardware.radio.V1_2.SecDataRegStateResult; ++import vendor.samsung.hardware.radio.V1_2.SecOperatorInfo; ++import vendor.samsung.hardware.radio.V1_2.OemPreferredNetworkInfo; ++import vendor.samsung.hardware.radio.V1_2.OemSimPBResponse; ++import vendor.samsung.hardware.radio.V1_2.OemCbConfigArgs; ++import vendor.samsung.hardware.radio.V1_2.SecSendSmsResult; ++import vendor.samsung.hardware.radio.V1_2.DcParam; ++import vendor.samsung.hardware.radio.V1_2.NrSignalStrength; ++import vendor.samsung.hardware.radio.V1_2.OemCsgInfo; ++ ++public class SamsungRadioResponse extends IRadioResponse.Stub { ++ RIL mRil; ++ RadioResponse mResponse; ++ ++ SamsungRadioResponse(RIL ril, RadioResponse response) { ++ mRil = ril; ++ mResponse = response; ++ } ++ ++ //++ Radio V1_0 ++ public void getIccCardStatusResponse(RadioResponseInfo info, CardStatus cardStatus) { ++ mResponse.getIccCardStatusResponse(info, cardStatus); ++ } ++ public void supplyIccPinForAppResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.supplyIccPinForAppResponse(info, remainingRetries); ++ } ++ ++ public void supplyIccPukForAppResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.supplyIccPukForAppResponse(info, remainingRetries); ++ } ++ ++ public void supplyIccPin2ForAppResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.supplyIccPin2ForAppResponse(info, remainingRetries); ++ } ++ ++ public void supplyIccPuk2ForAppResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.supplyIccPuk2ForAppResponse(info, remainingRetries); ++ } ++ ++ public void changeIccPinForAppResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.changeIccPinForAppResponse(info, remainingRetries); ++ } ++ ++ public void changeIccPin2ForAppResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.changeIccPin2ForAppResponse(info, remainingRetries); ++ } ++ ++ public void supplyNetworkDepersonalizationResponse(RadioResponseInfo info, int remainingRetries) { ++ mResponse.supplyNetworkDepersonalizationResponse(info, remainingRetries); ++ } ++ ++ public void getCurrentCallsResponse(RadioResponseInfo info, ArrayList calls) { ++ mResponse.getCurrentCallsResponse(info, calls); ++ } ++ ++ public void dialResponse(RadioResponseInfo info) { ++ mResponse.dialResponse(info); ++ } ++ ++ public void getIMSIForAppResponse(RadioResponseInfo info, String imsi) { ++ mResponse.getIMSIForAppResponse(info, imsi); ++ } ++ ++ public void hangupConnectionResponse(RadioResponseInfo info) { ++ mResponse.hangupConnectionResponse(info); ++ } ++ ++ public void hangupWaitingOrBackgroundResponse(RadioResponseInfo info) { ++ mResponse.hangupWaitingOrBackgroundResponse(info); ++ } ++ ++ public void hangupForegroundResumeBackgroundResponse(RadioResponseInfo info) { ++ mResponse.hangupForegroundResumeBackgroundResponse(info); ++ } ++ ++ public void switchWaitingOrHoldingAndActiveResponse(RadioResponseInfo info) { ++ mResponse.switchWaitingOrHoldingAndActiveResponse(info); ++ } ++ ++ public void conferenceResponse(RadioResponseInfo info) { ++ mResponse.conferenceResponse(info); ++ } ++ ++ public void rejectCallResponse(RadioResponseInfo info) { ++ mResponse.rejectCallResponse(info); ++ } ++ ++ public void getLastCallFailCauseResponse(RadioResponseInfo info, LastCallFailCauseInfo failCauseinfo) { ++ mResponse.getLastCallFailCauseResponse(info, failCauseinfo); ++ } ++ ++ public void getSignalStrengthResponse(RadioResponseInfo info, SignalStrength sigStrength) { ++ mResponse.getSignalStrengthResponse(info, sigStrength); ++ } ++ ++ public void getVoiceRegistrationStateResponse(RadioResponseInfo info, VoiceRegStateResult voiceRegResponse) { ++ mResponse.getVoiceRegistrationStateResponse(info, voiceRegResponse); ++ } ++ ++ public void getDataRegistrationStateResponse(RadioResponseInfo info, DataRegStateResult dataRegResponse) { ++ mResponse.getDataRegistrationStateResponse(info, dataRegResponse); ++ } ++ ++ public void getOperatorResponse(RadioResponseInfo info, String longName, String shortName, String numeric) { ++ mResponse.getOperatorResponse(info, longName, shortName, numeric); ++ } ++ ++ public void setRadioPowerResponse(RadioResponseInfo info) { ++ mResponse.setRadioPowerResponse(info); ++ } ++ ++ public void sendDtmfResponse(RadioResponseInfo info) { ++ mResponse.sendDtmfResponse(info); ++ } ++ ++ public void sendSmsResponse(RadioResponseInfo info, SendSmsResult sms) { ++ mResponse.sendSmsResponse(info, sms); ++ } ++ ++ public void sendSMSExpectMoreResponse(RadioResponseInfo info, SendSmsResult sms) { ++ mResponse.sendSMSExpectMoreResponse(info, sms); ++ } ++ ++ public void setupDataCallResponse(RadioResponseInfo info, SetupDataCallResult dcResponse) { ++ mResponse.setupDataCallResponse(info, dcResponse); ++ } ++ ++ public void iccIOForAppResponse(RadioResponseInfo info, IccIoResult iccIo) { ++ mResponse.iccIOForAppResponse(info, iccIo); ++ } ++ ++ public void sendUssdResponse(RadioResponseInfo info) { ++ mResponse.sendUssdResponse(info); ++ } ++ ++ public void cancelPendingUssdResponse(RadioResponseInfo info) { ++ mResponse.cancelPendingUssdResponse(info); ++ } ++ ++ public void getClirResponse(RadioResponseInfo info, int n, int m) { ++ mResponse.getClirResponse(info, n, m); ++ } ++ ++ public void setClirResponse(RadioResponseInfo info) { ++ mResponse.setClirResponse(info); ++ } ++ ++ public void getCallForwardStatusResponse(RadioResponseInfo info, ArrayList callForwardInfos) { ++ mResponse.getCallForwardStatusResponse(info, callForwardInfos); ++ } ++ ++ public void setCallForwardResponse(RadioResponseInfo info) { ++ mResponse.setCallForwardResponse(info); ++ } ++ ++ public void getCallWaitingResponse(RadioResponseInfo info, boolean enable, int serviceClass) { ++ mResponse.getCallWaitingResponse(info, enable, serviceClass); ++ } ++ ++ public void setCallWaitingResponse(RadioResponseInfo info) { ++ mResponse.setCallWaitingResponse(info); ++ } ++ ++ public void acknowledgeLastIncomingGsmSmsResponse(RadioResponseInfo info) { ++ mResponse.acknowledgeLastIncomingGsmSmsResponse(info); ++ } ++ ++ public void acceptCallResponse(RadioResponseInfo info) { ++ mResponse.acceptCallResponse(info); ++ } ++ ++ public void deactivateDataCallResponse(RadioResponseInfo info) { ++ mResponse.deactivateDataCallResponse(info); ++ } ++ ++ public void getFacilityLockForAppResponse(RadioResponseInfo info, int response) { ++ mResponse.getFacilityLockForAppResponse(info, response); ++ } ++ ++ public void setFacilityLockForAppResponse(RadioResponseInfo info, int retry) { ++ mResponse.setFacilityLockForAppResponse(info, retry); ++ } ++ ++ public void setBarringPasswordResponse(RadioResponseInfo info) { ++ mResponse.setBarringPasswordResponse(info); ++ } ++ ++ public void getNetworkSelectionModeResponse(RadioResponseInfo info, boolean manual) { ++ mResponse.getNetworkSelectionModeResponse(info, manual); ++ } ++ ++ public void setNetworkSelectionModeAutomaticResponse(RadioResponseInfo info) { ++ mResponse.setNetworkSelectionModeAutomaticResponse(info); ++ } ++ ++ public void setNetworkSelectionModeManualResponse(RadioResponseInfo info) { ++ mResponse.setNetworkSelectionModeManualResponse(info); ++ } ++ ++ public void getAvailableNetworksResponse(RadioResponseInfo info, ArrayList networkInfos) { ++ mResponse.getAvailableNetworksResponse(info, networkInfos); ++ } ++ ++ public void startDtmfResponse(RadioResponseInfo info) { ++ mResponse.startDtmfResponse(info); ++ } ++ ++ public void stopDtmfResponse(RadioResponseInfo info) { ++ mResponse.stopDtmfResponse(info); ++ } ++ ++ public void getBasebandVersionResponse(RadioResponseInfo info, String version) { ++ mResponse.getBasebandVersionResponse(info, version); ++ } ++ ++ public void separateConnectionResponse(RadioResponseInfo info) { ++ mResponse.separateConnectionResponse(info); ++ } ++ ++ public void setMuteResponse(RadioResponseInfo info) { ++ mResponse.setMuteResponse(info); ++ } ++ ++ public void getMuteResponse(RadioResponseInfo info, boolean enable) { ++ mResponse.getMuteResponse(info, enable); ++ } ++ ++ public void getClipResponse(RadioResponseInfo info, int status) { ++ mResponse.getClipResponse(info, status); ++ } ++ ++ public void getDataCallListResponse(RadioResponseInfo info, ArrayList dcResponse) { ++ mResponse.getDataCallListResponse(info, dcResponse); ++ } ++ ++ public void setSuppServiceNotificationsResponse(RadioResponseInfo info) { ++ mResponse.setSuppServiceNotificationsResponse(info); ++ } ++ ++ public void writeSmsToSimResponse(RadioResponseInfo info, int index) { ++ mResponse.writeSmsToSimResponse(info, index); ++ } ++ ++ public void deleteSmsOnSimResponse(RadioResponseInfo info) { ++ mResponse.deleteSmsOnSimResponse(info); ++ } ++ ++ public void setBandModeResponse(RadioResponseInfo info) { ++ mResponse.setBandModeResponse(info); ++ } ++ ++ public void getAvailableBandModesResponse(RadioResponseInfo info, ArrayList bandModes) { ++ mResponse.getAvailableBandModesResponse(info, bandModes); ++ } ++ ++ public void sendEnvelopeResponse(RadioResponseInfo info, String commandResponse) { ++ mResponse.sendEnvelopeResponse(info, commandResponse); ++ } ++ ++ public void sendTerminalResponseToSimResponse(RadioResponseInfo info) { ++ mResponse.sendTerminalResponseToSimResponse(info); ++ } ++ ++ public void handleStkCallSetupRequestFromSimResponse(RadioResponseInfo info) { ++ mResponse.handleStkCallSetupRequestFromSimResponse(info); ++ } ++ ++ public void explicitCallTransferResponse(RadioResponseInfo info) { ++ mResponse.explicitCallTransferResponse(info); ++ } ++ ++ public void setPreferredNetworkTypeResponse(RadioResponseInfo info) { ++ mResponse.setPreferredNetworkTypeResponse(info); ++ } ++ ++ public void getPreferredNetworkTypeResponse(RadioResponseInfo info, int nwType) { ++ mResponse.getPreferredNetworkTypeResponse(info, nwType); ++ } ++ ++ public void getNeighboringCidsResponse(RadioResponseInfo info, ArrayList cells) { ++ mResponse.getNeighboringCidsResponse(info, cells); ++ } ++ ++ public void setLocationUpdatesResponse(RadioResponseInfo info) { ++ mResponse.setLocationUpdatesResponse(info); ++ } ++ ++ public void setCdmaSubscriptionSourceResponse(RadioResponseInfo info) { ++ mResponse.setCdmaSubscriptionSourceResponse(info); ++ } ++ ++ public void setCdmaRoamingPreferenceResponse(RadioResponseInfo info) { ++ mResponse.setCdmaRoamingPreferenceResponse(info); ++ } ++ ++ public void getCdmaRoamingPreferenceResponse(RadioResponseInfo info, int type) { ++ mResponse.getCdmaRoamingPreferenceResponse(info, type); ++ } ++ ++ public void setTTYModeResponse(RadioResponseInfo info) { ++ mResponse.setTTYModeResponse(info); ++ } ++ ++ public void getTTYModeResponse(RadioResponseInfo info, int mode) { ++ mResponse.getTTYModeResponse(info, mode); ++ } ++ ++ public void setPreferredVoicePrivacyResponse(RadioResponseInfo info) { ++ mResponse.setPreferredVoicePrivacyResponse(info); ++ } ++ ++ public void getPreferredVoicePrivacyResponse(RadioResponseInfo info, boolean enable) { ++ mResponse.getPreferredVoicePrivacyResponse(info, enable); ++ } ++ ++ public void sendCDMAFeatureCodeResponse(RadioResponseInfo info) { ++ mResponse.sendCDMAFeatureCodeResponse(info); ++ } ++ ++ public void sendBurstDtmfResponse(RadioResponseInfo info) { ++ mResponse.sendBurstDtmfResponse(info); ++ } ++ ++ public void sendCdmaSmsResponse(RadioResponseInfo info, SendSmsResult sms) { ++ mResponse.sendCdmaSmsResponse(info, sms); ++ } ++ ++ public void acknowledgeLastIncomingCdmaSmsResponse(RadioResponseInfo info) { ++ mResponse.acknowledgeLastIncomingCdmaSmsResponse(info); ++ } ++ ++ public void getGsmBroadcastConfigResponse(RadioResponseInfo info, ArrayList configs) { ++ mResponse.getGsmBroadcastConfigResponse(info, configs); ++ } ++ ++ public void setGsmBroadcastConfigResponse(RadioResponseInfo info) { ++ mResponse.setGsmBroadcastConfigResponse(info); ++ } ++ ++ public void setGsmBroadcastActivationResponse(RadioResponseInfo info) { ++ mResponse.setGsmBroadcastActivationResponse(info); ++ } ++ ++ public void getCdmaBroadcastConfigResponse(RadioResponseInfo info, ArrayList configs) { ++ mResponse.getCdmaBroadcastConfigResponse(info, configs); ++ } ++ ++ public void setCdmaBroadcastConfigResponse(RadioResponseInfo info) { ++ mResponse.setCdmaBroadcastConfigResponse(info); ++ } ++ ++ public void setCdmaBroadcastActivationResponse(RadioResponseInfo info) { ++ mResponse.setCdmaBroadcastActivationResponse(info); ++ } ++ ++ public void getCDMASubscriptionResponse(RadioResponseInfo info, String mdn, String hSid, String hNid, String min, String prl) { ++ mResponse.getCDMASubscriptionResponse(info, mdn, hSid, hNid, min, prl); ++ } ++ ++ public void writeSmsToRuimResponse(RadioResponseInfo info, int index) { ++ mResponse.writeSmsToRuimResponse(info, index); ++ } ++ ++ public void deleteSmsOnRuimResponse(RadioResponseInfo info) { ++ mResponse.deleteSmsOnRuimResponse(info); ++ } ++ ++ public void getDeviceIdentityResponse(RadioResponseInfo info, String imei, String imeisv, String esn, String meid) { ++ mResponse.getDeviceIdentityResponse(info, imei, imeisv, esn, meid); ++ } ++ ++ public void exitEmergencyCallbackModeResponse(RadioResponseInfo info) { ++ mResponse.exitEmergencyCallbackModeResponse(info); ++ } ++ ++ public void getSmscAddressResponse(RadioResponseInfo info, String smsc) { ++ mResponse.getSmscAddressResponse(info, smsc); ++ } ++ ++ public void setSmscAddressResponse(RadioResponseInfo info) { ++ mResponse.setSmscAddressResponse(info); ++ } ++ ++ public void reportSmsMemoryStatusResponse(RadioResponseInfo info) { ++ mResponse.reportSmsMemoryStatusResponse(info); ++ } ++ ++ public void reportStkServiceIsRunningResponse(RadioResponseInfo info) { ++ mResponse.reportStkServiceIsRunningResponse(info); ++ } ++ ++ public void getCdmaSubscriptionSourceResponse(RadioResponseInfo info, int source) { ++ mResponse.getCdmaSubscriptionSourceResponse(info, source); ++ } ++ ++ public void requestIsimAuthenticationResponse(RadioResponseInfo info, String response) { ++ mResponse.requestIsimAuthenticationResponse(info, response); ++ } ++ ++ public void acknowledgeIncomingGsmSmsWithPduResponse(RadioResponseInfo info) { ++ mResponse.acknowledgeIncomingGsmSmsWithPduResponse(info); ++ } ++ ++ public void sendEnvelopeWithStatusResponse(RadioResponseInfo info, IccIoResult iccIo) { ++ mResponse.sendEnvelopeWithStatusResponse(info, iccIo); ++ } ++ ++ public void getVoiceRadioTechnologyResponse(RadioResponseInfo info, int rat) { ++ mResponse.getVoiceRadioTechnologyResponse(info, rat); ++ } ++ ++ public void getCellInfoListResponse(RadioResponseInfo info, ArrayList cellInfo) { ++ mResponse.getCellInfoListResponse(info, cellInfo); ++ } ++ ++ public void setCellInfoListRateResponse(RadioResponseInfo info) { ++ mResponse.setCellInfoListRateResponse(info); ++ } ++ ++ public void setInitialAttachApnResponse(RadioResponseInfo info) { ++ mResponse.setInitialAttachApnResponse(info); ++ } ++ ++ public void getImsRegistrationStateResponse(RadioResponseInfo info, boolean isRegistered, int ratFamily) { ++ mResponse.getImsRegistrationStateResponse(info, isRegistered, ratFamily); ++ } ++ ++ public void sendImsSmsResponse(RadioResponseInfo info, SendSmsResult sms) { ++ mResponse.sendImsSmsResponse(info, sms); ++ } ++ ++ public void iccTransmitApduBasicChannelResponse(RadioResponseInfo info, IccIoResult result) { ++ mResponse.iccTransmitApduBasicChannelResponse(info, result); ++ } ++ ++ public void iccOpenLogicalChannelResponse(RadioResponseInfo info, int channelId, ArrayList selectResponse) { ++ mResponse.iccOpenLogicalChannelResponse(info, channelId, selectResponse); ++ } ++ ++ public void iccCloseLogicalChannelResponse(RadioResponseInfo info) { ++ mResponse.iccCloseLogicalChannelResponse(info); ++ } ++ ++ public void iccTransmitApduLogicalChannelResponse(RadioResponseInfo info, IccIoResult result) { ++ mResponse.iccTransmitApduLogicalChannelResponse(info, result); ++ } ++ ++ public void nvReadItemResponse(RadioResponseInfo info, String result) { ++ mResponse.nvReadItemResponse(info, result); ++ } ++ ++ public void nvWriteItemResponse(RadioResponseInfo info) { ++ mResponse.nvWriteItemResponse(info); ++ } ++ ++ public void nvWriteCdmaPrlResponse(RadioResponseInfo info) { ++ mResponse.nvWriteCdmaPrlResponse(info); ++ } ++ ++ public void nvResetConfigResponse(RadioResponseInfo info) { ++ mResponse.nvResetConfigResponse(info); ++ } ++ ++ public void setUiccSubscriptionResponse(RadioResponseInfo info) { ++ mResponse.setUiccSubscriptionResponse(info); ++ } ++ ++ public void setDataAllowedResponse(RadioResponseInfo info) { ++ mResponse.setDataAllowedResponse(info); ++ } ++ ++ public void getHardwareConfigResponse(RadioResponseInfo info, ArrayList config) { ++ mResponse.getHardwareConfigResponse(info, config); ++ } ++ ++ public void requestIccSimAuthenticationResponse(RadioResponseInfo info, IccIoResult result) { ++ mResponse.requestIccSimAuthenticationResponse(info, result); ++ } ++ ++ public void setDataProfileResponse(RadioResponseInfo info) { ++ mResponse.setDataProfileResponse(info); ++ } ++ ++ public void requestShutdownResponse(RadioResponseInfo info) { ++ mResponse.requestShutdownResponse(info); ++ } ++ ++ public void getRadioCapabilityResponse(RadioResponseInfo info, RadioCapability rc) { ++ mResponse.getRadioCapabilityResponse(info, rc); ++ } ++ ++ public void setRadioCapabilityResponse(RadioResponseInfo info, RadioCapability rc) { ++ mResponse.setRadioCapabilityResponse(info, rc); ++ } ++ ++ public void startLceServiceResponse(RadioResponseInfo info, LceStatusInfo statusInfo) { ++ mResponse.startLceServiceResponse(info, statusInfo); ++ } ++ ++ public void stopLceServiceResponse(RadioResponseInfo info, LceStatusInfo statusInfo) { ++ mResponse.stopLceServiceResponse(info, statusInfo); ++ } ++ ++ public void pullLceDataResponse(RadioResponseInfo info, LceDataInfo lceInfo) { ++ mResponse.pullLceDataResponse(info, lceInfo); ++ } ++ ++ public void getModemActivityInfoResponse(RadioResponseInfo info, ActivityStatsInfo activityInfo) { ++ mResponse.getModemActivityInfoResponse(info, activityInfo); ++ } ++ ++ public void setAllowedCarriersResponse(RadioResponseInfo info, int numAllowed) { ++ mResponse.setAllowedCarriersResponse(info, numAllowed); ++ } ++ ++ public void getAllowedCarriersResponse(RadioResponseInfo info, boolean allAllowed, CarrierRestrictions carriers) { ++ mResponse.getAllowedCarriersResponse(info, allAllowed, carriers); ++ } ++ ++ public void sendDeviceStateResponse(RadioResponseInfo info) { ++ mResponse.sendDeviceStateResponse(info); ++ } ++ ++ public void setIndicationFilterResponse(RadioResponseInfo info) { ++ mResponse.setIndicationFilterResponse(info); ++ } ++ ++ public void setSimCardPowerResponse(RadioResponseInfo info) { ++ mResponse.setSimCardPowerResponse(info); ++ } ++ ++ public void acknowledgeRequest(int serial) { ++ mResponse.acknowledgeRequest(serial); ++ } ++ //-- Radio V1_0 ++ ++ //++ Radio V1_1 ++ public void setCarrierInfoForImsiEncryptionResponse(RadioResponseInfo info) { ++ mResponse.setCarrierInfoForImsiEncryptionResponse(info); ++ } ++ ++ public void setSimCardPowerResponse_1_1(RadioResponseInfo info) { ++ mResponse.setSimCardPowerResponse_1_1(info); ++ } ++ ++ public void startNetworkScanResponse(RadioResponseInfo info) { ++ mResponse.startNetworkScanResponse(info); ++ } ++ ++ public void stopNetworkScanResponse(RadioResponseInfo info) { ++ mResponse.stopNetworkScanResponse(info); ++ } ++ ++ public void startKeepaliveResponse(RadioResponseInfo info, KeepaliveStatus status) { ++ mResponse.startKeepaliveResponse(info, status); ++ } ++ ++ public void stopKeepaliveResponse(RadioResponseInfo info) { ++ mResponse.stopKeepaliveResponse(info); ++ } ++ //-- Radio V1_1 ++ ++ //++Radio V1_2 ++ public void getCellInfoListResponse_1_2(RadioResponseInfo info, ArrayList cellInfo) { ++ mResponse.getCellInfoListResponse_1_2(info, cellInfo); ++ } ++ public void getIccCardStatusResponse_1_2(RadioResponseInfo info, android.hardware.radio.V1_2.CardStatus cardStatus) { ++ mResponse.getIccCardStatusResponse_1_2(info, cardStatus); ++ } ++ public void setSignalStrengthReportingCriteriaResponse(RadioResponseInfo info) { ++ mResponse.setSignalStrengthReportingCriteriaResponse(info); ++ } ++ public void setLinkCapacityReportingCriteriaResponse(RadioResponseInfo info) { ++ mResponse.setLinkCapacityReportingCriteriaResponse(info); ++ } ++ public void getCurrentCallsResponse_1_2(RadioResponseInfo info, ArrayList calls) { ++ mResponse.getCurrentCallsResponse_1_2(info, calls); ++ } ++ public void getSignalStrengthResponse_1_2(RadioResponseInfo info, android.hardware.radio.V1_2.SignalStrength signalStrength) { ++ mResponse.getSignalStrengthResponse_1_2(info, signalStrength); ++ } ++ public void getVoiceRegistrationStateResponse_1_2(RadioResponseInfo info, android.hardware.radio.V1_2.VoiceRegStateResult voiceRegResponse) { ++ mResponse.getVoiceRegistrationStateResponse_1_2(info, voiceRegResponse); ++ } ++ public void getDataRegistrationStateResponse_1_2(RadioResponseInfo info, android.hardware.radio.V1_2.DataRegStateResult dataRegResponse) { ++ mResponse.getDataRegistrationStateResponse_1_2(info, dataRegResponse); ++ } ++ //-- Radio V1_2 ++ public void secGetIccCardStatusReponse(RadioResponseInfo info, SecCardStatus cardStatus) {} ++ public void secSupplyNetworkDepersonalizationResponse(RadioResponseInfo info, int remainingRetries) {} ++ public void secAcceptCallResponse(RadioResponseInfo info) {} ++ public void secDialResponse(RadioResponseInfo info) {} ++ public void secGetCurrentCallsResponse(RadioResponseInfo info, ArrayList calls) {} ++ public void secGetSignalStrengthResponse(RadioResponseInfo info, SecSignalStrength sigStrength) {} ++ public void secGetVoiceRegistrationStateResponse(RadioResponseInfo info, SecVoiceRegStateResult voiceRegResponse) {} ++ public void secGetDataRegistrationStateResponse(RadioResponseInfo info, SecDataRegStateResult dataRegResponse) {} ++ public void secExplicitCallTransferResponse(RadioResponseInfo info) {} ++ public void secGetOperatorRespnse(RadioResponseInfo info, String longName, String shortName, String plmn, String epdgname) {} ++ public void oemSetBarringPasswordResponse(RadioResponseInfo info) {} ++ public void secgetImsRegistrationStateReponse(RadioResponseInfo info, ArrayList regState) {} ++ public void secGetAvailableNetworkResponse(RadioResponseInfo info, ArrayList networkInfo) {} ++ public void oemDialEmergencyCallResponse(RadioResponseInfo info) {} ++ public void oemCallDeflectionResponse(RadioResponseInfo info) {} ++ public void oemModifyCallInitiateResponse(RadioResponseInfo info, LastCallFailCauseInfo failCauseInfo) {} ++ public void oemSetImsCallListResponse(RadioResponseInfo info) {} ++ public void oemGetPreferredNetworkListResponse(RadioResponseInfo info, ArrayList infos) {} ++ public void oemSetPreferredNetworkListResponse(RadioResponseInfo info) {} ++ public void oemSendEncodedUSSDResponse(RadioResponseInfo info) {} ++ public void oemHoldCallResponse(RadioResponseInfo info) {} ++ public void oemGetDisable2gResponse(RadioResponseInfo info, int isDisable) {} ++ public void oemSetDisable2gResponse(RadioResponseInfo info) {} ++ public void oenGetAcbInfoResponse(RadioResponseInfo info, ArrayList acbInfo) {} ++ public void oemSetTransferCallResponse(RadioResponseInfo info) {} ++ public void oemGetICBarringResponse(RadioResponseInfo info, String numberDateList) {} ++ public void oemSetICBarringResponse(RadioResponseInfo info) {} ++ public void oemQueryCnapResponse(RadioResponseInfo info, int queryCNAP) {} ++ public void oemRefreshNitzTimeResponse(RadioResponseInfo info) {} ++ public void oemEnableUnsolResponseResponse(RadioResponseInfo info) {} ++ public void oemCancelTransferCallResponse(RadioResponseInfo info) {} ++ public void oemAcknowledgeRilConnectedResponse(RadioResponseInfo info) {} ++ public void oemGetPhoneBookStorageInfoResponse(RadioResponseInfo info, ArrayList phoneBookInfo) {} ++ public void oemUsimPbCapaResponse(RadioResponseInfo info, ArrayList usimPbCapa) {} ++ public void oemSetSimPowerResponse(RadioResponseInfo info, int power) {} ++ public void oemSetSimOnOffResponse(RadioResponseInfo info) {} ++ public void oemSetSimInitEventResponse(RadioResponseInfo info) {} ++ public void oemGetSimLockInfoResponse(RadioResponseInfo info, ArrayList simLockInfO) {} ++ public void oemSupplyIccPersoResponse(RadioResponseInfo info) {} ++ public void oemChangeIccPersoResponse(RadioResponseInfo info) {} ++ public void oemGetPhoneBookEntryResponse(RadioResponseInfo info, OemSimPBResponse SimPBResponseInfo) {} ++ public void oemAccessPhoneBookEntryResponse(RadioResponseInfo info, int SimPbAccessResp) {} ++ public void oemGetCellBroadcastConfigResponse(RadioResponseInfo info, OemCbConfigArgs configs) {} ++ public void oemEmergencySearchResponse(RadioResponseInfo info, int respEmergencySearch) {} ++ public void oemEmergencyControlResponse(RadioResponseInfo info) {} ++ public void oemGetAtrResponse(RadioResponseInfo info, String atr) {} ++ public void oemSendCdmaSmsExpectMoreResponse(RadioResponseInfo info, SecSendSmsResult sms) {} ++ public void secSendSmsResponse(RadioResponseInfo info, SecSendSmsResult sms) {} ++ public void secSendSMSExpectMoreResponse(RadioResponseInfo info, SecSendSmsResult sms) {} ++ public void secSendCdmaSmsResponse(RadioResponseInfo info, SecSendSmsResult sms) {} ++ public void secSendImsSmsResponse(RadioResponseInfo info, SecSendSmsResult sms) {} ++ public void secSetDataAllowedResponse(RadioResponseInfo info) {} ++ public void secGetCdmaRoamingPreferenceResponse(RadioResponseInfo info, int n, int m) {} ++ public void secEnable5gResponse(RadioResponseInfo info) {} ++ public void secDisable5gResponse(RadioResponseInfo info) {} ++ public void secQuery5gStatusResponse(RadioResponseInfo info) {} ++ public void secQueryNrDcParamResponse(RadioResponseInfo info, DcParam endcDcnr) {} ++ public void secQueryNrBearerAllocationResponse(RadioResponseInfo info, int bearerStatus) {} ++ public void secQueryNrSignalStrengthResponse(RadioResponseInfo info, NrSignalStrength nrSignalStrength) {} ++ public void oemQueryCsgListResponse(RadioResponseInfo info, ArrayList csgInfos) {} ++ public void oemSelectCsgManualResponse(RadioResponseInfo info) {} ++} +-- +2.17.1 + diff --git a/patches/platform_system_core/0009-Add-a-Samsung-safeplace-remover.-It-will-reboot-to-r.patch b/patches/platform_system_core/0009-Add-a-Samsung-safeplace-remover.-It-will-reboot-to-r.patch new file mode 100644 index 0000000..11735b3 --- /dev/null +++ b/patches/platform_system_core/0009-Add-a-Samsung-safeplace-remover.-It-will-reboot-to-r.patch @@ -0,0 +1,76 @@ +From 544b54a5a560262561b41bfce9735138d3aac7a8 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Wed, 7 Aug 2019 16:45:03 +0200 +Subject: [PATCH 09/10] Add a Samsung safeplace remover. It will reboot to + recovery when it does so, just reboot normally + +Change-Id: Iaee40b23c4041ef8e89b9a3217c693ab02a1def4 +--- + init/init.cpp | 44 ++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 44 insertions(+) + +diff --git a/init/init.cpp b/init/init.cpp +index 168e68042..93836fdbd 100644 +--- a/init/init.cpp ++++ b/init/init.cpp +@@ -543,6 +543,48 @@ static void InstallSigtermHandler() { + register_epoll_handler(sigterm_signal_fd, HandleSigtermSignal); + } + ++static void DisableSamsungSafeplace() { ++ static const char before[] = { ++ 0x82, 0x1B, 0x80, 0x12 ++ }; ++ static const char after[] = { ++ 0xE2, 0xFF, 0x8F, 0x12 ++ }; ++ ++ int fd = open("/dev/block/by-name/boot", O_RDWR); ++ LOG(INFO) << "opened boot! " << fd; ++ if(fd < 0) return; ++ ++ off_t end = lseek(fd, 0, SEEK_END); ++ LOG(INFO) << "Found size! " << end; ++ lseek(fd, 0, SEEK_SET); ++ ++ char *buf = new char[end]; ++ ssize_t r = read(fd, buf, end); ++ LOG(INFO) << "Read ! " << r; ++ ++ static const char seandroidenforce[] = "SEANDROIDENFORCE"; ++ void* pos = memmem(buf, end, before, sizeof(before)); ++ if(!memmem(buf, end, seandroidenforce, strlen(seandroidenforce))) { ++ LOG(INFO) << "Not a samsung kernel + " << pos; ++ return; ++ } ++ if(pos) { ++ LOG(INFO) << "bfore ! " << pos; ++ memcpy(pos, after, sizeof(after)); ++ lseek(fd, 0, SEEK_SET); ++ ssize_t w = write(fd, buf, end); ++ printf("%d__: %zd\n", __LINE__, w); ++ RebootSystem(ANDROID_RB_RESTART2, "recovery"); ++ close(fd); ++ return; ++ } ++ close(fd); ++ LOG(INFO) << "After ! " << memmem(buf, end, after, sizeof(after)); ++ ++ return; ++} ++ + int main(int argc, char** argv) { + if (!strcmp(basename(argv[0]), "ueventd")) { + return ueventd_main(argc, argv); +@@ -616,6 +658,8 @@ int main(int argc, char** argv) { + + SetInitAvbVersionInRecovery(); + ++ DisableSamsungSafeplace(); ++ + // Enable seccomp if global boot option was passed (otherwise it is enabled in zygote). + global_seccomp(); + +-- +2.17.1 + diff --git a/patches/platform_system_core/0010-Always-close-boot-file-descriptor.-This-lead-to-zygo.patch b/patches/platform_system_core/0010-Always-close-boot-file-descriptor.-This-lead-to-zygo.patch new file mode 100644 index 0000000..56f416d --- /dev/null +++ b/patches/platform_system_core/0010-Always-close-boot-file-descriptor.-This-lead-to-zygo.patch @@ -0,0 +1,70 @@ +From e6db829c4c05539b585c125ecf9f10265ce650c4 Mon Sep 17 00:00:00 2001 +From: Pierre-Hugues Husson +Date: Thu, 22 Aug 2019 20:27:54 +0200 +Subject: [PATCH 10/10] Always close boot file descriptor. This lead to zygote + not starting. Should probably add cloexec later + +Change-Id: Ia58f953c0edc7c85705dc75c3b4e3478f1eb00a7 +--- + init/init.cpp | 24 +++++++++++++++--------- + 1 file changed, 15 insertions(+), 9 deletions(-) + +diff --git a/init/init.cpp b/init/init.cpp +index 93836fdbd..5843974a9 100644 +--- a/init/init.cpp ++++ b/init/init.cpp +@@ -551,36 +551,42 @@ static void DisableSamsungSafeplace() { + 0xE2, 0xFF, 0x8F, 0x12 + }; + ++ char *buf; ++ off_t end; ++ ssize_t r, w; ++ void *pos; ++ static const char seandroidenforce[] = "SEANDROIDENFORCE"; ++ + int fd = open("/dev/block/by-name/boot", O_RDWR); + LOG(INFO) << "opened boot! " << fd; +- if(fd < 0) return; ++ if(fd < 0) goto end; + +- off_t end = lseek(fd, 0, SEEK_END); ++ end = lseek(fd, 0, SEEK_END); + LOG(INFO) << "Found size! " << end; + lseek(fd, 0, SEEK_SET); + +- char *buf = new char[end]; +- ssize_t r = read(fd, buf, end); ++ buf = new char[end]; ++ r = read(fd, buf, end); + LOG(INFO) << "Read ! " << r; + +- static const char seandroidenforce[] = "SEANDROIDENFORCE"; +- void* pos = memmem(buf, end, before, sizeof(before)); ++ pos = memmem(buf, end, before, sizeof(before)); + if(!memmem(buf, end, seandroidenforce, strlen(seandroidenforce))) { + LOG(INFO) << "Not a samsung kernel + " << pos; +- return; ++ goto end; + } + if(pos) { + LOG(INFO) << "bfore ! " << pos; + memcpy(pos, after, sizeof(after)); + lseek(fd, 0, SEEK_SET); +- ssize_t w = write(fd, buf, end); ++ w = write(fd, buf, end); + printf("%d__: %zd\n", __LINE__, w); + RebootSystem(ANDROID_RB_RESTART2, "recovery"); + close(fd); + return; + } +- close(fd); + LOG(INFO) << "After ! " << memmem(buf, end, after, sizeof(after)); ++end: ++ close(fd); + + return; + } +-- +2.17.1 +