From 03a2bc3b7b5b10b305ff849eaf535ea52bcd857d Mon Sep 17 00:00:00 2001
From: jhenrique09 <jhenrique09.mcz@hotmail.com>
Date: Mon, 15 Jun 2020 15:48:07 -0300
Subject: [PATCH] Initial import of lineagehw

All credits to LineageOS and related authors on:

https://github.com/LineageOS/android_lineage-sdk

Signed-off-by: Henrique Silva <jhenrique09.mcz@hotmail.com>
Change-Id: Ief90ce8c20115d6a1c17c84a9874af6246dc1dcd
---

diff --git a/core/java/com/android/internal/lineage/app/LineageContextConstants.java b/core/java/com/android/internal/lineage/app/LineageContextConstants.java
new file mode 100644
index 0000000..a207223
--- /dev/null
+++ b/core/java/com/android/internal/lineage/app/LineageContextConstants.java
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2015, The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.lineage.app;
+
+import android.annotation.SdkConstant;
+
+/**
+ * @hide
+ * TODO: We need to somehow make these managers accessible via getSystemService
+ */
+public final class LineageContextConstants {
+
+    /**
+     * @hide
+     */
+    private LineageContextConstants() {
+        // Empty constructor
+    }
+
+    /**
+     * Use with {@link android.content.Context#getSystemService} to retrieve a
+     * {@link com.android.internal.lineage.LineageHardwareManager} to manage the extended
+     * hardware features of the device.
+     *
+     * @see android.content.Context#getSystemService
+     * @see com.android.internal.lineage.LineageHardwareManager
+     *
+     * @hide
+     */
+    public static final String LINEAGE_HARDWARE_SERVICE = "lineagehardware";
+
+}
diff --git a/core/java/com/android/internal/lineage/hardware/HIDLHelper.java b/core/java/com/android/internal/lineage/hardware/HIDLHelper.java
new file mode 100644
index 0000000..ab62841
--- /dev/null
+++ b/core/java/com/android/internal/lineage/hardware/HIDLHelper.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.lineage.hardware;
+
+import java.util.ArrayList;
+
+class HIDLHelper {
+}
diff --git a/core/java/com/android/internal/lineage/hardware/ILineageHardwareService.aidl b/core/java/com/android/internal/lineage/hardware/ILineageHardwareService.aidl
new file mode 100644
index 0000000..23d88cf
--- /dev/null
+++ b/core/java/com/android/internal/lineage/hardware/ILineageHardwareService.aidl
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015-2016 The CyanogenMod Project
+ *               2017-2018 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.lineage.hardware;
+
+/** @hide */
+interface ILineageHardwareService {
+    int getSupportedFeatures();
+    boolean get(int feature);
+    boolean set(int feature, boolean enable);
+}
diff --git a/core/java/com/android/internal/lineage/hardware/LineageHardwareManager.java b/core/java/com/android/internal/lineage/hardware/LineageHardwareManager.java
new file mode 100644
index 0000000..ab57f73
--- /dev/null
+++ b/core/java/com/android/internal/lineage/hardware/LineageHardwareManager.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2015-2016 The CyanogenMod Project
+ *               2017-2019 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.internal.lineage.hardware;
+
+import android.content.Context;
+import android.hidl.base.V1_0.IBase;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.util.Log;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+import com.android.internal.lineage.app.LineageContextConstants;
+import com.android.internal.lineage.hardware.HIDLHelper;
+
+import java.lang.IllegalArgumentException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/**
+ * Manages access to LineageOS hardware extensions
+ *
+ *  <p>
+ *  This manager requires the HARDWARE_ABSTRACTION_ACCESS permission.
+ *  <p>
+ *  To get the instance of this class, utilize LineageHardwareManager#getInstance(Context context)
+ */
+public final class LineageHardwareManager {
+    private static final String TAG = "LineageHardwareManager";
+
+    // The VisibleForTesting annotation is to ensure Proguard doesn't remove these
+    // fields, as they might be used via reflection. When the @Keep annotation in
+    // the support library is properly handled in the platform, we should change this.
+
+    private static final List<Integer> BOOLEAN_FEATURES = Arrays.asList(
+    );
+
+    private static ILineageHardwareService sService;
+    private static LineageHardwareManager sLineageHardwareManagerInstance;
+
+    private Context mContext;
+
+    // HIDL hals
+    private HashMap<Integer, IBase> mHIDLMap = new HashMap<Integer, IBase>();
+
+    /**
+     * @hide to prevent subclassing from outside of the framework
+     */
+    private LineageHardwareManager(Context context) {
+        Context appContext = context.getApplicationContext();
+        if (appContext != null) {
+            mContext = appContext;
+        } else {
+            mContext = context;
+        }
+        sService = getService();
+
+        if (!checkService()) {
+            Log.wtf(TAG, "Unable to get LineageHardwareService. The service either" +
+                    " crashed, was not started, or the interface has been called to early in" +
+                    " SystemServer init");
+        }
+    }
+
+    /**
+     * Get or create an instance of the {@link com.android.internal.lineage.hardware.LineageHardwareManager}
+     * @param context
+     * @return {@link LineageHardwareManager}
+     */
+    public static LineageHardwareManager getInstance(Context context) {
+        if (sLineageHardwareManagerInstance == null) {
+            sLineageHardwareManagerInstance = new LineageHardwareManager(context);
+        }
+        return sLineageHardwareManagerInstance;
+    }
+
+    /** @hide */
+    public static ILineageHardwareService getService() {
+        if (sService != null) {
+            return sService;
+        }
+        IBinder b = ServiceManager.getService(LineageContextConstants.LINEAGE_HARDWARE_SERVICE);
+        if (b != null) {
+            sService = ILineageHardwareService.Stub.asInterface(b);
+            return sService;
+        }
+        return null;
+    }
+
+    /**
+     * Determine if a Lineage Hardware feature is supported on this device
+     *
+     * @param feature The Lineage Hardware feature to query
+     *
+     * @return true if the feature is supported, false otherwise.
+     */
+    public boolean isSupported(int feature) {
+        return isSupportedHIDL(feature) || isSupportedLegacy(feature);
+    }
+
+    private boolean isSupportedHIDL(int feature) {
+        if (!mHIDLMap.containsKey(feature)) {
+            mHIDLMap.put(feature, getHIDLService(feature));
+        }
+        return mHIDLMap.get(feature) != null;
+    }
+
+    private boolean isSupportedLegacy(int feature) {
+        try {
+            if (checkService()) {
+                return feature == (sService.getSupportedFeatures() & feature);
+            }
+        } catch (RemoteException e) {
+        }
+        return false;
+    }
+
+    private IBase getHIDLService(int feature) {
+        try {
+            /*switch (feature) {
+            }*/
+        } catch (NoSuchElementException | RemoteException e) {
+        }
+        return null;
+    }
+
+    /**
+     * String version for preference constraints
+     *
+     * @hide
+     */
+    public boolean isSupported(String feature) {
+        if (!feature.startsWith("FEATURE_")) {
+            return false;
+        }
+        try {
+            Field f = getClass().getField(feature);
+            if (f != null) {
+                return isSupported((int) f.get(null));
+            }
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            Log.d(TAG, e.getMessage(), e);
+        }
+
+        return false;
+    }
+    /**
+     * Determine if the given feature is enabled or disabled.
+     *
+     * Only used for features which have simple enable/disable controls.
+     *
+     * @param feature the Lineage Hardware feature to query
+     *
+     * @return true if the feature is enabled, false otherwise.
+     */
+    public boolean get(int feature) {
+        if (!BOOLEAN_FEATURES.contains(feature)) {
+            throw new IllegalArgumentException(feature + " is not a boolean");
+        }
+
+        try {
+            if (isSupportedHIDL(feature)) {
+                IBase obj = mHIDLMap.get(feature);
+                /*switch (feature) {
+                }*/
+            } else if (checkService()) {
+                return sService.get(feature);
+            }
+        } catch (RemoteException e) {
+        }
+        return false;
+    }
+
+    /**
+     * Enable or disable the given feature
+     *
+     * Only used for features which have simple enable/disable controls.
+     *
+     * @param feature the Lineage Hardware feature to set
+     * @param enable true to enable, false to disale
+     *
+     * @return true if the feature is enabled, false otherwise.
+     */
+    public boolean set(int feature, boolean enable) {
+        if (!BOOLEAN_FEATURES.contains(feature)) {
+            throw new IllegalArgumentException(feature + " is not a boolean");
+        }
+
+        try {
+            if (isSupportedHIDL(feature)) {
+                IBase obj = mHIDLMap.get(feature);
+                /*switch (feature) {
+                }*/
+            } else if (checkService()) {
+                return sService.set(feature, enable);
+            }
+        } catch (RemoteException e) {
+        }
+        return false;
+    }
+
+
+    /**
+     * @return true if service is valid
+     */
+    private boolean checkService() {
+        if (sService == null) {
+            Log.w(TAG, "not connected to LineageHardwareManagerService");
+            return false;
+        }
+        return true;
+    }
+
+}
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 7439b2f..850cc70 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -6542,6 +6542,13 @@
     <attribution android:tag="DevicePolicyManagerService"
         android:label="@string/device_policy_manager_service"/>
 
