Android/lineage-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lineage-sdk: Remove external views API

Browse Source 
* It was only used by live lockscreen

Change-Id: I78408eefb03dcccbe095311bea78baf8e6d852eb
This commit is contained in:
Michael Bestas
2018-01-23 20:44:51 +02:00
parent 60aa859cbe
commit 498b79bb3a
29 changed files with 1 additions and 1046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

247
sdk/src/java/lineageos/externalviews/ExternalView.java
View File

@@ -1,247 +0,0 @@
/*
* Copyright (C) 2015 The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package lineageos.externalviews;
import android.app.Activity;
import android.app.Application;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewTreeObserver;
import java.util.LinkedList;
/**
* TODO: unhide once documented and finalized
* @hide
*/
public class ExternalView extends View implements Application.ActivityLifecycleCallbacks,
ViewTreeObserver.OnPreDrawListener {
private LinkedList<Runnable> mQueue = new LinkedList<Runnable>();
protected Context mContext;
protected final ExternalViewProperties mExternalViewProperties;
protected volatile IExternalViewProvider mExternalViewProvider;
public ExternalView(Context context, AttributeSet attrs) {
this(context, attrs, null);
}
public ExternalView(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs);
}
public ExternalView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
this(context, attrs);
}
public ExternalView(Context context, AttributeSet attributeSet, ComponentName componentName) {
super(context, attributeSet);
mContext = getContext();
mExternalViewProperties = new ExternalViewProperties(this, mContext);
Application app = (mContext instanceof Activity) ? ((Activity) mContext).getApplication()
: (Application) mContext;
app.registerActivityLifecycleCallbacks(this);
if (componentName != null) {
mContext.bindService(new Intent().setComponent(componentName),
mServiceConnection, Context.BIND_AUTO_CREATE);
}
}
private ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
try {
mExternalViewProvider = IExternalViewProvider.Stub.asInterface(
IExternalViewProviderFactory.Stub.asInterface(service).createExternalView(null));
executeQueue();
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
mExternalViewProvider = null;
}
};
private void executeQueue() {
while (!mQueue.isEmpty()) {
Runnable r = mQueue.pop();
r.run();
}
}
protected void performAction(Runnable r) {
if (mExternalViewProvider != null) {
r.run();
} else {
mQueue.add(r);
}
}
// view overrides, for positioning
@Override
public boolean onPreDraw() {
long cur = System.currentTimeMillis();
if (!mExternalViewProperties.hasChanged()) {
return true;
}
final int x = mExternalViewProperties.getX();
final int y = mExternalViewProperties.getY();
final int width = mExternalViewProperties.getWidth();
final int height = mExternalViewProperties.getHeight();
final boolean visible = mExternalViewProperties.isVisible();
final Rect clipRect = mExternalViewProperties.getHitRect();
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.alterWindow(x, y, width, height, visible,
clipRect);
} catch (RemoteException e) {
}
}
});
return true;
}
// Activity lifecycle callbacks
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
}
@Override
public void onActivityStarted(Activity activity) {
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.onStart();
} catch (RemoteException e) {
}
}
});
}
@Override
public void onActivityResumed(Activity activity) {
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.onResume();
} catch (RemoteException e) {
}
getViewTreeObserver().addOnPreDrawListener(ExternalView.this);
}
});
}
@Override
public void onActivityPaused(Activity activity) {
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.onPause();
} catch (RemoteException e) {
}
getViewTreeObserver().removeOnPreDrawListener(ExternalView.this);
}
});
}
@Override
public void onActivityStopped(Activity activity) {
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.onStop();
} catch (RemoteException e) {
}
}
});
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
@Override
public void onActivityDestroyed(Activity activity) {
mExternalViewProvider = null;
mContext.unbindService(mServiceConnection);
}
// Placeholder callbacks
@Override
public void onDetachedFromWindow() {
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.onDetach();
} catch (RemoteException e) {
}
}
});
}
@Override
public void onAttachedToWindow() {
performAction(new Runnable() {
@Override
public void run() {
try {
mExternalViewProvider.onAttach(null);
} catch (RemoteException e) {
}
}
});
}
/**
* Sets the component of the ExternalViewProviderService to be used for this ExternalView.
* If a provider is already connected to this view, it is first unbound before binding to the
* new provider.
* @param componentName
*/
public void setProviderComponent(ComponentName componentName) {
// unbind any existing external view provider
if (mExternalViewProvider != null) {
mContext.unbindService(mServiceConnection);
}
if (componentName != null) {
mContext.bindService(new Intent().setComponent(componentName),
mServiceConnection, Context.BIND_AUTO_CREATE);
}
}
}

