aixan/lawnchair
1
0
Fork 0
mirror of https://github.com/LawnchairLauncher/lawnchair.git synced 2026-03-04 18:06:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix build launcher3 src

Browse Source
This commit is contained in:
MrSluffy
2024-10-13 08:08:22 +08:00
parent 457841ff5b
commit 67f1da2742
166 changed files with 23 additions and 18253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
systemUIPluginCore/src/com/android/systemui/plugins/Plugin.java
View File

@@ -1,129 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins;
import com.android.systemui.plugins.annotations.Requires;
import android.content.Context;
/**
* Plugins are separate APKs that
* are expected to implement interfaces provided by SystemUI. Their
* code is dynamically loaded into the SysUI process which can allow
* for multiple prototypes to be created and run on a single android
* build.
*
* PluginLifecycle:
* <pre class="prettyprint">
*
* plugin.onCreate(Context sysuiContext, Context pluginContext);
* --- This is always called before any other calls
*
* pluginListener.onPluginConnected(Plugin p);
* --- This lets the plugin hook know that a plugin is now connected.
*
* ** Any other calls back and forth between sysui/plugin **
*
* pluginListener.onPluginDisconnected(Plugin p);
* --- Lets the plugin hook know that it should stop interacting with
* this plugin and drop all references to it.
*
* plugin.onDestroy();
* --- Finally the plugin can perform any cleanup to ensure that its not
* leaking into the SysUI process.
*
* Any time a plugin APK is updated the plugin is destroyed and recreated
* to load the new code/resources.
*
* </pre>
*
* Creating plugin hooks:
*
* To create a plugin hook, first create an interface in
* frameworks/base/packages/SystemUI/plugin that extends Plugin.
* Include in it any hooks you want to be able to call into from
* sysui and create callback interfaces for anything you need to
* pass through into the plugin.
*
* Then to attach to any plugins simply add a plugin listener and
* onPluginConnected will get called whenever new plugins are installed,
* updated, or enabled. Like this example from SystemUIApplication:
*
* <pre class="prettyprint">
* {@literal
* PluginManager.getInstance(this).addPluginListener(OverlayPlugin.COMPONENT,
* new PluginListener<OverlayPlugin>() {
* @Override
* public void onPluginConnected(OverlayPlugin plugin) {
* StatusBar phoneStatusBar = getComponent(StatusBar.class);
* if (phoneStatusBar != null) {
* plugin.setup(phoneStatusBar.getStatusBarWindow(),
* phoneStatusBar.getNavigationBarView());
* }
* }
* }, OverlayPlugin.VERSION, true /* Allow multiple plugins *\/);
* }
* </pre>
* Note the VERSION included here. Any time incompatible changes in the
* interface are made, this version should be changed to ensure old plugins
* aren't accidentally loaded. Since the plugin library is provided by
* SystemUI, default implementations can be added for new methods to avoid
* version changes when possible.
*
* Implementing a Plugin:
*
* See the ExamplePlugin for an example Android.mk on how to compile
* a plugin. Note that SystemUILib is not static for plugins, its classes
* are provided by SystemUI.
*
* Plugin security is based around a signature permission, so plugins must
* hold the following permission in their manifest.
*
* <pre class="prettyprint">
* {@literal
* <uses-permission android:name="com.android.systemui.permission.PLUGIN" />
* }
* </pre>
*
* A plugin is found through a querying for services, so to let SysUI know
* about it, create a service with a name that points at your implementation
* of the plugin interface with the action accompanying it:
*
* <pre class="prettyprint">
* {@literal
* <service android:name=".TestOverlayPlugin">
* <intent-filter>
* <action android:name="com.android.systemui.action.PLUGIN_COMPONENT" />
* </intent-filter>
* </service>
* }
* </pre>
*/
public interface Plugin {
/**
* @deprecated
* @see Requires
*/
default int getVersion() {
// Default of -1 indicates the plugin supports the new Requires model.
return -1;
}
default void onCreate(Context sysuiContext, Context pluginContext) {
}
default void onDestroy() {
}
}

45
systemUIPluginCore/src/com/android/systemui/plugins/PluginFragment.java
View File

@@ -1,45 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins;
import android.app.Fragment;
import android.content.Context;
import android.os.Bundle;
import android.view.LayoutInflater;
public abstract class PluginFragment extends Fragment implements Plugin {
private Context mPluginContext;
@Override
public void onCreate(Context sysuiContext, Context pluginContext) {
mPluginContext = pluginContext;
}
@Override
public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
return super.onGetLayoutInflater(savedInstanceState).cloneInContext(getContext());
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
@Override
public Context getContext() {
return mPluginContext;
}
}