+    <!-- LineageHardware -->
+    <protected-broadcast android:name="lineageos.intent.action.INITIALIZE_LINEAGE_HARDWARE" />
+
+    <!-- @hide -->
+    <permission android:name="lineageos.permission.HARDWARE_ABSTRACTION_ACCESS"
+                android:protectionLevel="signature|privileged" />
+
     <application android:process="system"
                  android:persistent="true"
                  android:hasCode="false"
diff --git a/services/core/java/com/android/server/lineage/LineageHardwareService.java b/services/core/java/com/android/server/lineage/LineageHardwareService.java
new file mode 100644
index 0000000..925e5fb
--- /dev/null
+++ b/services/core/java/com/android/server/lineage/LineageHardwareService.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2015-2016 The CyanogenMod Project
+ *               2017-2019 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.server.lineage;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.RemoteCallbackList;
+import android.os.RemoteException;
+import android.os.UserHandle;
+import android.util.Log;
+import android.util.Range;
+
+import com.android.server.LocalServices;
+import com.android.server.SystemService;
+
+import com.android.internal.lineage.hardware.ILineageHardwareService;
+import com.android.internal.lineage.hardware.LineageHardwareManager;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.android.internal.lineage.app.LineageContextConstants;
+
+
+/** @hide */
+public class LineageHardwareService extends SystemService {
+
+    private static final boolean DEBUG = true;
+    private static final String TAG = LineageHardwareService.class.getSimpleName();
+
+    private final Context mContext;
+    private final LineageHardwareInterface mLineageHwImpl;
+
+    private interface LineageHardwareInterface {
+        public int getSupportedFeatures();
+        public boolean get(int feature);
+        public boolean set(int feature, boolean enable);
+    }
+
+    private class LegacyLineageHardware implements LineageHardwareInterface {
+
+        private int mSupportedFeatures = 0;
+
+        public LegacyLineageHardware() {
+        }
+
+        public int getSupportedFeatures() {
+            return mSupportedFeatures;
+        }
+
+        public boolean get(int feature) {
+            switch(feature) {
+                default:
+                    Log.e(TAG, "feature " + feature + " is not a boolean feature");
+                    return false;
+            }
+        }
+
+        public boolean set(int feature, boolean enable) {
+            switch(feature) {
+                default:
+                    Log.e(TAG, "feature " + feature + " is not a boolean feature");
+                    return false;
+            }
+        }
+    }
+
+    private LineageHardwareInterface getImpl(Context context) {
+        return new LegacyLineageHardware();
+    }
+
+    public LineageHardwareService(Context context) {
+        super(context);
+        mContext = context;
+        mLineageHwImpl = getImpl(context);
+        publishBinderService(LineageContextConstants.LINEAGE_HARDWARE_SERVICE, mService);
+    }
+
+    @Override
+    public void onBootPhase(int phase) {
+        if (phase == PHASE_BOOT_COMPLETED) {
+            Intent intent = new Intent("lineageos.intent.action.INITIALIZE_LINEAGE_HARDWARE");
+            intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
+            mContext.sendBroadcastAsUser(intent, UserHandle.ALL,
+                    "lineageos.permission.HARDWARE_ABSTRACTION_ACCESS");
+        }
+    }
+
+    @Override
+    public void onStart() {
+    }
+
+    private final IBinder mService = new ILineageHardwareService.Stub() {
+
+        private boolean isSupported(int feature) {
+            return (getSupportedFeatures() & feature) == feature;
+        }
+
+        @Override
+        public int getSupportedFeatures() {
+            mContext.enforceCallingOrSelfPermission(
+                    "lineageos.permission.HARDWARE_ABSTRACTION_ACCESS", null);
+            return mLineageHwImpl.getSupportedFeatures();
+        }
+
+        @Override
+        public boolean get(int feature) {
+            mContext.enforceCallingOrSelfPermission(
+                    "lineageos.permission.HARDWARE_ABSTRACTION_ACCESS", null);
+            if (!isSupported(feature)) {
+                Log.e(TAG, "feature " + feature + " is not supported");
+                return false;
+            }
+            return mLineageHwImpl.get(feature);
+        }
+
+        @Override
+        public boolean set(int feature, boolean enable) {
+            mContext.enforceCallingOrSelfPermission(
+                    "lineageos.permission.HARDWARE_ABSTRACTION_ACCESS", null);
+            if (!isSupported(feature)) {
+                Log.e(TAG, "feature " + feature + " is not supported");
+                return false;
+            }
+            return mLineageHwImpl.set(feature, enable);
+        }
+    };
+}
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
index 66c9f55..a625cf2 100644
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -137,6 +137,7 @@
 import com.android.server.inputmethod.InputMethodManagerService;
 import com.android.server.integrity.AppIntegrityManagerService;
 import com.android.server.lights.LightsService;
+import com.android.server.lineage.LineageHardwareService;
 import com.android.server.locales.LocaleManagerService;
 import com.android.server.location.LocationManagerService;
 import com.android.server.logcat.LogcatManagerService;
@@ -2520,6 +2521,14 @@
             t.traceBegin("StartMediaMetricsManager");
             mSystemServiceManager.startService(MediaMetricsManagerService.class);
             t.traceEnd();
+
+            // LineageHardware
+            if (!mOnlyCore){
+                t.traceBegin("StartLineageHardwareService");
+                mSystemServiceManager.startService(LineageHardwareService.class);
+                t.traceEnd();
+            }
+
         }
 
         t.traceBegin("StartMediaProjectionManager");