95
sdk/src/java/lineageos/externalviews/ExternalViewProperties.java
View File

@@ -1,95 +0,0 @@
/*
* Copyright (C) 2015 The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package lineageos.externalviews;
import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.graphics.Rect;
import android.view.View;
/**
* TODO: unhide once documented and finalized
* @hide
*/
public class ExternalViewProperties {
private final int[] mScreenCoords = new int[2];
private final View mView;
private final View mDecorView;
private int mWidth, mHeight;
private boolean mVisible;
private Rect mHitRect = new Rect();
ExternalViewProperties(View view, Context context) {
mView = view;
if (context instanceof Activity) {
mDecorView = ((Activity) context).getWindow().getDecorView();
} else {
mDecorView = null;
}
}
public Rect getHitRect() {
return mHitRect;
}
public int getX() {
return mScreenCoords[0];
}
public int getY() {
return mScreenCoords[1];
}
public int getWidth() {
return mWidth;
}
public int getHeight() {
return mHeight;
}
public boolean isVisible() {
return mVisible;
}
public boolean hasChanged() {
int previousWidth = mWidth;
int previousHeight = mHeight;
mWidth = mView.getWidth();
mHeight = mView.getHeight();
int previousX = mScreenCoords[0];
int previousY = mScreenCoords[1];
mView.getLocationOnScreen(mScreenCoords);
int newX = mScreenCoords[0];
int newY = mScreenCoords[1];
mHitRect.setEmpty();
if (mDecorView != null) {
mDecorView.getHitRect(mHitRect);
}
boolean wasVisible = mVisible;
mVisible = mView.getLocalVisibleRect(mHitRect);
// Check if anything actually changed
return previousX != newX || previousY != newY
|| previousWidth != mWidth || previousHeight != mHeight
|| mVisible != wasVisible;
}
}

236
sdk/src/java/lineageos/externalviews/ExternalViewProviderService.java
View File