62
systemUIPluginCore/src/com/android/systemui/plugins/PluginLifecycleManager.java
View File

@@ -1,62 +0,0 @@
/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.systemui.plugins;
import android.content.ComponentName;
/**
* Provides the ability for consumers to control plugin lifecycle.
*
* @param <T> is the target plugin type
*/
public interface PluginLifecycleManager<T extends Plugin> {
/** Returns the ComponentName of the target plugin. Maybe be called when not loaded. */
ComponentName getComponentName();
/** Returns the package name of the target plugin. May be called when not loaded. */
String getPackage();
/** Returns the currently loaded plugin instance (if plugin is loaded) */
T getPlugin();
/** Returns true if the lifecycle manager should log debug messages */
boolean getIsDebug();
/** Sets whether or not hte lifecycle manager should log debug messages */
void setIsDebug(boolean debug);
/** returns true if the plugin is currently loaded */
default boolean isLoaded() {
return getPlugin() != null;
}
/**
* Loads and creates the plugin instance if it does not exist.
*
* This will trigger {@link PluginListener#onPluginLoaded} with the new instance if it did not
* already exist.
*/
void loadPlugin();
/**
* Unloads and destroys the plugin instance if it exists.
*
* This will trigger {@link PluginListener#onPluginUnloaded} if a concrete plugin instance
* existed when this call was made.
*/
void unloadPlugin();
}

123
systemUIPluginCore/src/com/android/systemui/plugins/PluginListener.java
View File

@@ -1,123 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins;
import android.content.Context;
/**
* Interface for listening to plugins being connected and disconnected.
*
* The call order for a plugin is
* 1) {@link #onPluginAttached}
* Called when a new plugin is added to the device, or an existing plugin was replaced by
* the package manager. Will only be called once per package manager event. If multiple
* non-conflicting packages which have the same plugin interface are installed on the
* device, then this method can be called multiple times with different instances of
* {@link PluginLifecycleManager} (as long as `allowMultiple` was set to true when the
* listener was registered with {@link PluginManager#addPluginListener}).
* 2) {@link #onPluginLoaded}
* Called whenever a new instance of the plugin object is created and ready for use. Can be
* called multiple times per {@link PluginLifecycleManager}, but will always pass a newly
* created plugin object. {@link #onPluginUnloaded} with the previous plugin object will
* be called before another call to {@link #onPluginLoaded} is made. This method will be
* called once automatically after {@link #onPluginAttached}. Besides the initial call,
* {@link #onPluginLoaded} will occur due to {@link PluginLifecycleManager#loadPlugin}.
* 3) {@link #onPluginUnloaded}
* Called when a request to unload the plugin has been received. This can be triggered from
* a related call to {@link PluginLifecycleManager#unloadPlugin} or for any reason that
* {@link #onPluginDetached} would be triggered.
* 4) {@link #onPluginDetached}
* Called when the package is removed from the device, disabled, or replaced due to an
* external trigger. These are events from the android package manager.
*
* @param <T> is the target plugin type
*/
public interface PluginListener<T extends Plugin> {
/**
* Called when the plugin has been loaded and is ready to be used.
* This may be called multiple times if multiple plugins are allowed.
* It may also be called in the future if the plugin package changes
* and needs to be reloaded.
*
* @deprecated Migrate to {@link #onPluginLoaded} or {@link #onPluginAttached}
*/
@Deprecated
default void onPluginConnected(T plugin, Context pluginContext) {
// Optional
}
/**
* Called when the plugin is first attached to the host application. {@link #onPluginLoaded}
* will be automatically called as well when first attached if true is returned. This may be
* called multiple times if multiple plugins are allowed. It may also be called in the future
* if the plugin package changes and needs to be reloaded. Each call to
* {@link #onPluginAttached} will provide a new or different {@link PluginLifecycleManager}.
*
* @return returning true will immediately load the plugin and call onPluginLoaded with the
* created object. false will skip loading, but the listener can load it at any time using the
* provided PluginLifecycleManager. Loading plugins immediately is the default behavior.
*/
default boolean onPluginAttached(PluginLifecycleManager<T> manager) {
// Optional
return true;
}
/**
* Called when a plugin has been uninstalled/updated and should be removed
* from use.
*
* @deprecated Migrate to {@link #onPluginDetached} or {@link #onPluginUnloaded}
*/
@Deprecated
default void onPluginDisconnected(T plugin) {
// Optional.
}
/**
* Called when the plugin has been detached from the host application. Implementers should no
* longer attempt to reload it via this {@link PluginLifecycleManager}. If the package was
* updated and not removed, then {@link #onPluginAttached} will be called again when the updated
* package is available.
*/
default void onPluginDetached(PluginLifecycleManager<T> manager) {
// Optional.
}
/**
* Called when the plugin is loaded into the host's process and is available for use. This can
* happen several times if clients are using {@link PluginLifecycleManager} to manipulate a
* plugin's load state. Each call to {@link #onPluginLoaded} will have a matched call to
* {@link #onPluginUnloaded} when that plugin object should no longer be used.
*/
default void onPluginLoaded(
T plugin,
Context pluginContext,
PluginLifecycleManager<T> manager
) {
// Optional, default to deprecated version
onPluginConnected(plugin, pluginContext);
}
/**
* Called when the plugin should no longer be used. Listeners should clean up all references to
* the relevant plugin so that it can be garbage collected. If the plugin object is required in
* the future a call can be made to {@link PluginLifecycleManager#loadPlugin} to create a new
* plugin object and trigger {@link #onPluginLoaded}.
*/
default void onPluginUnloaded(T plugin, PluginLifecycleManager<T> manager) {
// Optional, default to deprecated version
onPluginDisconnected(plugin);
}
}

