diff --git a/configs/permissions/oplus_camera_default_grant_permissions_list.xml b/configs/permissions/oplus_camera_default_grant_permissions_list.xml new file mode 100644 index 0000000..9c08d09 --- /dev/null +++ b/configs/permissions/oplus_camera_default_grant_permissions_list.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/configs/permissions/oplus_google_lens_config.xml b/configs/permissions/oplus_google_lens_config.xml new file mode 100644 index 0000000..bacf48b --- /dev/null +++ b/configs/permissions/oplus_google_lens_config.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/configs/permissions/privapp-permissions-oplus.xml b/configs/permissions/privapp-permissions-oplus.xml new file mode 100644 index 0000000..4fe926f --- /dev/null +++ b/configs/permissions/privapp-permissions-oplus.xml @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/configs/sysconfig/hiddenapi-package-oplus-whitelist.xml b/configs/sysconfig/hiddenapi-package-oplus-whitelist.xml new file mode 100644 index 0000000..e337329 --- /dev/null +++ b/configs/sysconfig/hiddenapi-package-oplus-whitelist.xml @@ -0,0 +1,16 @@ + + + + + + + + diff --git a/init/Android.bp b/init/Android.bp new file mode 100644 index 0000000..32c430c --- /dev/null +++ b/init/Android.bp @@ -0,0 +1,11 @@ +/* + * Copyright (C) 2024 The Nameless-AOSP Project + * SPDX-License-Identifier: Apache-2.0 + */ + +prebuilt_etc { + name: "init.oplus.camera.rc", + src: "init.oplus.camera.rc", + sub_dir: "init", + device_specific: true, +} diff --git a/init/init.oplus.camera.rc b/init/init.oplus.camera.rc new file mode 100644 index 0000000..be1edc2 --- /dev/null +++ b/init/init.oplus.camera.rc @@ -0,0 +1,9 @@ +# +# Copyright (C) 2024 The Nameless-AOSP Project +# +# SPDX-License-Identifier: Apache-2.0 +# + +on boot + # OIS + chown cameraserver cameraserver /sys/kernel/ois_control/dump_registers diff --git a/oplus-fwk/Android.bp b/oplus-fwk/Android.bp new file mode 100644 index 0000000..c8c3c3b --- /dev/null +++ b/oplus-fwk/Android.bp @@ -0,0 +1,14 @@ +// +// Copyright (C) 2022-2024 The Nameless-AOSP Project +// SPDX-License-Identifier: Apache-2.0 +// + +java_library { + name: "oplus-fwk", + installable: true, + + srcs: [ + "src/**/*.aidl", + "src/**/*.java", + ], +} diff --git a/oplus-fwk/src/android/app/OplusActivityManager.java b/oplus-fwk/src/android/app/OplusActivityManager.java new file mode 100644 index 0000000..2c373bc --- /dev/null +++ b/oplus-fwk/src/android/app/OplusActivityManager.java @@ -0,0 +1,25 @@ +package android.app; + +import android.os.RemoteException; + +import com.oplus.app.OplusAppInfo; + +import java.util.ArrayList; +import java.util.List; + +public class OplusActivityManager { + + private static OplusActivityManager sOplusActivityManager = null; + private static ArrayList sTopAppInfos = new ArrayList(); + + public static OplusActivityManager getInstance() { + if (sOplusActivityManager == null) { + sOplusActivityManager = new OplusActivityManager(); + } + return sOplusActivityManager; + } + + public List getAllTopAppInfos() throws RemoteException { + return (ArrayList) sTopAppInfos.clone(); + } +} diff --git a/oplus-fwk/src/android/app/OplusExSystemServiceHelper.java b/oplus-fwk/src/android/app/OplusExSystemServiceHelper.java new file mode 100644 index 0000000..d6fe527 --- /dev/null +++ b/oplus-fwk/src/android/app/OplusExSystemServiceHelper.java @@ -0,0 +1,84 @@ +package android.app; + +import android.content.ComponentName; +import android.content.Intent; +import android.os.Handler; +import android.text.TextUtils; +import android.util.Log; +//import com.oplus.multiapp.BaseOplusMultiAppManager; + +/* loaded from: classes.dex */ +public class OplusExSystemServiceHelper { + private static final String ATHENA_SYSTEM_SERVICE_CLASSNAME = "com.oplus.athena.systemservice.OplusAthenaSystemService"; + public static final String COREAPPFEATURE_SYSTEM_SERVICE_CLASSNAME = "com.oplus.customize.coreapp.service.OplusCoreAppFeatureService"; + public static final String EX_SYSTEM_SERVICE_CLASSNAME = "com.oplus.exsystemservice.OplusSharedSystemService"; + public static final String EX_SYSTEM_SERVICE_PKGNAME = "com.oplus.exsystemservice"; + private static final String TAG = OplusExSystemServiceHelper.class.getSimpleName(); + private static volatile OplusExSystemServiceHelper sIntance; + + public static OplusExSystemServiceHelper getInstance() { + if (sIntance == null) { + synchronized (OplusExSystemServiceHelper.class) { + if (sIntance == null) { + sIntance = new OplusExSystemServiceHelper(); + } + } + } + return sIntance; + } + + public boolean checkOplusExSystemService(boolean systemThread, String className) { + if (TextUtils.isEmpty(className)) { + Log.w(TAG, "checkOplusExSystemService className is null or empty str"); + return false; + } else if (!systemThread) { + return false; + } else { + try { + if (!EX_SYSTEM_SERVICE_CLASSNAME.equals(className) && !COREAPPFEATURE_SYSTEM_SERVICE_CLASSNAME.equals(className)) { + if (!ATHENA_SYSTEM_SERVICE_CLASSNAME.equals(className)) { + return false; + } + } + return true; + } catch (Exception e) { + Log.e(TAG, "checkOplusExSystemService e = " + e); + return false; + } + } + } + + public boolean checkOplusExSystemService(boolean systemThread, Intent intent) { + if (intent == null) { + Log.w(TAG, "checkOplusExSystemService intent is null"); + return false; + } else if (intent.getComponent() == null) { + Log.w(TAG, "checkOplusExSystemService intent getComponent is null"); + return false; + } else { + return checkOplusExSystemService(systemThread, intent.getComponent().getClassName()); + } + } + + public boolean checkOplusExSystemService(Handler handler, String className) { + return checkOplusExSystemService(true, className); + } + + public ComponentName getComponentName() { + return new ComponentName(EX_SYSTEM_SERVICE_PKGNAME, EX_SYSTEM_SERVICE_CLASSNAME); + } + /* + public void ensureMediaProviderPriority(Handler activityThread, ComponentName name, Runnable runConnection) { + if (name.getClassName().contains(BaseOplusMultiAppManager.MEDIA_PROVIDER_PACKAGE_NAME)) { + Log.i(TAG, "connected :" + name.getClassName()); + } + if (checkOplusExSystemService(activityThread, name.getClassName())) { + runConnection.run(); + } else if (name.getClassName().contains(BaseOplusMultiAppManager.MEDIA_PROVIDER_PACKAGE_NAME)) { + activityThread.postAtFrontOfQueue(runConnection); + } else { + activityThread.post(runConnection); + } + } + */ +} diff --git a/oplus-fwk/src/android/app/OplusWhiteListManager.java b/oplus-fwk/src/android/app/OplusWhiteListManager.java new file mode 100644 index 0000000..1110c02 --- /dev/null +++ b/oplus-fwk/src/android/app/OplusWhiteListManager.java @@ -0,0 +1,18 @@ +package android.app; + +import android.content.Context; + +import java.util.ArrayList; + +public class OplusWhiteListManager { + + public OplusWhiteListManager(Context context) {} + + public ArrayList getStageProtectListFromPkg(String pkg, int type) { + return new ArrayList(); + } + + public void addStageProtectInfo(String pkg, long timeout) {} + + public void removeStageProtectInfo(String pkg) {} +} diff --git a/oplus-fwk/src/android/app/job/IJobInfoExt.java b/oplus-fwk/src/android/app/job/IJobInfoExt.java new file mode 100644 index 0000000..c1279fe --- /dev/null +++ b/oplus-fwk/src/android/app/job/IJobInfoExt.java @@ -0,0 +1,43 @@ +package android.app.job; + +public interface IJobInfoExt { + + public final class JobBuilderExt { + + public boolean mIsOplusJob; + + public JobBuilderExt setRequiresBattIdle(boolean requiresBattIdle, int extra) { + return this; + } + } + + default boolean getBooleanConstraint(String type, boolean defValue) { + return defValue; + } + + default String getStringConstraint(String type, String defValue) { + return defValue; + } + + default int getIntConstraint(String type, int defValue) { + return defValue; + } + + default long getLongConstraint(String type, long defValue) { + return defValue; + } + + default void setBooleanConstraint(String type, boolean value) {} + + default void setStringConstraint(String type, String value) {} + + default void setIntConstraint(String type, int value) {} + + default void setLongConstraint(JobInfo job, String type, long value) {} + + default void initJobInfo(Object in) {} + + default void initJobInfoPure(JobBuilderExt jobBuilderExt) {} + + default void writeToParcelJobInfo(Object out, int flags) {} +} diff --git a/oplus-fwk/src/android/bluetooth/OplusBluetoothAdapter.java b/oplus-fwk/src/android/bluetooth/OplusBluetoothAdapter.java new file mode 100644 index 0000000..3dda63c --- /dev/null +++ b/oplus-fwk/src/android/bluetooth/OplusBluetoothAdapter.java @@ -0,0 +1,13 @@ +package android.bluetooth; + +public class OplusBluetoothAdapter { + + private static OplusBluetoothAdapter sAdapter; + + public static OplusBluetoothAdapter getOplusBluetoothAdapter() { + if (sAdapter == null) { + sAdapter = new OplusBluetoothAdapter(); + } + return sAdapter; + } +} diff --git a/oplus-fwk/src/android/common/IOplusCommonFeature.java b/oplus-fwk/src/android/common/IOplusCommonFeature.java new file mode 100644 index 0000000..1d8ccb5 --- /dev/null +++ b/oplus-fwk/src/android/common/IOplusCommonFeature.java @@ -0,0 +1,14 @@ +package android.common; + +import android.common.OplusFeatureList; + +public interface IOplusCommonFeature { + + default OplusFeatureList.OplusIndex index() { + return OplusFeatureList.OplusIndex.End; + } + + default IOplusCommonFeature getDefault() { + return null; + } +} diff --git a/oplus-fwk/src/android/common/OplusFeatureList.java b/oplus-fwk/src/android/common/OplusFeatureList.java new file mode 100644 index 0000000..50ba70f --- /dev/null +++ b/oplus-fwk/src/android/common/OplusFeatureList.java @@ -0,0 +1,8 @@ +package android.common; + +public class OplusFeatureList { + + public enum OplusIndex { + End + } +} diff --git a/oplus-fwk/src/android/common/OplusFrameworkFactory.java b/oplus-fwk/src/android/common/OplusFrameworkFactory.java new file mode 100644 index 0000000..4daf029 --- /dev/null +++ b/oplus-fwk/src/android/common/OplusFrameworkFactory.java @@ -0,0 +1,13 @@ +package android.common; + +public class OplusFrameworkFactory { + + private static OplusFrameworkFactory sOplusFrameworkFactory = null; + + public static OplusFrameworkFactory getInstance() { + if (sOplusFrameworkFactory == null) { + sOplusFrameworkFactory = new OplusFrameworkFactory(); + } + return sOplusFrameworkFactory; + } +} diff --git a/oplus-fwk/src/android/content/res/OplusBaseConfiguration.java b/oplus-fwk/src/android/content/res/OplusBaseConfiguration.java new file mode 100644 index 0000000..0d96089 --- /dev/null +++ b/oplus-fwk/src/android/content/res/OplusBaseConfiguration.java @@ -0,0 +1,12 @@ +package android.content.res; + +import oplus.content.res.OplusExtraConfiguration; + +public abstract class OplusBaseConfiguration { + + public OplusExtraConfiguration mOplusExtraConfiguration = null; + + public OplusExtraConfiguration getOplusExtraConfiguration() { + return mOplusExtraConfiguration; + } +} diff --git a/oplus-fwk/src/android/hardware/IAONHECallbacks.java b/oplus-fwk/src/android/hardware/IAONHECallbacks.java new file mode 100644 index 0000000..d584141 --- /dev/null +++ b/oplus-fwk/src/android/hardware/IAONHECallbacks.java @@ -0,0 +1,195 @@ +package android.hardware; + +import android.os.Binder; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Parcel; +import android.os.RemoteException; + +/* loaded from: classes.dex */ +public interface IAONHECallbacks extends IInterface { + public static final String DESCRIPTOR = "android.hardware.IAONHECallbacks"; + public static final int ERROR_AON_DISABLED = 2; + public static final int ERROR_AON_FORCE_CLOSE = 3; + public static final int ERROR_AON_IN_CLOSED = 0; + public static final int ERROR_AON_IN_USE = 1; + public static final int ERROR_AON_NO_INDEX = -1; + + void onClosed() throws RemoteException; + + void onError(int i) throws RemoteException; + + void onHEDetected() throws RemoteException; + + void onOpened() throws RemoteException; + + /* loaded from: classes.dex */ + public static class Default implements IAONHECallbacks { + @Override // android.hardware.IAONHECallbacks + public void onOpened() throws RemoteException { + } + + @Override // android.hardware.IAONHECallbacks + public void onClosed() throws RemoteException { + } + + @Override // android.hardware.IAONHECallbacks + public void onError(int errorCode) throws RemoteException { + } + + @Override // android.hardware.IAONHECallbacks + public void onHEDetected() throws RemoteException { + } + + @Override // android.os.IInterface + public IBinder asBinder() { + return null; + } + } + + /* loaded from: classes.dex */ + public static abstract class Stub extends Binder implements IAONHECallbacks { + static final int TRANSACTION_onClosed = 2; + static final int TRANSACTION_onError = 3; + static final int TRANSACTION_onHEDetected = 4; + static final int TRANSACTION_onOpened = 1; + + public Stub() { + attachInterface(this, IAONHECallbacks.DESCRIPTOR); + } + + public static IAONHECallbacks asInterface(IBinder obj) { + if (obj == null) { + return null; + } + IInterface iin = obj.queryLocalInterface(IAONHECallbacks.DESCRIPTOR); + if (iin != null && (iin instanceof IAONHECallbacks)) { + return (IAONHECallbacks) iin; + } + return new Proxy(obj); + } + + @Override // android.os.IInterface + public IBinder asBinder() { + return this; + } + + public static String getDefaultTransactionName(int transactionCode) { + switch (transactionCode) { + case 1: + return "onOpened"; + case 2: + return "onClosed"; + case 3: + return "onError"; + case 4: + return "onHEDetected"; + default: + return null; + } + } + + public String getTransactionName(int transactionCode) { + return getDefaultTransactionName(transactionCode); + } + + @Override // android.os.Binder + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { + if (code >= 1 && code <= 16777215) { + data.enforceInterface(IAONHECallbacks.DESCRIPTOR); + } + switch (code) { + case 1598968902: + reply.writeString(IAONHECallbacks.DESCRIPTOR); + return true; + default: + switch (code) { + case 1: + onOpened(); + break; + case 2: + onClosed(); + break; + case 3: + int _arg0 = data.readInt(); + data.enforceNoDataAvail(); + onError(_arg0); + break; + case 4: + onHEDetected(); + break; + default: + return super.onTransact(code, data, reply, flags); + } + return true; + } + } + + /* loaded from: classes.dex */ + private static class Proxy implements IAONHECallbacks { + private IBinder mRemote; + + Proxy(IBinder remote) { + this.mRemote = remote; + } + + @Override // android.os.IInterface + public IBinder asBinder() { + return this.mRemote; + } + + public String getInterfaceDescriptor() { + return IAONHECallbacks.DESCRIPTOR; + } + + @Override // android.hardware.IAONHECallbacks + public void onOpened() throws RemoteException { + Parcel _data = Parcel.obtain(asBinder()); + try { + _data.writeInterfaceToken(IAONHECallbacks.DESCRIPTOR); + this.mRemote.transact(1, _data, null, 1); + } finally { + _data.recycle(); + } + } + + @Override // android.hardware.IAONHECallbacks + public void onClosed() throws RemoteException { + Parcel _data = Parcel.obtain(asBinder()); + try { + _data.writeInterfaceToken(IAONHECallbacks.DESCRIPTOR); + this.mRemote.transact(2, _data, null, 1); + } finally { + _data.recycle(); + } + } + + @Override // android.hardware.IAONHECallbacks + public void onError(int errorCode) throws RemoteException { + Parcel _data = Parcel.obtain(asBinder()); + try { + _data.writeInterfaceToken(IAONHECallbacks.DESCRIPTOR); + _data.writeInt(errorCode); + this.mRemote.transact(3, _data, null, 1); + } finally { + _data.recycle(); + } + } + + @Override // android.hardware.IAONHECallbacks + public void onHEDetected() throws RemoteException { + Parcel _data = Parcel.obtain(asBinder()); + try { + _data.writeInterfaceToken(IAONHECallbacks.DESCRIPTOR); + this.mRemote.transact(4, _data, null, 1); + } finally { + _data.recycle(); + } + } + } + + public int getMaxTransactionId() { + return 3; + } + } +} diff --git a/oplus-fwk/src/android/hardware/camera2/IOplusCameraManager.java b/oplus-fwk/src/android/hardware/camera2/IOplusCameraManager.java new file mode 100644 index 0000000..c4c72d5 --- /dev/null +++ b/oplus-fwk/src/android/hardware/camera2/IOplusCameraManager.java @@ -0,0 +1,65 @@ +package android.hardware.camera2; + +import android.common.IOplusCommonFeature; +import android.common.OplusFeatureList; +import android.content.Context; +import android.os.IBinder; + +/* loaded from: classes.dex */ +public interface IOplusCameraManager extends IOplusCommonFeature { + public static final IOplusCameraManager DEFAULT = new IOplusCameraManager() { // from class: android.hardware.camera2.IOplusCameraManager.1 + }; + public static final String NAME = "IOplusCameraManager"; + + /* loaded from: classes.dex */ + public enum Cmd { + CMD_NONE, + CMD_PRE_CAPTURE, + CMD_PRE_OPEN, + CMD_PRE_EVLIST + } + + //default OplusFeatureList.OplusIndex index() { + // return OplusFeatureList.OplusIndex.IOplusCameraManager; + //} + + default IOplusCommonFeature getDefault() { + return DEFAULT; + } + + default void addAuthResultInfo(Context context, int uid, int pid, int permBits, String packageName) { + } + + default void setDeathRecipient(IBinder client) { + } + + default boolean isAuthedClient(Context context) { + return false; + } + + default void preOpenCamera(Context context) { + } + + default void sendOplusExtCamCmd(Context context, Cmd cmd, int[] param) { + } + + default void setCallInfo() { + } + + default void saveOpPackageName(String packageName) { + } + + default void setPackageName() { + } + + default boolean isPrivilegedApp(String packageName) { + return false; + } + + default boolean isCameraUnitSession() { + return false; + } + + default void parseSessionParameters(CaptureRequest sessionParams) { + } +} diff --git a/oplus-fwk/src/android/hardware/camera2/OplusCameraManager.java b/oplus-fwk/src/android/hardware/camera2/OplusCameraManager.java new file mode 100644 index 0000000..d2f5739 --- /dev/null +++ b/oplus-fwk/src/android/hardware/camera2/OplusCameraManager.java @@ -0,0 +1,757 @@ +package android.hardware.camera2; + +import android.app.OplusExSystemServiceHelper; +import android.content.Context; +import android.hardware.IAONHECallbacks; +import android.hardware.camera2.CaptureRequest; +import android.hardware.camera2.IOplusCameraManager; +import android.hardware.camera2.impl.CameraMetadataNative; +import android.media.Image; +import android.media.ImageReader; +import android.os.Binder; +import android.os.IBinder; +import android.os.Parcel; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemProperties; +import android.util.Log; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/* loaded from: classes.dex */ +public final class OplusCameraManager implements IOplusCameraManager { + private static final String PERMISSION_SAFE_CAMERA = "com.oplus.permission.safe.CAMERA"; + private static final String TAG = "OplusCameraManager"; + private static final String SYSTEM_CAMERA_PACKNAME = SystemProperties.get("ro.oplus.system.camera.name"); + private static final CaptureRequest.Key KEY_OPLUS_PACKAGE = new CaptureRequest.Key<>("com.oplus.is.sdk.camera.package", byte[].class); + private static OplusCameraManager mInstance = new OplusCameraManager(); + private static String[] SET_PACKAGE_BLACK_LIST = {"com.oplus.battery", "com.oplus.onetrace", "com.android.systemui", "com.oplus.obrain", OplusExSystemServiceHelper.EX_SYSTEM_SERVICE_PKGNAME}; + private String mOpPackageName = ""; + private boolean mIsCameraUnitSession = false; + private boolean mbLoad = false; + + public native int nativeSendToAttachHWBufToBufQEvent(long j); + + public native int nativeSendToBufQAllocEnableEvent(long j); + + public native int nativeSendToExchgHWBufBtwBufQEvent(long j); + + public native void nativtSendToProcessHeif(long j); + + private OplusCameraManager() { + } + + private void checkLoadLibrary() { + Log.i(TAG, "checkLoadHeifLibbrary, mbLoad: " + this.mbLoad); + if (this.mbLoad) { + return; + } + try { + System.loadLibrary("HeifWinBufExchg-jni"); + this.mbLoad = true; + } catch (Exception e) { + e.printStackTrace(); + Log.e(TAG, "checkLoadHeifLibbrary, error"); + } + } + + public void sendToProcessHeif(long ptr) { + checkLoadLibrary(); + nativtSendToProcessHeif(ptr); + } + + public int sendToBufQAllocEnableEvent(long ptr) { + checkLoadLibrary(); + return nativeSendToBufQAllocEnableEvent(ptr); + } + + public int sendToExchgHWBufBtwBufQEvent(long ptr) { + checkLoadLibrary(); + return nativeSendToExchgHWBufBtwBufQEvent(ptr); + } + + public int sendToAttachHWBufToBufQEvent(long ptr) { + checkLoadLibrary(); + return nativeSendToAttachHWBufToBufQEvent(ptr); + } + + public static synchronized OplusCameraManager getInstance() { + OplusCameraManager oplusCameraManager; + synchronized (OplusCameraManager.class) { + oplusCameraManager = mInstance; + } + return oplusCameraManager; + } + + public static Object getEmptyCameraMetadataNative(long[] metadataPtr) { + CameraMetadataNative meta = new CameraMetadataNative(); + if (metadataPtr != null && metadataPtr.length > 0) { + metadataPtr[0] = meta.getMetadataPtr(); + } + return meta; + } + + public static TotalCaptureResult generateTotalCaptureResult(Object meta, long frameId) { + if (meta == null || !(meta instanceof CameraMetadataNative)) { + return null; + } + TotalCaptureResult r = new TotalCaptureResult((CameraMetadataNative) meta, 0); + try { + Field numField = CaptureResult.class.getDeclaredField("mFrameNumber"); + numField.setAccessible(true); + numField.setLong(r, frameId); + } catch (IllegalAccessException | NoSuchFieldException e) { + e.printStackTrace(); + } + return r; + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void addAuthResultInfo(Context context, int uid, int pid, int permBits, String packageName) { + context.enforceCallingOrSelfPermission(PERMISSION_SAFE_CAMERA, TAG); + if (uid == 0) { + throw new IllegalArgumentException("uid was 0, which is illegal."); + } + if (pid == 0) { + throw new IllegalArgumentException("pid was 0, which is illegal."); + } + if (packageName == null) { + throw new IllegalArgumentException("packageName was null, which is illegal."); + } + try { + OplusCameraManagerGlobal.get().addAuthResultInfo(uid, pid, permBits, packageName); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void setDeathRecipient(IBinder client) { + if (client == null) { + throw new IllegalArgumentException("client was null"); + } + try { + OplusCameraManagerGlobal.get().setDeathRecipient(client); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public boolean isAuthedClient(Context context) { + if (context == null) { + throw new IllegalArgumentException("context was null"); + } + try { + return OplusCameraManagerGlobal.get().isAuthedClient(context.getOpPackageName()); + } catch (CameraAccessException e) { + e.printStackTrace(); + return false; + } catch (RemoteException e2) { + e2.printStackTrace(); + return false; + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void preOpenCamera(Context context) { + if (context == null) { + throw new IllegalArgumentException("context was null"); + } + context.enforceCallingOrSelfPermission(PERMISSION_SAFE_CAMERA, TAG); + try { + OplusCameraManagerGlobal.get().preOpenCamera(context.getOpPackageName()); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void sendOplusExtCamCmd(Context context, IOplusCameraManager.Cmd cmd, int[] param) { + if (context == null) { + throw new IllegalArgumentException("context was null"); + } + context.enforceCallingOrSelfPermission(PERMISSION_SAFE_CAMERA, TAG); + try { + OplusCameraManagerGlobal.get().sendOplusExtCamCmd(context.getOpPackageName(), cmd, param); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void setCallInfo() { + try { + OplusCameraManagerGlobal.get().setCallInfo(); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void saveOpPackageName(String packageName) { + this.mOpPackageName = packageName; + Log.i(TAG, "saveOpPackageName, mOpPackageName: " + this.mOpPackageName); + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void setPackageName() { + String[] strArr; + for (String packageName : SET_PACKAGE_BLACK_LIST) { + if (packageName.equals(this.mOpPackageName)) { + return; + } + } + try { + OplusCameraManagerGlobal.get().setClientInfo(this.mOpPackageName, Binder.getCallingUid(), Binder.getCallingPid()); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + public void setRIOClientInfo() throws CameraAccessException { + Log.i(TAG, "uid = " + Binder.getCallingUid() + ", pid = " + Binder.getCallingPid()); + try { + OplusCameraManagerGlobal.get().setRIOClientInfo(Binder.getCallingUid(), Binder.getCallingPid()); + } catch (RemoteException e) { + e.printStackTrace(); + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public boolean isPrivilegedApp(String packageName) { + String str; + if (packageName == null || (str = SYSTEM_CAMERA_PACKNAME) == null || !str.equals(packageName)) { + return false; + } + return true; + } + + public void setTorchIntensity(int torchIntensity) { + if (torchIntensity < 0) { + throw new IllegalArgumentException("torchIntensity was less than 0, which is illegal."); + } + try { + OplusCameraManagerGlobal.get().setTorchIntensity(torchIntensity); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + public void disconnectClients() { + try { + OplusCameraManagerGlobal.get().disconnectClients(); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + public boolean isClientConnected() { + try { + return OplusCameraManagerGlobal.get().isClientConnected(); + } catch (CameraAccessException e) { + e.printStackTrace(); + return false; + } catch (RemoteException e2) { + e2.printStackTrace(); + return false; + } + } + + @Override // android.hardware.camera2.IOplusCameraManager + public boolean isCameraUnitSession() { + return this.mIsCameraUnitSession; + } + + @Override // android.hardware.camera2.IOplusCameraManager + public void parseSessionParameters(CaptureRequest sessionParams) { + if (sessionParams == null) { + setIsCameraUnitSession(false); + return; + } + byte[] result = (byte[]) sessionParams.get(KEY_OPLUS_PACKAGE); + if (result == null || result.length == 0) { + setIsCameraUnitSession(false); + return; + } + if (1 == result[0]) { + setIsCameraUnitSession(true); + } + Log.i(TAG, "parseSessionParameters mIsCameraUnitSession: " + this.mIsCameraUnitSession); + } + + public void oplusDetachImage(Image image, ImageReader imgreader) { + try { + Method method = ImageReader.class.getDeclaredMethod("detachImage", Image.class); + method.setAccessible(true); + method.invoke(imgreader, image); + } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) { + e.printStackTrace(); + } + Log.i(TAG, "using reflection to visit detachImage method in ImageReader"); + } + + public static void setOmojiJson(String jsonInfo) { + Log.i(TAG, "setOmojiJson called."); + if (jsonInfo == null || "".equals(jsonInfo)) { + Log.i(TAG, "jsonInfo is null"); + return; + } + try { + OplusCameraManagerGlobal.get().setOmojiJson(jsonInfo); + } catch (CameraAccessException e) { + Log.i(TAG, "setOmojiJson :" + e.getMessage()); + } catch (RemoteException e2) { + Log.i(TAG, "setOmojiJson :" + e2.getMessage()); + } + } + + public void closeAON() throws CameraAccessException { + Log.i(TAG, "uid = " + Binder.getCallingUid() + ", pid = " + Binder.getCallingPid()); + try { + OplusCameraManagerGlobal.get().closeAON(); + } catch (RemoteException e) { + e.printStackTrace(); + } + } + + public void openAON(IAONHECallbacks callback) throws CameraAccessException { + Log.i(TAG, "uid = " + Binder.getCallingUid() + ", pid = " + Binder.getCallingPid()); + try { + OplusCameraManagerGlobal.get().openAON(callback); + } catch (RemoteException e) { + e.printStackTrace(); + } + } + + private void setIsCameraUnitSession(boolean isCameraUnitSession) { + this.mIsCameraUnitSession = isCameraUnitSession; + try { + OplusCameraManagerGlobal.get().setIsCameraUnitSession(this.mIsCameraUnitSession); + } catch (CameraAccessException e) { + e.printStackTrace(); + } catch (RemoteException e2) { + e2.printStackTrace(); + } + } + + /* JADX INFO: Access modifiers changed from: private */ + /* loaded from: classes.dex */ + public static final class OplusCameraManagerGlobal implements IBinder.DeathRecipient { + private static final int ADD_AUTH_RESULT = 10001; + private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera"; + private static final int CLIENT_IS_AUTHED = 10004; + private static final int CLOSE_AON = 10013; + private static final int CONNECT_STATUS = 10011; + private static final String DESCRIPTOR = "android.hardware.camera"; + private static final int DISCONNECT_CLIENTS = 10009; + private static final int OPEN_AON = 10012; + private static final int OPLUS_CAMERA_FIRST_CALL_TRANSACTION = 10000; + private static final int PRE_OPEN_CAMERA = 10014; + private static final int SEND_OPLUS_EXT_CAM_CMD = 10015; + private static final int SET_CALL_INFO = 10006; + private static final int SET_CLIENT_INFO = 10005; + private static final int SET_DEATH_RECIPIENT = 10002; + private static final int SET_IS_CAMERA_UNIT_SESSION = 10016; + private static final int SET_OMOJI_JSON = 10010; + private static final int SET_PACKAGE_NAME = 10003; + private static final int SET_RIO_CLIENT_INFO = 10007; + private static final int SET_TORCH_INTENSITY = 10008; + private static final String TAG = "OplusCameraManagerGlobal"; + private static final OplusCameraManagerGlobal gCameraManager = new OplusCameraManagerGlobal(); + public static final boolean sCameraServiceDisabled = SystemProperties.getBoolean("config.disable_cameraservice", false); + private final boolean DEBUG = false; + private final Object mLock = new Object(); + private IBinder mRemote = null; + + private OplusCameraManagerGlobal() { + } + + public static OplusCameraManagerGlobal get() { + return gCameraManager; + } + + private void connectCameraServiceLocked() { + if (this.mRemote != null || sCameraServiceDisabled) { + return; + } + Log.i(TAG, "Connecting to camera service"); + IBinder service = ServiceManager.getService(CAMERA_SERVICE_BINDER_NAME); + this.mRemote = service; + if (service == null) { + return; + } + try { + service.linkToDeath(this, 0); + } catch (RemoteException e) { + } + } + + public IBinder getCameraServiceRemote() { + IBinder iBinder; + synchronized (this.mLock) { + connectCameraServiceLocked(); + if (this.mRemote == null && !sCameraServiceDisabled) { + Log.e(TAG, "Camera service is unavailable"); + } + iBinder = this.mRemote; + } + return iBinder; + } + + public void addAuthResultInfo(int uid, int pid, int permBits, String packageName) throws CameraAccessException, RemoteException { + Log.e(TAG, "addAuthResultInfo"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeInt(uid); + data.writeInt(pid); + data.writeInt(permBits); + data.writeString(packageName); + this.mRemote.transact(10001, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void setDeathRecipient(IBinder client) throws CameraAccessException, RemoteException { + Log.e(TAG, "setDeathRecipient"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeStrongBinder(client); + this.mRemote.transact(10002, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public boolean isAuthedClient(String packageName) throws CameraAccessException, RemoteException { + Log.e(TAG, "isAuthedClient, need check packageName: " + packageName); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeString(packageName); + this.mRemote.transact(10004, data, reply, 0); + reply.readException(); + boolean isAuthed = reply.readBoolean(); + data.recycle(); + reply.recycle(); + Log.e(TAG, "isAuthedClient, the " + packageName + " is Authed " + isAuthed); + return isAuthed; + } catch (Throwable th) { + data.recycle(); + reply.recycle(); + throw th; + } + } + + public void preOpenCamera(String packageName) throws CameraAccessException, RemoteException { + Log.e(TAG, "preOpenCamera, need check packageName: " + packageName); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeInt(1); + this.mRemote.transact(10014, data, reply, 0); + reply.readException(); + data.recycle(); + reply.recycle(); + Log.e(TAG, "preOpenCamera, the " + packageName + " preOpenSend "); + } catch (Throwable th) { + data.recycle(); + reply.recycle(); + throw th; + } + } + + public void sendOplusExtCamCmd(String packageName, IOplusCameraManager.Cmd cmd, int[] param) throws CameraAccessException, RemoteException { + Log.e(TAG, "sendOplusExtCamCmd, packageName: " + packageName + ", cmd: " + cmd); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeInt(cmd.ordinal()); + data.writeIntArray(param); + this.mRemote.transact(10015, data, reply, 1); + reply.readException(); + data.recycle(); + reply.recycle(); + Log.e(TAG, "sendOplusExtCamCmd complete "); + } catch (Throwable th) { + data.recycle(); + reply.recycle(); + throw th; + } + } + + public void setCallInfo() throws CameraAccessException, RemoteException { + Log.e(TAG, "setCallInfo"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + this.mRemote.transact(10006, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void setPackageName(String packageName) throws CameraAccessException, RemoteException { + Log.i(TAG, "setPackageName"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeString(packageName); + remote.transact(10003, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void setClientInfo(String packageName, int uid, int pid) throws CameraAccessException, RemoteException { + Log.i(TAG, "setClientInfo, packageName: " + packageName + ", uid: " + uid + ", pid: " + pid); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeString(packageName); + data.writeInt(uid); + data.writeInt(pid); + remote.transact(10005, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void setRIOClientInfo(int uid, int pid) throws CameraAccessException, RemoteException { + Log.i(TAG, "uid: " + uid + ", pid: " + pid); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeInt(uid); + data.writeInt(pid); + remote.transact(10007, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void setOmojiJson(String atavatarInfo) throws CameraAccessException, RemoteException { + Log.i(TAG, "setOmojiJson E"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeString(atavatarInfo); + Log.i(TAG, "setOmojiJson process E"); + this.mRemote.transact(10010, data, reply, 0); + Log.i(TAG, "setOmojiJson process X"); + reply.readException(); + data.recycle(); + reply.recycle(); + Log.i(TAG, "setOmojiJson X"); + } catch (Throwable th) { + data.recycle(); + reply.recycle(); + throw th; + } + } + + public void setTorchIntensity(int torchIntensity) throws CameraAccessException, RemoteException { + Log.d(TAG, "setTorchIntensity: " + torchIntensity); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeInt(torchIntensity); + remote.transact(10008, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void disconnectClients() throws CameraAccessException, RemoteException { + Log.e(TAG, "disconnectClients"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + this.mRemote.transact(10009, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public boolean isClientConnected() throws CameraAccessException, RemoteException { + Log.e(TAG, "isClientConnected"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + this.mRemote.transact(10011, data, reply, 0); + reply.readException(); + boolean isConnected = reply.readBoolean(); + data.recycle(); + reply.recycle(); + Log.e(TAG, "isClientConnected: " + isConnected); + return isConnected; + } catch (Throwable th) { + data.recycle(); + reply.recycle(); + throw th; + } + } + + public void openAON(IAONHECallbacks callback) throws CameraAccessException, RemoteException { + Log.i(TAG, "openAON E"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeStrongBinder(callback.asBinder()); + remote.transact(10012, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void closeAON() throws CameraAccessException, RemoteException { + Log.i(TAG, "closeAON E"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + remote.transact(10013, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public void setIsCameraUnitSession(boolean isCameraUnitSession) throws CameraAccessException, RemoteException { + Log.i(TAG, "setIsCameraUnitSession E"); + IBinder remote = getCameraServiceRemote(); + if (remote == null) { + throw new CameraAccessException(2, "Camera service is currently unavailable"); + } + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(DESCRIPTOR); + data.writeBoolean(isCameraUnitSession); + remote.transact(10016, data, reply, 0); + reply.readException(); + } finally { + data.recycle(); + reply.recycle(); + } + } + + @Override // android.os.IBinder.DeathRecipient + public void binderDied() { + this.mRemote = null; + } + } +} diff --git a/oplus-fwk/src/android/os/OplusKeyEventManager.java b/oplus-fwk/src/android/os/OplusKeyEventManager.java new file mode 100644 index 0000000..fe013a8 --- /dev/null +++ b/oplus-fwk/src/android/os/OplusKeyEventManager.java @@ -0,0 +1,10 @@ +package android.os; + +import android.view.KeyEvent; + +public class OplusKeyEventManager { + + public interface OnKeyEventObserver { + void onKeyEvent(KeyEvent event); + } +} diff --git a/oplus-fwk/src/android/os/OplusManager.java b/oplus-fwk/src/android/os/OplusManager.java new file mode 100644 index 0000000..49281dc --- /dev/null +++ b/oplus-fwk/src/android/os/OplusManager.java @@ -0,0 +1,8 @@ +package android.os; + +import java.util.Map; + +public class OplusManager { + + public static void onStamp(String eventId, Map logMap) {} +} diff --git a/oplus-fwk/src/android/os/OplusSystemProperties.java b/oplus-fwk/src/android/os/OplusSystemProperties.java new file mode 100644 index 0000000..f37593f --- /dev/null +++ b/oplus-fwk/src/android/os/OplusSystemProperties.java @@ -0,0 +1,20 @@ +package android.os; + +public class OplusSystemProperties { + + public static String get(String key) { + return SystemProperties.get(key); + } + + public static String get(String key, String def) { + return SystemProperties.get(key, def); + } + + public static int getInt(String key, int def) { + return SystemProperties.getInt(key, def); + } + + public static boolean getBoolean(String key, boolean def) { + return SystemProperties.getBoolean(key, def); + } +} diff --git a/oplus-fwk/src/android/view/OplusWindowManager.java b/oplus-fwk/src/android/view/OplusWindowManager.java new file mode 100644 index 0000000..c22e5fa --- /dev/null +++ b/oplus-fwk/src/android/view/OplusWindowManager.java @@ -0,0 +1,6 @@ +package android.view; + +public class OplusWindowManager { + + public OplusWindowManager() {} +} diff --git a/oplus-fwk/src/android/view/animation/OplusBezierInterpolator.java b/oplus-fwk/src/android/view/animation/OplusBezierInterpolator.java new file mode 100644 index 0000000..c2f5d55 --- /dev/null +++ b/oplus-fwk/src/android/view/animation/OplusBezierInterpolator.java @@ -0,0 +1,63 @@ +package android.view.animation; + +import android.content.Context; +import android.content.res.Resources; +import android.util.AttributeSet; + +public class OplusBezierInterpolator extends BaseInterpolator { + private final float ABOVE_ONE; + private final float ABOVE_ZERO; + private final float BELOW_ONE; + private final boolean DEBUG; + private final double EPSILON; + private final String TAG; + private boolean mAbove; + private boolean mLimit; + private OplusUnitBezier mOplusUnitBezier; + + public OplusBezierInterpolator(Context context, AttributeSet attrs) { + this(context.getResources(), context.getTheme(), attrs); + } + + public OplusBezierInterpolator(Resources res, Resources.Theme theme, AttributeSet attrs) { + this.TAG = "OplusBezierInterpolator"; + this.DEBUG = false; + this.EPSILON = 6.25E-5d; + this.ABOVE_ONE = 1.0f; + this.BELOW_ONE = 0.9999f; + this.ABOVE_ZERO = 1.0E-4f; + this.mAbove = false; + this.mLimit = false; + } + + public OplusBezierInterpolator(double p1x, double p1y, double p2x, double p2y, boolean limit) { + this.TAG = "OplusBezierInterpolator"; + this.DEBUG = false; + this.EPSILON = 6.25E-5d; + this.ABOVE_ONE = 1.0f; + this.BELOW_ONE = 0.9999f; + this.ABOVE_ZERO = 1.0E-4f; + this.mAbove = false; + this.mLimit = false; + this.mLimit = limit; + this.mOplusUnitBezier = new OplusUnitBezier(p1x, p1y, p2x, p2y); + } + + @Override + public float getInterpolation(float input) { + double interpolation = this.mOplusUnitBezier.solve(input, 6.25E-5d); + if (this.mLimit) { + if (input < 1.0E-4f || input > 0.9999f) { + this.mAbove = false; + } + if (interpolation > 1.0d && !this.mAbove) { + interpolation = 1.0d; + this.mAbove = true; + } + if (this.mAbove) { + interpolation = 1.0d; + } + } + return (float) interpolation; + } +} diff --git a/oplus-fwk/src/android/view/animation/OplusUnitBezier.java b/oplus-fwk/src/android/view/animation/OplusUnitBezier.java new file mode 100644 index 0000000..2b288c2 --- /dev/null +++ b/oplus-fwk/src/android/view/animation/OplusUnitBezier.java @@ -0,0 +1,77 @@ +package android.view.animation; + +public class OplusUnitBezier { + + private double f5ax; + private double f6ay; + private double f7bx; + private double f8by; + private double f9cx; + private double f10cy; + + public OplusUnitBezier(double p1x, double p1y, double p2x, double p2y) { + double d = p1x * 3.0d; + this.f9cx = d; + double d2 = ((p2x - p1x) * 3.0d) - d; + this.f7bx = d2; + this.f5ax = (1.0d - d) - d2; + double d3 = p1y * 3.0d; + this.f10cy = d3; + double d4 = ((p2y - p1y) * 3.0d) - d3; + this.f8by = d4; + this.f6ay = (1.0d - d3) - d4; + } + + public double sampleCurveX(double t) { + return ((((this.f5ax * t) + this.f7bx) * t) + this.f9cx) * t; + } + + public double sampleCurveY(double t) { + return ((((this.f6ay * t) + this.f8by) * t) + this.f10cy) * t; + } + + public double sampleCurveDerivativeX(double t) { + return (((this.f5ax * 3.0d * t) + (this.f7bx * 2.0d)) * t) + this.f9cx; + } + + public double solveCurveX(double x, double epsilon) { + double t2 = x; + for (int i = 0; i < 8; i++) { + double x2 = sampleCurveX(t2) - x; + if (Math.abs(x2) < epsilon) { + return t2; + } + double d2 = sampleCurveDerivativeX(t2); + if (Math.abs(d2) < 1.0E-6d) { + break; + } + t2 -= x2 / d2; + } + double t0 = 0.0d; + double t1 = 1.0d; + double t22 = x; + if (t22 < 0.0d) { + return 0.0d; + } + if (t22 > 1.0d) { + return 1.0d; + } + while (t0 < t1) { + double x22 = sampleCurveX(t22); + if (Math.abs(x22 - x) < epsilon) { + return t22; + } + if (x > x22) { + t0 = t22; + } else { + t1 = t22; + } + t22 = ((t1 - t0) * 0.5d) + t0; + } + return t22; + } + + public double solve(double x, double epsilon) { + return sampleCurveY(solveCurveX(x, epsilon)); + } +} diff --git a/oplus-fwk/src/com/oplus/app/OPlusAccessControlManager.java b/oplus-fwk/src/com/oplus/app/OPlusAccessControlManager.java new file mode 100644 index 0000000..e167d5c --- /dev/null +++ b/oplus-fwk/src/com/oplus/app/OPlusAccessControlManager.java @@ -0,0 +1,25 @@ +package com.oplus.app; + +import android.os.UserHandle; + +public class OPlusAccessControlManager { + + private static OPlusAccessControlManager sOPlusAccessControlManager = null; + + public static final int USER_CURRENT = UserHandle.myUserId(); + + public static OPlusAccessControlManager getInstance() { + if (sOPlusAccessControlManager == null) { + sOPlusAccessControlManager = new OPlusAccessControlManager(); + } + return sOPlusAccessControlManager; + } + + public boolean isEncryptPass(String packageName, int userId) { + return true; + } + + public boolean isEncryptedPackage(String packageName, int userId) { + return true; + } +} diff --git a/oplus-fwk/src/com/oplus/app/OplusAppEnterInfo.java b/oplus-fwk/src/com/oplus/app/OplusAppEnterInfo.java new file mode 100644 index 0000000..0cbf7dc --- /dev/null +++ b/oplus-fwk/src/com/oplus/app/OplusAppEnterInfo.java @@ -0,0 +1,6 @@ +package com.oplus.app; + +public class OplusAppEnterInfo { + + public OplusAppEnterInfo() {} +} diff --git a/oplus-fwk/src/com/oplus/app/OplusAppExitInfo.java b/oplus-fwk/src/com/oplus/app/OplusAppExitInfo.java new file mode 100644 index 0000000..1909933 --- /dev/null +++ b/oplus-fwk/src/com/oplus/app/OplusAppExitInfo.java @@ -0,0 +1,6 @@ +package com.oplus.app; + +public class OplusAppExitInfo { + + public OplusAppExitInfo() {} +} diff --git a/oplus-fwk/src/com/oplus/app/OplusAppInfo.java b/oplus-fwk/src/com/oplus/app/OplusAppInfo.java new file mode 100644 index 0000000..2a73c23 --- /dev/null +++ b/oplus-fwk/src/com/oplus/app/OplusAppInfo.java @@ -0,0 +1,6 @@ +package com.oplus.app; + +public class OplusAppInfo { + + public OplusAppInfo() {} +} diff --git a/oplus-fwk/src/com/oplus/app/OplusAppSwitchConfig.java b/oplus-fwk/src/com/oplus/app/OplusAppSwitchConfig.java new file mode 100644 index 0000000..82d9cbc --- /dev/null +++ b/oplus-fwk/src/com/oplus/app/OplusAppSwitchConfig.java @@ -0,0 +1,8 @@ +package com.oplus.app; + +import java.util.List; + +public class OplusAppSwitchConfig { + + public void addAppConfig(int type, List list) {} +} diff --git a/oplus-fwk/src/com/oplus/app/OplusAppSwitchManager.java b/oplus-fwk/src/com/oplus/app/OplusAppSwitchManager.java new file mode 100644 index 0000000..691ed00 --- /dev/null +++ b/oplus-fwk/src/com/oplus/app/OplusAppSwitchManager.java @@ -0,0 +1,37 @@ +package com.oplus.app; + +import android.content.Context; + +public class OplusAppSwitchManager { + + private static OplusAppSwitchManager sOplusAppSwitchManager = null; + + public static int APP_SWITCH_VERSION = 1; + + public static OplusAppSwitchManager getInstance() { + if (sOplusAppSwitchManager == null) { + sOplusAppSwitchManager = new OplusAppSwitchManager(); + } + return sOplusAppSwitchManager; + } + + public boolean registerAppSwitchObserver(Context context, + OnAppSwitchObserver observer, OplusAppSwitchConfig config) { + return true; + } + + public boolean unregisterAppSwitchObserver(Context context, OnAppSwitchObserver observer) { + return true; + } + + public interface OnAppSwitchObserver { + + void onActivityEnter(OplusAppEnterInfo oplusAppEnterInfo); + + void onActivityExit(OplusAppExitInfo oplusAppExitInfo); + + void onAppEnter(OplusAppEnterInfo oplusAppEnterInfo); + + void onAppExit(OplusAppExitInfo oplusAppExitInfo); + } +} diff --git a/oplus-fwk/src/com/oplus/content/OplusFeatureConfigManager.java b/oplus-fwk/src/com/oplus/content/OplusFeatureConfigManager.java new file mode 100644 index 0000000..220e948 --- /dev/null +++ b/oplus-fwk/src/com/oplus/content/OplusFeatureConfigManager.java @@ -0,0 +1,20 @@ +package com.oplus.content; + +public class OplusFeatureConfigManager { + + public static OplusFeatureConfigManager sOplusFeatureConfigManager = null; + + public static OplusFeatureConfigManager getInstance() { + if (sOplusFeatureConfigManager == null) { + sOplusFeatureConfigManager = new OplusFeatureConfigManager(); + } + return sOplusFeatureConfigManager; + } + + public boolean hasFeature(String name) { + if ("oplus.software.vibrator_lmvibrator".equals(name)) { + return true; + } + return false; + } +} diff --git a/oplus-fwk/src/com/oplus/orms/OplusResourceManager.java b/oplus-fwk/src/com/oplus/orms/OplusResourceManager.java new file mode 100644 index 0000000..c0800c9 --- /dev/null +++ b/oplus-fwk/src/com/oplus/orms/OplusResourceManager.java @@ -0,0 +1,19 @@ +package com.oplus.orms; + +import com.oplus.orms.info.OrmsSaParam; + +public class OplusResourceManager { + + private static OplusResourceManager sOplusResourceManager = null; + + public static OplusResourceManager getInstance(Class clazz) { + if (sOplusResourceManager == null) { + sOplusResourceManager = new OplusResourceManager(); + } + return sOplusResourceManager; + } + + public long ormsSetSceneAction(OrmsSaParam ormsSaParam) { + return -1L; + } +} diff --git a/oplus-fwk/src/com/oplus/orms/info/OrmsSaParam.java b/oplus-fwk/src/com/oplus/orms/info/OrmsSaParam.java new file mode 100644 index 0000000..1e49be4 --- /dev/null +++ b/oplus-fwk/src/com/oplus/orms/info/OrmsSaParam.java @@ -0,0 +1,8 @@ +package com.oplus.orms.info; + +public class OrmsSaParam { + + public OrmsSaParam() {} + + public OrmsSaParam(String scene, String action, int timeout) {} +} diff --git a/oplus-fwk/src/com/oplus/os/OplusBuild.java b/oplus-fwk/src/com/oplus/os/OplusBuild.java new file mode 100644 index 0000000..289a66b --- /dev/null +++ b/oplus-fwk/src/com/oplus/os/OplusBuild.java @@ -0,0 +1,15 @@ +package com.oplus.os; + +public class OplusBuild { + public static final int OplusOS_11_3 = 22; + + public static int getOplusOSVERSION() { + return 23; + } + + public static class VERSION { + public static final String RELEASE = "unknown"; + public static final int SDK_VERSION = getOplusOSVERSION(); + public static final int SDK_SUB_VERSION = 1; + } +} diff --git a/oplus-fwk/src/com/oplus/os/OplusUsbEnvironment.java b/oplus-fwk/src/com/oplus/os/OplusUsbEnvironment.java new file mode 100644 index 0000000..55afb7a --- /dev/null +++ b/oplus-fwk/src/com/oplus/os/OplusUsbEnvironment.java @@ -0,0 +1,156 @@ +package com.oplus.os; + +import android.content.Context; +import android.os.Environment; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.UserHandle; +import android.os.storage.DiskInfo; +import android.os.storage.IStorageManager; +import android.os.storage.StorageManager; +import android.os.storage.VolumeInfo; +import android.util.Log; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +public class OplusUsbEnvironment extends Environment { + + private static final String TAG = "OplusUsbEnvironment"; + private static final String DEFAULT_INTERNAL_PATH = "/storage/emulated/0"; + + private static IStorageManager sMountService = null; + private static Object sLock = new Object(); + private static String sExternalSdDir = null; + private static String sInternalSdDir = DEFAULT_INTERNAL_PATH; + private static ArrayList sOtgPathes = new ArrayList<>(); + + private static void update(Context context) { + if (sMountService == null) { + sMountService = IStorageManager.Stub.asInterface(ServiceManager.getService("mount")); + } + getVolumes(); + } + + public static File getExternalSdDirectory(Context context) { + String path; + synchronized (sLock) { + update(context); + path = sExternalSdDir; + } + if (path == null) { + return null; + } + return new File(path); + } + + public static String getExternalSdState(Context context) { + String path; + final StorageManager sm = (StorageManager) context.getSystemService("storage"); + synchronized (sLock) { + update(context); + path = sExternalSdDir; + } + if (path == null || sm == null) { + return "unknown"; + } + return sm.getVolumeState(path); + } + + public static String getExternalPath(Context context) { + String path; + synchronized (sLock) { + update(context); + path = sExternalSdDir; + } + return path; + } + + public static File getInternalSdDirectory(Context context) { + String path; + synchronized (sLock) { + update(context); + path = sInternalSdDir; + } + if (path == null) { + return null; + } + return new File(path); + } + + public static String getInternalSdState(Context context) { + String path; + final StorageManager sm = (StorageManager) context.getSystemService("storage"); + synchronized (sLock) { + update(context); + path = sInternalSdDir; + } + if (path == null || sm == null) { + return "unknown"; + } + return sm.getVolumeState(path); + } + + public static String getInternalPath(Context context) { + String path; + synchronized (sLock) { + update(context); + path = sInternalSdDir; + } + return path; + } + + public static List getOtgPath(Context context) { + synchronized (sLock) { + update(context); + if (sOtgPathes == null) { + return null; + } + return (ArrayList) sOtgPathes.clone(); + } + } + + public static void getVolumes() { + if (sMountService == null) { + Log.e(TAG, "getVolumes: sMountService is null!!!"); + return; + } + try { + final VolumeInfo[] vols = sMountService.getVolumes(0); + sExternalSdDir = null; + sOtgPathes.clear(); + for (VolumeInfo vol : vols) { + final String path = vol.path; + if (vol.type == 2) { + final int userId = UserHandle.myUserId(); + if (path != null) { + sInternalSdDir = path.concat("/").concat(Integer.toString(userId)); + } + } else { + final DiskInfo diskInfo = vol.getDisk(); + if (diskInfo != null) { + if (diskInfo.isSd() && path != null) { + sExternalSdDir = path; + } + if (diskInfo.isUsb() && path != null && !sOtgPathes.contains(path)) { + sOtgPathes.add(path); + } + } + } + } + } catch (RemoteException e) { + } + } + + public static boolean isVolumeMounted(Context context, String path) { + synchronized (sLock) { + update(context); + } + final StorageManager sm = (StorageManager) context.getSystemService("storage"); + if (path == null || sm == null) { + return false; + } + return "mounted".equals(sm.getVolumeState(path)); + } +} diff --git a/oplus-fwk/src/com/oplus/os/WaveformEffect.java b/oplus-fwk/src/com/oplus/os/WaveformEffect.java new file mode 100644 index 0000000..acebf4f --- /dev/null +++ b/oplus-fwk/src/com/oplus/os/WaveformEffect.java @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2022 The Nameless-AOSP Project + * SPDX-License-Identifier: Apache-2.0 + */ + +package com.oplus.os; + +import android.os.Parcel; +import android.os.Parcelable; +import android.util.Slog; + +public class WaveformEffect implements Parcelable { + + private static final String TAG = "WaveformEffect"; + + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + @Override + public WaveformEffect createFromParcel(Parcel in) { + return new WaveformEffect(in); + } + + @Override + public WaveformEffect[] newArray(int size) { + return new WaveformEffect[size]; + } + }; + + private int mEffectType; + private boolean mEffectLoop; + private boolean mStrengthSettingEnabled; + + private WaveformEffect() { + mEffectType = -1; + mEffectLoop = false; + mStrengthSettingEnabled = false; + } + + public int getEffectType() { + return mEffectType; + } + + public boolean getEffectLoop() { + return mEffectLoop; + } + + public boolean getStrengthSettingEnabled() { + return mStrengthSettingEnabled; + } + + public static class Builder { + private int mEffectType; + private boolean mEffectLoop; + private boolean mStrengthSettingEnabled; + + public Builder() { + mEffectType = -1; + mEffectLoop = false; + mStrengthSettingEnabled = false; + } + + public Builder(WaveformEffect effect) { + mEffectType = -1; + mEffectLoop = false; + mStrengthSettingEnabled = false; + } + + public WaveformEffect build() { + WaveformEffect effect = new WaveformEffect(); + effect.mEffectType = mEffectType; + effect.mEffectLoop = mEffectLoop; + effect.mStrengthSettingEnabled = mStrengthSettingEnabled; + return effect; + } + + public Builder setEffectType(int type) { + mEffectType = type; + return this; + } + + public Builder setEffectLoop(boolean loop) { + mEffectLoop = loop; + return this; + } + + public Builder setStrengthSettingEnabled(boolean enabled) { + mStrengthSettingEnabled = enabled; + return this; + } + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(mEffectType); + dest.writeBoolean(mEffectLoop); + dest.writeBoolean(mStrengthSettingEnabled); + } + + private WaveformEffect(Parcel in) { + mEffectType = in.readInt(); + mEffectLoop = in.readBoolean(); + mStrengthSettingEnabled = in.readBoolean(); + } + + @Override + public String toString() { + return String.valueOf(mEffectType); + } +} diff --git a/oplus-fwk/src/com/oplus/osense/OsenseResClient.java b/oplus-fwk/src/com/oplus/osense/OsenseResClient.java new file mode 100644 index 0000000..5688051 --- /dev/null +++ b/oplus-fwk/src/com/oplus/osense/OsenseResClient.java @@ -0,0 +1,8 @@ +package com.oplus.osense; + +public class OsenseResClient { + + public static OsenseResClient get(Class clazz) { + return null; + } +} diff --git a/oplus-fwk/src/com/oplus/osense/OsenseResEventClient.java b/oplus-fwk/src/com/oplus/osense/OsenseResEventClient.java new file mode 100644 index 0000000..27da765 --- /dev/null +++ b/oplus-fwk/src/com/oplus/osense/OsenseResEventClient.java @@ -0,0 +1,20 @@ +package com.oplus.osense; + +public class OsenseResEventClient { + + private static volatile OsenseResEventClient sInstance; + + private OsenseResEventClient() { + } + + public static OsenseResEventClient getInstance() { + if (sInstance == null) { + synchronized (OsenseResEventClient.class) { + if (sInstance == null) { + sInstance = new OsenseResEventClient(); + } + } + } + return sInstance; + } +} diff --git a/oplus-fwk/src/com/oplus/osense/eventinfo/IOsenseEventCallback.java b/oplus-fwk/src/com/oplus/osense/eventinfo/IOsenseEventCallback.java new file mode 100644 index 0000000..80692ed --- /dev/null +++ b/oplus-fwk/src/com/oplus/osense/eventinfo/IOsenseEventCallback.java @@ -0,0 +1,25 @@ +package com.oplus.osense.eventinfo; + +import android.os.Binder; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Parcel; +import android.os.RemoteException; + +/* loaded from: classes.dex */ +public interface IOsenseEventCallback extends IInterface { + + public static class Default implements IOsenseEventCallback { + @Override // android.os.IInterface + public IBinder asBinder() { + return null; + } + } + + public static abstract class Stub extends Binder implements IOsenseEventCallback { + @Override // android.os.IInterface + public IBinder asBinder() { + return this; + } + } +} diff --git a/oplus-fwk/src/com/oplus/osense/eventinfo/OsenseEventCallback.java b/oplus-fwk/src/com/oplus/osense/eventinfo/OsenseEventCallback.java new file mode 100644 index 0000000..5201a1e --- /dev/null +++ b/oplus-fwk/src/com/oplus/osense/eventinfo/OsenseEventCallback.java @@ -0,0 +1,7 @@ +package com.oplus.osense.eventinfo; + +import com.oplus.osense.eventinfo.IOsenseEventCallback; + +public class OsenseEventCallback extends IOsenseEventCallback.Stub { + +} diff --git a/oplus-fwk/src/com/oplus/screenshot/OplusLongshotCustomController.java b/oplus-fwk/src/com/oplus/screenshot/OplusLongshotCustomController.java new file mode 100644 index 0000000..0bb6f84 --- /dev/null +++ b/oplus-fwk/src/com/oplus/screenshot/OplusLongshotCustomController.java @@ -0,0 +1,6 @@ +package com.oplus.screenshot; + +public class OplusLongshotCustomController { + + public OplusLongshotCustomController(OplusLongshotViewBase view, String source) {} +} diff --git a/oplus-fwk/src/com/oplus/screenshot/OplusLongshotViewBase.java b/oplus-fwk/src/com/oplus/screenshot/OplusLongshotViewBase.java new file mode 100644 index 0000000..4b30002 --- /dev/null +++ b/oplus-fwk/src/com/oplus/screenshot/OplusLongshotViewBase.java @@ -0,0 +1,20 @@ +package com.oplus.screenshot; + +import android.content.Context; + +public interface OplusLongshotViewBase { + + boolean canLongScroll(); + + int computeLongScrollExtent(); + + int computeLongScrollOffset(); + + int computeLongScrollRange(); + + boolean findViewsLongshotInfo(OplusLongshowViewInfo oplusLongshowViewInfo); + + Context getContext(); + + boolean isLongshotVisibleToUser(); +} diff --git a/oplus-fwk/src/com/oplus/screenshot/OplusLongshowViewInfo.java b/oplus-fwk/src/com/oplus/screenshot/OplusLongshowViewInfo.java new file mode 100644 index 0000000..ca45f7f --- /dev/null +++ b/oplus-fwk/src/com/oplus/screenshot/OplusLongshowViewInfo.java @@ -0,0 +1,6 @@ +package com.oplus.screenshot; + +public class OplusLongshowViewInfo { + + public OplusLongshowViewInfo() {} +} diff --git a/oplus-fwk/src/com/oplus/uifirst/OplusUIFirstManager.java b/oplus-fwk/src/com/oplus/uifirst/OplusUIFirstManager.java new file mode 100644 index 0000000..71823b7 --- /dev/null +++ b/oplus-fwk/src/com/oplus/uifirst/OplusUIFirstManager.java @@ -0,0 +1,16 @@ +package com.oplus.uifirst; + +public class OplusUIFirstManager { + + private static OplusUIFirstManager sOplusUIFirstManager = null; + + public static OplusUIFirstManager getInstance() { + if (sOplusUIFirstManager == null) { + sOplusUIFirstManager = new OplusUIFirstManager(); + } + return sOplusUIFirstManager; + } + + public void setUxThreadValue(int pid, int tid, String value) { + } +} diff --git a/oplus-fwk/src/com/oplus/util/OplusChangeTextUtil.java b/oplus-fwk/src/com/oplus/util/OplusChangeTextUtil.java new file mode 100644 index 0000000..0092bff --- /dev/null +++ b/oplus-fwk/src/com/oplus/util/OplusChangeTextUtil.java @@ -0,0 +1,52 @@ +package com.oplus.util; + +public class OplusChangeTextUtil { + + private static final String TAG = "OplusChangeTextUtil"; + + private static final float H1 = 0.9f; + private static final float H2 = 1.0f; + private static final float H3 = 1.1f; + private static final float H4 = 1.25f; + private static final float H5 = 1.45f; + private static final float H6 = 1.65f; + + public static final int G1 = 1; + public static final int G2 = 2; + public static final int G3 = 3; + public static final int G4 = 4; + public static final int G5 = 5; + public static final int G6 = 6; + + public static final float[] SCALE_LEVEL = {H1, H2, H3, H4, H5, H6}; + + public static float getSuitableFontSize(float textSize, float scale, int level) { + if (level < 2) { + return textSize; + } + if (level > SCALE_LEVEL.length) { + level = SCALE_LEVEL.length; + } + final float textSizeNoScale = textSize / scale; + switch (level) { + case G2: + if (scale < H3) { + return H2 * textSizeNoScale; + } + return H3 * textSizeNoScale; + case G3: + if (scale < H3) { + return H2 * textSizeNoScale; + } + if (scale < H5) { + return H3 * textSizeNoScale; + } + return H4 * textSizeNoScale; + default: + if (scale > SCALE_LEVEL[level - 1]) { + return SCALE_LEVEL[level - 1] * textSizeNoScale; + } + return textSizeNoScale * scale; + } + } +} diff --git a/oplus-fwk/src/com/oplus/util/OplusNetworkUtils.java b/oplus-fwk/src/com/oplus/util/OplusNetworkUtils.java new file mode 100644 index 0000000..fa8c64e --- /dev/null +++ b/oplus-fwk/src/com/oplus/util/OplusNetworkUtils.java @@ -0,0 +1,40 @@ +package com.oplus.util; + +import android.content.Context; +import android.content.Intent; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.net.Uri; + +public class OplusNetworkUtils { + + private static final String DEFAULT_HTTP_URI = "http://connectivitycheck.gstatic.com/generate_204"; + + public static boolean isWifiConnected(Context context) { + ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + if (cm != null) { + return cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState() + == NetworkInfo.State.CONNECTED; + } + return false; + } + + public static boolean isMobileDataConnected(Context context) { + ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + if (cm != null) { + return cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState() + == NetworkInfo.State.CONNECTED; + } + return false; + } + + public static void onClickLoginBtn(Context context) { + Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(DEFAULT_HTTP_URI)); + intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT); + context.startActivity(intent); + } + + public static int getErrorString(Context context, String url) { + return 1; + } +} diff --git a/oplus-fwk/src/com/oplus/util/OplusTypeCastingHelper.java b/oplus-fwk/src/com/oplus/util/OplusTypeCastingHelper.java new file mode 100644 index 0000000..3d44316 --- /dev/null +++ b/oplus-fwk/src/com/oplus/util/OplusTypeCastingHelper.java @@ -0,0 +1,6 @@ +package com.oplus.util; + +public class OplusTypeCastingHelper { + + public OplusTypeCastingHelper() {} +} diff --git a/oplus-fwk/src/com/oplus/wrapper/os/PowerManager.java b/oplus-fwk/src/com/oplus/wrapper/os/PowerManager.java new file mode 100644 index 0000000..20b682c --- /dev/null +++ b/oplus-fwk/src/com/oplus/wrapper/os/PowerManager.java @@ -0,0 +1,14 @@ +package com.oplus.wrapper.os; + +public class PowerManager { + + private final android.os.PowerManager mPowerManager; + + public PowerManager(android.os.PowerManager powerManager) { + mPowerManager = powerManager; + } + + public int getMaximumScreenBrightnessSetting() { + return mPowerManager.getMaximumScreenBrightnessSetting(); + } +} diff --git a/oplus-fwk/src/com/oplus/wrapper/os/ServiceManager.java b/oplus-fwk/src/com/oplus/wrapper/os/ServiceManager.java new file mode 100644 index 0000000..cc52029 --- /dev/null +++ b/oplus-fwk/src/com/oplus/wrapper/os/ServiceManager.java @@ -0,0 +1,17 @@ +package com.oplus.wrapper.os; + +import android.os.IBinder; + +public class ServiceManager { + public static void addService(String paramString, IBinder paramIBinder) { + android.os.ServiceManager.addService(paramString, paramIBinder); + } + + public static IBinder checkService(String paramString) { + return android.os.ServiceManager.checkService(paramString); + } + + public static IBinder getService(String paramString) { + return android.os.ServiceManager.getService(paramString); + } +} diff --git a/oplus-fwk/src/com/oplus/wrapper/os/SystemProperties.java b/oplus-fwk/src/com/oplus/wrapper/os/SystemProperties.java new file mode 100644 index 0000000..1235d65 --- /dev/null +++ b/oplus-fwk/src/com/oplus/wrapper/os/SystemProperties.java @@ -0,0 +1,24 @@ +package com.oplus.wrapper.os; + +public class SystemProperties { + + public static String get(String key) { + return android.os.SystemProperties.get(key, ""); + } + + public static String get(String key, String def) { + return android.os.SystemProperties.get(key, def); + } + + public static int getInt(String key, int def) { + return android.os.SystemProperties.getInt(key, def); + } + + public static boolean getBoolean(String key, boolean def) { + return android.os.SystemProperties.getBoolean(key, def); + } + + public static void set(String key, String val) { + android.os.SystemProperties.set(key, val); + } +} diff --git a/oplus-fwk/src/com/oplus/wrapper/view/IWindowManager.java b/oplus-fwk/src/com/oplus/wrapper/view/IWindowManager.java new file mode 100644 index 0000000..b8ad089 --- /dev/null +++ b/oplus-fwk/src/com/oplus/wrapper/view/IWindowManager.java @@ -0,0 +1,658 @@ +package com.oplus.wrapper.view; + +import android.app.IAssistDataReceiver; +import android.content.ComponentName; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.graphics.Point; +import android.graphics.Rect; +import android.graphics.Region; +import android.os.Bundle; +import android.os.IBinder; +import android.os.IInterface; +import android.os.IRemoteCallback; +import android.os.RemoteException; +import android.view.IAppTransitionAnimationSpecsFuture; +import android.view.ICrossWindowBlurEnabledListener; +import android.view.IDisplayChangeWindowController; +import android.view.IDisplayFoldListener; +import android.view.IDisplayWindowInsetsController; +import android.view.IDisplayWindowListener; +import android.view.IOnKeyguardExitResult; +import android.view.IPinnedTaskListener; +import android.view.IRotationWatcher; +import android.view.IScrollCaptureResponseListener; +import android.view.ISystemGestureExclusionListener; +import android.view.IWallpaperVisibilityListener; +import android.view.IWindow; +import android.view.IWindowSession; +import android.view.IWindowSessionCallback; +import android.view.InputChannel; +import android.view.InsetsState; +import android.view.TaskTransitionSpec; +import android.view.WindowContentFrameStats; +import android.view.displayhash.DisplayHash; +import android.view.displayhash.VerifiedDisplayHash; +import android.window.AddToSurfaceSyncGroupResult; +import android.window.ISurfaceSyncGroupCompletedListener; +import android.window.ITaskFpsCallback; +import android.window.ScreenCapture; +import com.android.internal.os.IResultReceiver; +import com.android.internal.policy.IKeyguardDismissCallback; +import com.android.internal.policy.IKeyguardLockedStateListener; +import com.android.internal.policy.IShortcutService; +import com.oplus.wrapper.view.IWindowManager; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Function; + +/* loaded from: classes.dex */ +public interface IWindowManager { + int getBaseDisplayDensity(int i) throws RemoteException; + + void getBaseDisplaySize(int i, Point point) throws RemoteException; + + int getDockedStackSide() throws RemoteException; + + int getInitialDisplayDensity(int i) throws RemoteException; + + boolean hasNavigationBar(int i) throws RemoteException; + + void removeRotationWatcher(IRotationWatcher iRotationWatcher) throws RemoteException; + + void setForcedDisplayDensityForUser(int i, int i2, int i3) throws RemoteException; + + int watchRotation(IRotationWatcher iRotationWatcher, int i) throws RemoteException; + + /* loaded from: classes.dex */ + public static abstract class Stub implements android.os.IInterface, android.view.IWindowManager { + private final android.view.IWindowManager mIWindowManager = new android.view.IWindowManager.Stub() { // from class: com.oplus.wrapper.view.IWindowManager.Stub.1 + public boolean startViewServer(int i) throws RemoteException { + return false; + } + + public boolean stopViewServer() throws RemoteException { + return false; + } + + public boolean isViewServerRunning() throws RemoteException { + return false; + } + + public IWindowSession openSession(IWindowSessionCallback iWindowSessionCallback) throws RemoteException { + return null; + } + + public boolean useBLAST() throws RemoteException { + return false; + } + + public void getInitialDisplaySize(int i, Point point) throws RemoteException { + } + + public void getBaseDisplaySize(int displayId, Point size) throws RemoteException { + getBaseDisplaySize(displayId, size); + } + + public void setForcedDisplaySize(int i, int i1, int i2) throws RemoteException { + } + + public void clearForcedDisplaySize(int i) throws RemoteException { + } + + public int getInitialDisplayDensity(int displayId) throws RemoteException { + return getInitialDisplayDensity(displayId); + } + + public int getBaseDisplayDensity(int displayId) throws RemoteException { + return getBaseDisplayDensity(displayId); + } + + public void setForcedDisplayDensityForUser(int i, int i1, int i2) throws RemoteException { + setForcedDisplayDensityForUser(i, i1, i2); + } + + public void clearForcedDisplayDensityForUser(int i, int i1) throws RemoteException { + } + + public void setForcedDisplayScalingMode(int i, int i1) throws RemoteException { + } + + public void setEventDispatching(boolean b) throws RemoteException { + } + + public boolean isWindowToken(IBinder iBinder) throws RemoteException { + return false; + } + + public void addWindowToken(IBinder iBinder, int i, int i1, Bundle bundle) throws RemoteException { + } + + public void removeWindowToken(IBinder iBinder, int i) throws RemoteException { + } + + public void setDisplayChangeWindowController(IDisplayChangeWindowController controller) throws RemoteException { + } + + public android.view.SurfaceControl addShellRoot(int i, IWindow iWindow, int i1) throws RemoteException { + return null; + } + + public void setShellRootAccessibilityWindow(int i, int i1, IWindow iWindow) throws RemoteException { + } + + public void overridePendingAppTransitionMultiThumbFuture(IAppTransitionAnimationSpecsFuture iAppTransitionAnimationSpecsFuture, IRemoteCallback iRemoteCallback, boolean b, int i) throws RemoteException { + } + + public void overridePendingAppTransitionRemote(android.view.RemoteAnimationAdapter remoteAnimationAdapter, int i) throws RemoteException { + } + + public void endProlongedAnimations() throws RemoteException { + } + + public void startFreezingScreen(int i, int i1) throws RemoteException { + } + + public void stopFreezingScreen() throws RemoteException { + } + + public void disableKeyguard(IBinder iBinder, String s, int i) throws RemoteException { + } + + public void reenableKeyguard(IBinder iBinder, int i) throws RemoteException { + } + + public void exitKeyguardSecurely(IOnKeyguardExitResult iOnKeyguardExitResult) throws RemoteException { + } + + public boolean isKeyguardLocked() throws RemoteException { + return false; + } + + public boolean isKeyguardSecure(int i) throws RemoteException { + return false; + } + + public void dismissKeyguard(IKeyguardDismissCallback iKeyguardDismissCallback, CharSequence charSequence) throws RemoteException { + } + + public void addKeyguardLockedStateListener(IKeyguardLockedStateListener iKeyguardLockedStateListener) throws RemoteException { + } + + public void removeKeyguardLockedStateListener(IKeyguardLockedStateListener iKeyguardLockedStateListener) throws RemoteException { + } + + public void setSwitchingUser(boolean b) throws RemoteException { + } + + public void closeSystemDialogs(String s) throws RemoteException { + } + + public float getAnimationScale(int i) throws RemoteException { + return 0.0f; + } + + public float[] getAnimationScales() throws RemoteException { + return new float[0]; + } + + public void setAnimationScale(int i, float v) throws RemoteException { + } + + public void setAnimationScales(float[] floats) throws RemoteException { + } + + public float getCurrentAnimatorScale() throws RemoteException { + return 0.0f; + } + + public void setInTouchMode(boolean b, int displayId) throws RemoteException { + } + + public void setInTouchModeOnAllDisplays(boolean inTouch) throws RemoteException { + } + + public boolean isInTouchMode(int displayId) throws RemoteException { + return false; + } + + public void showStrictModeViolation(boolean b) throws RemoteException { + } + + public void setStrictModeVisualIndicatorPreference(String s) throws RemoteException { + } + + public void refreshScreenCaptureDisabled() throws RemoteException { + } + + public int getDefaultDisplayRotation() throws RemoteException { + return 0; + } + + public int watchRotation(final android.view.IRotationWatcher watcher, int displayId) throws RemoteException { + return 0; + } + + public void removeRotationWatcher(android.view.IRotationWatcher iRotationWatcher) throws RemoteException { + } + + public int registerProposedRotationListener(IBinder contextToken, android.view.IRotationWatcher listener) throws RemoteException { + return 0; + } + + public int getPreferredOptionsPanelGravity(int i) throws RemoteException { + return 0; + } + + public void freezeRotation(int i) throws RemoteException { + } + + public void thawRotation() throws RemoteException { + } + + public boolean isRotationFrozen() throws RemoteException { + return false; + } + + public void freezeDisplayRotation(int i, int i1) throws RemoteException { + } + + public void thawDisplayRotation(int i) throws RemoteException { + } + + public boolean isDisplayRotationFrozen(int i) throws RemoteException { + return false; + } + + public void setFixedToUserRotation(int i, int i1) throws RemoteException { + } + + public void setIgnoreOrientationRequest(int i, boolean b) throws RemoteException { + } + + public Bitmap screenshotWallpaper() throws RemoteException { + return null; + } + + public android.view.SurfaceControl mirrorWallpaperSurface(int i) throws RemoteException { + return null; + } + + public boolean registerWallpaperVisibilityListener(IWallpaperVisibilityListener iWallpaperVisibilityListener, int i) throws RemoteException { + return false; + } + + public void unregisterWallpaperVisibilityListener(IWallpaperVisibilityListener iWallpaperVisibilityListener, int i) throws RemoteException { + } + + public void registerSystemGestureExclusionListener(ISystemGestureExclusionListener iSystemGestureExclusionListener, int i) throws RemoteException { + } + + public void unregisterSystemGestureExclusionListener(ISystemGestureExclusionListener iSystemGestureExclusionListener, int i) throws RemoteException { + } + + public boolean requestAssistScreenshot(IAssistDataReceiver iAssistDataReceiver) throws RemoteException { + return false; + } + + public void hideTransientBars(int i) throws RemoteException { + } + + public void setRecentsVisibility(boolean b) throws RemoteException { + } + + public void updateStaticPrivacyIndicatorBounds(int i, Rect[] rects) throws RemoteException { + } + + public void setNavBarVirtualKeyHapticFeedbackEnabled(boolean b) throws RemoteException { + } + + public boolean hasNavigationBar(int displayId) throws RemoteException { + return hasNavigationBar(displayId); + } + + public void lockNow(Bundle bundle) throws RemoteException { + } + + public boolean isSafeModeEnabled() throws RemoteException { + return false; + } + + public boolean clearWindowContentFrameStats(IBinder iBinder) throws RemoteException { + return false; + } + + public WindowContentFrameStats getWindowContentFrameStats(IBinder iBinder) throws RemoteException { + return null; + } + + public int getDockedStackSide() throws RemoteException { + return getDockedStackSide(); + } + + public void registerPinnedTaskListener(int i, IPinnedTaskListener iPinnedTaskListener) throws RemoteException { + } + + public void requestAppKeyboardShortcuts(IResultReceiver iResultReceiver, int i) throws RemoteException { + } + + public void requestImeKeyboardShortcuts(IResultReceiver iRsultReceiver, int i) throws RemoteException { + + } + + public void getStableInsets(int i, Rect rect) throws RemoteException { + } + + public void registerShortcutKey(long l, IShortcutService iShortcutService) throws RemoteException { + } + + public void createInputConsumer(IBinder iBinder, String s, int i, InputChannel inputChannel) throws RemoteException { + } + + public boolean destroyInputConsumer(String s, int i) throws RemoteException { + return false; + } + + public Region getCurrentImeTouchRegion() throws RemoteException { + return null; + } + + public void registerDisplayFoldListener(IDisplayFoldListener iDisplayFoldListener) throws RemoteException { + } + + public void unregisterDisplayFoldListener(IDisplayFoldListener iDisplayFoldListener) throws RemoteException { + } + + public int[] registerDisplayWindowListener(IDisplayWindowListener iDisplayWindowListener) throws RemoteException { + return new int[0]; + } + + public void unregisterDisplayWindowListener(IDisplayWindowListener iDisplayWindowListener) throws RemoteException { + } + + public void startWindowTrace() throws RemoteException { + } + + public void stopWindowTrace() throws RemoteException { + } + + public void saveWindowTraceToFile() throws RemoteException { + } + + public void startTransitionTrace() throws RemoteException { + } + + public void stopTransitionTrace() throws RemoteException { + } + + public boolean isWindowTraceEnabled() throws RemoteException { + return false; + } + + public boolean isTransitionTraceEnabled() throws RemoteException { + return false; + } + + public int getWindowingMode(int i) throws RemoteException { + return 0; + } + + public void setWindowingMode(int i, int i1) throws RemoteException { + } + + public int getRemoveContentMode(int i) throws RemoteException { + return 0; + } + + public void setRemoveContentMode(int i, int i1) throws RemoteException { + } + + public boolean shouldShowWithInsecureKeyguard(int i) throws RemoteException { + return false; + } + + public void setShouldShowWithInsecureKeyguard(int i, boolean b) throws RemoteException { + } + + public boolean shouldShowSystemDecors(int i) throws RemoteException { + return false; + } + + public void setShouldShowSystemDecors(int i, boolean b) throws RemoteException { + } + + public int getDisplayImePolicy(int i) throws RemoteException { + return 0; + } + + public void setDisplayImePolicy(int i, int i1) throws RemoteException { + } + + public void syncInputTransactions(boolean b) throws RemoteException { + } + + public boolean isLayerTracing() throws RemoteException { + return false; + } + + public void setLayerTracing(boolean b) throws RemoteException { + } + + public boolean mirrorDisplay(int i, android.view.SurfaceControl surfaceControl) throws RemoteException { + return false; + } + + public void setDisplayWindowInsetsController(int i, IDisplayWindowInsetsController iDisplayWindowInsetsController) throws RemoteException { + } + + public void updateDisplayWindowRequestedVisibleTypes(int displayId, int requestedVisibleTypes) throws RemoteException { + } + + public boolean getWindowInsets(int displayId, IBinder token, InsetsState insetsState) throws RemoteException { + return false; + } + + public List getPossibleDisplayInfo(int displayId) throws RemoteException { + return null; + } + + public int getDisplayIdByUniqueId(String uniqueId) throws RemoteException { + return -1; + } + + public void showGlobalActions() throws RemoteException { + } + + public void setLayerTracingFlags(int i) throws RemoteException { + } + + public void setActiveTransactionTracing(boolean active) throws RemoteException { + } + + public void requestScrollCapture(int i, IBinder iBinder, int i1, IScrollCaptureResponseListener iScrollCaptureResponseListener) throws RemoteException { + } + + public void holdLock(IBinder iBinder, int i) throws RemoteException { + } + + public String[] getSupportedDisplayHashAlgorithms() throws RemoteException { + return new String[0]; + } + + public VerifiedDisplayHash verifyDisplayHash(DisplayHash displayHash) throws RemoteException { + return null; + } + + public void setDisplayHashThrottlingEnabled(boolean b) throws RemoteException { + } + + public Configuration attachWindowContextToDisplayArea(IBinder iBinder, int i, int i1, Bundle bundle) throws RemoteException { + return null; + } + + public void attachWindowContextToWindowToken(IBinder iBinder, IBinder iBinder1) throws RemoteException { + } + + public Configuration attachToDisplayContent(IBinder iBinder, int i) throws RemoteException { + return null; + } + + public void detachWindowContextFromWindowContainer(IBinder iBinder) throws RemoteException { + } + + public boolean registerCrossWindowBlurEnabledListener(ICrossWindowBlurEnabledListener iCrossWindowBlurEnabledListener) throws RemoteException { + return false; + } + + public void unregisterCrossWindowBlurEnabledListener(ICrossWindowBlurEnabledListener iCrossWindowBlurEnabledListener) throws RemoteException { + } + + public boolean isTaskSnapshotSupported() throws RemoteException { + return false; + } + + public int getImeDisplayId() throws RemoteException { + return 0; + } + + public void setTaskSnapshotEnabled(boolean b) throws RemoteException { + } + + public void setTaskTransitionSpec(TaskTransitionSpec taskTransitionSpec) throws RemoteException { + } + + public void clearTaskTransitionSpec() throws RemoteException { + } + + public void registerTaskFpsCallback(int i, ITaskFpsCallback iTaskFpsCallback) throws RemoteException { + } + + public void unregisterTaskFpsCallback(ITaskFpsCallback iTaskFpsCallback) throws RemoteException { + } + + public Bitmap snapshotTaskForRecents(int i) throws RemoteException { + return null; + } + + public void setRecentsAppBehindSystemBars(boolean b) throws RemoteException { + } + + public int getLetterboxBackgroundColorInArgb() { + return -1; + } + + public boolean isLetterboxBackgroundMultiColored() { + return false; + } + + public void captureDisplay(int displayId, ScreenCapture.CaptureArgs captureArgs, ScreenCapture.ScreenCaptureListener listener) { + } + + public boolean isGlobalKey(int keyCode) throws RemoteException { + return false; + } + + public boolean addToSurfaceSyncGroup(IBinder syncGroupToken, boolean parentSyncGroupMerge, ISurfaceSyncGroupCompletedListener completedListener, AddToSurfaceSyncGroupResult addToSurfaceSyncGroupResult) { + return false; + } + + public void markSurfaceSyncGroupReady(IBinder syncGroupToken) { + } + + public List notifyScreenshotListeners(int displayId) { + return null; + } + + public void takeScreenshotExt(boolean capturePhysicalDisplay) { + } + + public void onOverlayChanged() { + } + }; + + public static IWindowManager asInterface(IBinder obj) { + return new Proxy(android.view.IWindowManager.Stub.asInterface(obj)); + } + + @Override // android.os.IInterface + public IBinder asBinder() { + return this.mIWindowManager.asBinder(); + } + + /* JADX INFO: Access modifiers changed from: private */ + /* loaded from: classes.dex */ + public static class Proxy implements IWindowManager { + private static Map sRotationWatcherMap = new ConcurrentHashMap(); + private final android.view.IWindowManager mIWindowManager; + + Proxy(android.view.IWindowManager iWindowManager) { + this.mIWindowManager = iWindowManager; + } + + @Override // com.oplus.wrapper.view.IWindowManager + public int getDockedStackSide() throws RemoteException { + return this.mIWindowManager.getDockedStackSide(); + } + + @Override // com.oplus.wrapper.view.IWindowManager + public int getInitialDisplayDensity(int displayId) throws RemoteException { + return this.mIWindowManager.getInitialDisplayDensity(displayId); + } + + @Override // com.oplus.wrapper.view.IWindowManager + public boolean hasNavigationBar(int displayId) throws RemoteException { + return this.mIWindowManager.hasNavigationBar(displayId); + } + + @Override // com.oplus.wrapper.view.IWindowManager + public int watchRotation(IRotationWatcher watcher, int displayId) throws RemoteException { + android.view.IRotationWatcher rotationWatcher = sRotationWatcherMap.computeIfAbsent(watcher, new Function() { // from class: com.oplus.wrapper.view.IWindowManager$Stub$Proxy$$ExternalSyntheticLambda0 + @Override // java.util.function.Function + public final Object apply(Object obj) { + android.view.IRotationWatcher lambda$watchRotation$0; + lambda$watchRotation$0 = IWindowManager.Stub.Proxy.this.lambda$watchRotation$0((IRotationWatcher) obj); + return lambda$watchRotation$0; + } + }); + return this.mIWindowManager.watchRotation(rotationWatcher, displayId); + } + + /* JADX INFO: Access modifiers changed from: private */ + public /* synthetic */ android.view.IRotationWatcher lambda$watchRotation$0(final IRotationWatcher observer) { + return new IRotationWatcher.Stub() { // from class: com.oplus.wrapper.view.IWindowManager.Stub.Proxy.1 + public void onRotationChanged(int rotation) throws RemoteException { + observer.onRotationChanged(rotation); + } + }; + } + + @Override // com.oplus.wrapper.view.IWindowManager + public void removeRotationWatcher(IRotationWatcher watcher) throws RemoteException { + android.view.IRotationWatcher rotationWatcher = sRotationWatcherMap.get(watcher); + if (rotationWatcher == null) { + return; + } + sRotationWatcherMap.remove(watcher); + this.mIWindowManager.removeRotationWatcher(rotationWatcher); + } + + @Override // com.oplus.wrapper.view.IWindowManager + public void setForcedDisplayDensityForUser(int displayId, int density, int userId) throws RemoteException { + this.mIWindowManager.setForcedDisplayDensityForUser(displayId, density, userId); + } + + @Override // com.oplus.wrapper.view.IWindowManager + public int getBaseDisplayDensity(int displayId) throws RemoteException { + return this.mIWindowManager.getBaseDisplayDensity(displayId); + } + + @Override // com.oplus.wrapper.view.IWindowManager + public void getBaseDisplaySize(int displayId, Point size) throws RemoteException { + this.mIWindowManager.getBaseDisplaySize(displayId, size); + } + } + } +} + diff --git a/oplus-fwk/src/com/oplus/zoomwindow/IOplusZoomWindowObserver.aidl b/oplus-fwk/src/com/oplus/zoomwindow/IOplusZoomWindowObserver.aidl new file mode 100644 index 0000000..b4c5b5f --- /dev/null +++ b/oplus-fwk/src/com/oplus/zoomwindow/IOplusZoomWindowObserver.aidl @@ -0,0 +1,11 @@ +package com.oplus.zoomwindow; + +import com.oplus.zoomwindow.OplusZoomWindowInfo; + +interface IOplusZoomWindowObserver { + + void onInputMethodChanged(boolean z); + void onZoomWindowDied(String str); + void onZoomWindowHide(inout OplusZoomWindowInfo oplusZoomWindowInfo); + void onZoomWindowShow(inout OplusZoomWindowInfo oplusZoomWindowInfo); +} diff --git a/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowInfo.aidl b/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowInfo.aidl new file mode 100644 index 0000000..b715f8c --- /dev/null +++ b/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowInfo.aidl @@ -0,0 +1,3 @@ +package com.oplus.zoomwindow; + +parcelable OplusZoomWindowInfo; diff --git a/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowInfo.java b/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowInfo.java new file mode 100644 index 0000000..e0a4276 --- /dev/null +++ b/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowInfo.java @@ -0,0 +1,37 @@ +package com.oplus.zoomwindow; + +import android.os.Parcel; +import android.os.Parcelable; + +public class OplusZoomWindowInfo implements Parcelable { + + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + + @Override + public OplusZoomWindowInfo createFromParcel(Parcel source) { + return new OplusZoomWindowInfo(source); + } + + @Override + public OplusZoomWindowInfo[] newArray(int size) { + return new OplusZoomWindowInfo[size]; + } + }; + + public OplusZoomWindowInfo() {} + + public OplusZoomWindowInfo(Parcel in) {} + + public OplusZoomWindowInfo(OplusZoomWindowInfo in) {} + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) {} + + public void readFromParcel(Parcel in) {} +} diff --git a/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowManager.java b/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowManager.java new file mode 100644 index 0000000..10dba51 --- /dev/null +++ b/oplus-fwk/src/com/oplus/zoomwindow/OplusZoomWindowManager.java @@ -0,0 +1,21 @@ +package com.oplus.zoomwindow; + +public class OplusZoomWindowManager { + + public static OplusZoomWindowManager sOplusZoomWindowManager = null; + + public static OplusZoomWindowManager getInstance() { + if (sOplusZoomWindowManager == null) { + sOplusZoomWindowManager = new OplusZoomWindowManager(); + } + return sOplusZoomWindowManager; + } + + public boolean registerZoomWindowObserver(IOplusZoomWindowObserver observer) { + return false; + } + + public boolean unregisterZoomWindowObserver(IOplusZoomWindowObserver observer) { + return false; + } +} diff --git a/oplus-fwk/src/net/oneplus/odm/OpDeviceManagerInjector.java b/oplus-fwk/src/net/oneplus/odm/OpDeviceManagerInjector.java new file mode 100644 index 0000000..2eda0e0 --- /dev/null +++ b/oplus-fwk/src/net/oneplus/odm/OpDeviceManagerInjector.java @@ -0,0 +1,19 @@ +package net.oneplus.odm; + +import android.content.Context; + +import java.util.Map; + +public class OpDeviceManagerInjector { + + private static OpDeviceManagerInjector sOpDeviceManagerInjector = null; + + public void preserveAppData(Context a, String b, Map c, Map d) {} + + public static OpDeviceManagerInjector getInstance() { + if (sOpDeviceManagerInjector == null) { + sOpDeviceManagerInjector = new OpDeviceManagerInjector(); + } + return sOpDeviceManagerInjector; + } +} diff --git a/oplus-fwk/src/oplus/content/res/OplusExtraConfiguration.java b/oplus-fwk/src/oplus/content/res/OplusExtraConfiguration.java new file mode 100644 index 0000000..d9206c3 --- /dev/null +++ b/oplus-fwk/src/oplus/content/res/OplusExtraConfiguration.java @@ -0,0 +1,6 @@ +package oplus.content.res; + +public class OplusExtraConfiguration { + + public OplusExtraConfiguration() {} +} diff --git a/opluscamera.mk b/opluscamera.mk new file mode 100644 index 0000000..94744ae --- /dev/null +++ b/opluscamera.mk @@ -0,0 +1,32 @@ +# Framework +PRODUCT_PACKAGES += \ + oplus-fwk + +PRODUCT_BOOT_JARS += \ + oplus-fwk \ + oplus-support-wrapper + +# Init +PRODUCT_PACKAGES += \ + init.oplus.camera.rc + +# Permissions +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/configs/permissions/oplus_google_lens_config.xml:$(TARGET_COPY_OUT_SYSTEM_EXT)/etc/permissions/oplus_google_lens_config.xml \ + $(LOCAL_PATH)/configs/permissions/privapp-permissions-oplus.xml:$(TARGET_COPY_OUT_SYSTEM_EXT)/etc/permissions/privapp-permissions-oplus.xml \ + $(LOCAL_PATH)/configs/sysconfig/hiddenapi-package-oplus-whitelist.xml:$(TARGET_COPY_OUT_SYSTEM)/etc/sysconfig/hiddenapi-package-oplus-whitelist.xml + +# Properties +PRODUCT_PRODUCT_PROPERTIES += \ + persist.vendor.camera.privapp.list=com.oplus.camera \ + ro.com.google.lens.oem_camera_package=com.oplus.camera \ + ro.com.google.lens.oem_image_package=com.oneplus.gallery + +# Photo +TARGET_USES_OPLUS_CAMERA := true + +# Video +TARGET_CAMERA_OVERRIDE_FORMAT_FROM_RESERVED := true + +# Inherit from camera-vendor.mk +$(call inherit-product, vendor/oplus/camera/camera-vendor.mk)