@@ -1,236 +0,0 @@
/*
* Copyright (C) 2015 The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package lineageos.externalviews;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import com.android.internal.policy.PhoneWindow;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* TODO: unhide once documented and finalized
* @hide
*/
public abstract class ExternalViewProviderService extends Service {
private static final String TAG = "ExternalViewProvider";
private static final boolean DEBUG = false;
private WindowManager mWindowManager;
private final Handler mHandler = new Handler();
@Override
public void onCreate() {
super.onCreate();
mWindowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
}
@Override
public final IBinder onBind(Intent intent) {
return new IExternalViewProviderFactory.Stub() {
@Override public IBinder createExternalView(final Bundle options) {
FutureTask<IBinder> c = new FutureTask<IBinder>(new Callable<IBinder>() {
@Override
public IBinder call() throws Exception {
return ExternalViewProviderService.this.createExternalView(options).mImpl;
}
});
mHandler.post(c);
try {
return c.get();
} catch (InterruptedException | ExecutionException e) {
Log.e(TAG, "error: ", e);
return null;
}
}
};
}
protected abstract Provider createExternalView(Bundle options);
protected abstract class Provider {
public static final int DEFAULT_WINDOW_TYPE = WindowManager.LayoutParams.TYPE_PHONE;
public static final int DEFAULT_WINDOW_FLAGS =
WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL |
WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS |
WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;;
private final class ProviderImpl extends IExternalViewProvider.Stub {
private final Window mWindow;
private final WindowManager.LayoutParams mParams;
private boolean mShouldShow = true;
private boolean mAskedShow = false;
public ProviderImpl(Provider provider) {
mWindow = new PhoneWindow(ExternalViewProviderService.this);
((ViewGroup) mWindow.getDecorView()).addView(onCreateView());
mParams = new WindowManager.LayoutParams();
mParams.type = provider.getWindowType();
mParams.flags = provider.getWindowFlags();
mParams.gravity = Gravity.LEFT | Gravity.TOP;
mParams.format = PixelFormat.TRANSPARENT;
}
@Override
public void onAttach(IBinder windowToken) throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
mWindowManager.addView(mWindow.getDecorView(), mParams);
Provider.this.onAttach();
}
});
}
@Override
public void onStart() throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
Provider.this.onStart();
}
});
}
@Override
public void onResume() throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
mShouldShow = true;
updateVisibility();
Provider.this.onResume();
}
});
}
@Override
public void onPause() throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
mShouldShow = false;
updateVisibility();
Provider.this.onPause();
}
});
}
@Override
public void onStop() throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
Provider.this.onStop();
}
});
}
@Override
public void onDetach() throws RemoteException {
mHandler.post(new Runnable() {
@Override
public void run() {
mWindowManager.removeView(mWindow.getDecorView());
Provider.this.onDetach();
}
});
}
@Override
public void alterWindow(final int x, final int y, final int width, final int height,
final boolean visible, final Rect clipRect) {
mHandler.post(new Runnable() {
@Override
public void run() {
mParams.x = x;
mParams.y = y;
mParams.width = width;
mParams.height = height;
if (DEBUG) Log.d(TAG, mParams.toString());
mAskedShow = visible;
updateVisibility();
View decorView = mWindow.getDecorView();
if (decorView.getVisibility() == View.VISIBLE) {
decorView.setClipBounds(clipRect);
}
if (mWindow.getDecorView().getVisibility() != View.GONE)
mWindowManager.updateViewLayout(mWindow.getDecorView(), mParams);
}
});
}
private void updateVisibility() {
if (DEBUG) Log.d(TAG, "shouldShow = " + mShouldShow + " askedShow = " + mAskedShow);
mWindow.getDecorView().setVisibility(mShouldShow && mAskedShow ?
View.VISIBLE : View.GONE);
}
}
private final ProviderImpl mImpl = new ProviderImpl(this);
private final Bundle mOptions;
protected Provider(Bundle options) {
mOptions = options;
}
protected Bundle getOptions() {
return mOptions;
}
protected void onAttach() {}
protected abstract View onCreateView();
protected void onStart() {}
protected void onResume() {}
protected void onPause() {}
protected void onStop() {}
protected void onDetach() {}
/*package*/ int getWindowType() {
return DEFAULT_WINDOW_TYPE;
}
/*package*/ int getWindowFlags() {
return DEFAULT_WINDOW_FLAGS;
}
}
}

32
sdk/src/java/lineageos/externalviews/IExternalViewProvider.aidl
View File

@@ -1,32 +0,0 @@
/**
* Copyright (c) 2015, The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package lineageos.externalviews;
import android.graphics.Rect;
/** @hide */
interface IExternalViewProvider
{
oneway void onAttach(in IBinder windowToken);
oneway void onStart();
oneway void onResume();
oneway void onPause();
oneway void onStop();
oneway void onDetach();
void alterWindow(in int x, in int y, in int width, in int height, in boolean visible, in Rect clipRect);
}

25
sdk/src/java/lineageos/externalviews/IExternalViewProviderFactory.aidl
View File

@@ -1,25 +0,0 @@
/**
* Copyright (c) 2015, The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package lineageos.externalviews;
import android.os.Bundle;
/** @hide */
interface IExternalViewProviderFactory
{
IBinder createExternalView(in Bundle options);
}