58
systemUIPluginCore/src/com/android/systemui/plugins/PluginManager.java
View File

@@ -1,58 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins;
import android.text.TextUtils;
import com.android.systemui.plugins.annotations.ProvidesInterface;
public interface PluginManager {
String PLUGIN_CHANGED = "com.android.systemui.action.PLUGIN_CHANGED";
// must be one of the channels created in NotificationChannels.java
String NOTIFICATION_CHANNEL_ID = "ALR";
/** Returns plugins that don't get disabled when an exceptoin occurs. */
String[] getPrivilegedPlugins();
/** */
<T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<T> cls);
/** */
<T extends Plugin> void addPluginListener(PluginListener<T> listener, Class<T> cls,
boolean allowMultiple);
<T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,
Class<T> cls);
<T extends Plugin> void addPluginListener(String action, PluginListener<T> listener,
Class<T> cls, boolean allowMultiple);
void removePluginListener(PluginListener<?> listener);
<T> boolean dependsOn(Plugin p, Class<T> cls);
class Helper {
public static <P> String getAction(Class<P> cls) {
ProvidesInterface info = cls.getDeclaredAnnotation(ProvidesInterface.class);
if (info == null) {
throw new RuntimeException(cls + " doesn't provide an interface");
}
if (TextUtils.isEmpty(info.action())) {
throw new RuntimeException(cls + " doesn't provide an action");
}
return info.action();
}
}
}

27
systemUIPluginCore/src/com/android/systemui/plugins/annotations/Dependencies.java
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins.annotations;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Used for repeated @DependsOn internally, not for plugin
* use.
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface Dependencies {
DependsOn[] value();
}

32
systemUIPluginCore/src/com/android/systemui/plugins/annotations/DependsOn.java
View File

@@ -1,32 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins.annotations;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Used to indicate that an interface in the plugin library needs another
* interface to function properly. When this is added, it will be enforced
* that all plugins that @Requires the annotated interface also @Requires
* the specified class as well.
*/
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(value = Dependencies.class)
public @interface DependsOn {
Class<?> target();
}

30
systemUIPluginCore/src/com/android/systemui/plugins/annotations/ProvidesInterface.java
View File

@@ -1,30 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins.annotations;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Should be added to all interfaces in plugin lib to specify their
* current version and optionally their action to implement the plugin.
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface ProvidesInterface {
int version();
String action() default "";
}

27
systemUIPluginCore/src/com/android/systemui/plugins/annotations/Requirements.java
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins.annotations;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Used for repeated @Requires internally, not for plugin
* use.
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface Requirements {
Requires[] value();
}

33
systemUIPluginCore/src/com/android/systemui/plugins/annotations/Requires.java
View File

@@ -1,33 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.android.systemui.plugins.annotations;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* Used to annotate which interfaces a given plugin depends on.
*
* At minimum all plugins should have at least one @Requires annotation
* for the plugin interface that they are implementing. They will also
* need an @Requires for each class that the plugin interface @DependsOn.
*/
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(value = Requirements.class)
public @interface Requires {
Class<?> target();
int version();
}