| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.ide.eclipse.adt.internal.editors.layout.gle2; |
| |
| import static com.android.SdkConstants.CLASS_VIEW; |
| import static com.android.SdkConstants.CLASS_VIEWGROUP; |
| import static com.android.SdkConstants.FN_FRAMEWORK_LIBRARY; |
| |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.utils.Pair; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jdt.core.Flags; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IMethod; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.search.IJavaSearchConstants; |
| import org.eclipse.jdt.core.search.IJavaSearchScope; |
| import org.eclipse.jdt.core.search.SearchEngine; |
| import org.eclipse.jdt.core.search.SearchMatch; |
| import org.eclipse.jdt.core.search.SearchParticipant; |
| import org.eclipse.jdt.core.search.SearchPattern; |
| import org.eclipse.jdt.core.search.SearchRequestor; |
| import org.eclipse.jdt.internal.core.ResolvedBinaryType; |
| import org.eclipse.jdt.internal.core.ResolvedSourceType; |
| import org.eclipse.swt.widgets.Display; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * The {@link CustomViewFinder} can look up the custom views and third party views |
| * available for a given project. |
| */ |
| @SuppressWarnings("restriction") // JDT model access for custom-view class lookup |
| public class CustomViewFinder { |
| /** |
| * Qualified name for the per-project non-persistent property storing the |
| * {@link CustomViewFinder} for this project |
| */ |
| private final static QualifiedName CUSTOM_VIEW_FINDER = new QualifiedName(AdtPlugin.PLUGIN_ID, |
| "viewfinder"); //$NON-NLS-1$ |
| |
| /** Project that this view finder locates views for */ |
| private final IProject mProject; |
| |
| private final List<Listener> mListeners = new ArrayList<Listener>(); |
| |
| private List<String> mCustomViews; |
| private List<String> mThirdPartyViews; |
| private boolean mRefreshing; |
| |
| /** |
| * Constructs an {@link CustomViewFinder} for the given project. Don't use this method; |
| * use the {@link #get} factory method instead. |
| * |
| * @param project project to create an {@link CustomViewFinder} for |
| */ |
| private CustomViewFinder(IProject project) { |
| mProject = project; |
| } |
| |
| /** |
| * Returns the {@link CustomViewFinder} for the given project |
| * |
| * @param project the project the finder is associated with |
| * @return a {@CustomViewFinder} for the given project, never null |
| */ |
| public static CustomViewFinder get(IProject project) { |
| CustomViewFinder finder = null; |
| try { |
| finder = (CustomViewFinder) project.getSessionProperty(CUSTOM_VIEW_FINDER); |
| } catch (CoreException e) { |
| // Not a problem; we will just create a new one |
| } |
| |
| if (finder == null) { |
| finder = new CustomViewFinder(project); |
| try { |
| project.setSessionProperty(CUSTOM_VIEW_FINDER, finder); |
| } catch (CoreException e) { |
| AdtPlugin.log(e, "Can't store CustomViewFinder"); |
| } |
| } |
| |
| return finder; |
| } |
| |
| public void refresh() { |
| refresh(null /*listener*/, true /* sync */); |
| } |
| |
| public void refresh(final Listener listener) { |
| refresh(listener, false /* sync */); |
| } |
| |
| private void refresh(final Listener listener, boolean sync) { |
| // Add this listener to the list of listeners which should be notified when the |
| // search is done. (There could be more than one since multiple requests could |
| // arrive for a slow search since the search is run in a different thread). |
| if (listener != null) { |
| synchronized (this) { |
| mListeners.add(listener); |
| } |
| } |
| synchronized (this) { |
| if (listener != null) { |
| mListeners.add(listener); |
| } |
| if (mRefreshing) { |
| return; |
| } |
| mRefreshing = true; |
| } |
| |
| FindViewsJob job = new FindViewsJob(); |
| job.schedule(); |
| if (sync) { |
| try { |
| job.join(); |
| } catch (InterruptedException e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| } |
| |
| public Collection<String> getCustomViews() { |
| return mCustomViews == null ? null : Collections.unmodifiableCollection(mCustomViews); |
| } |
| |
| public Collection<String> getThirdPartyViews() { |
| return mThirdPartyViews == null |
| ? null : Collections.unmodifiableCollection(mThirdPartyViews); |
| } |
| |
| public Collection<String> getAllViews() { |
| // Not yet initialized: return null |
| if (mCustomViews == null) { |
| return null; |
| } |
| List<String> all = new ArrayList<String>(mCustomViews.size() + mThirdPartyViews.size()); |
| all.addAll(mCustomViews); |
| all.addAll(mThirdPartyViews); |
| return all; |
| } |
| |
| /** |
| * Returns a pair of view lists - the custom views and the 3rd-party views. |
| * This method performs no caching; it is the same as asking the custom view finder |
| * to refresh itself and then waiting for the answer and returning it. |
| * |
| * @param project the Android project |
| * @param layoutsOnly if true, only search for layouts |
| * @return a pair of lists, the first containing custom views and the second |
| * containing 3rd party views |
| */ |
| public static Pair<List<String>,List<String>> findViews( |
| final IProject project, boolean layoutsOnly) { |
| CustomViewFinder finder = get(project); |
| |
| return finder.findViews(layoutsOnly); |
| } |
| |
| private Pair<List<String>,List<String>> findViews(final boolean layoutsOnly) { |
| final Set<String> customViews = new HashSet<String>(); |
| final Set<String> thirdPartyViews = new HashSet<String>(); |
| |
| ProjectState state = Sdk.getProjectState(mProject); |
| final List<IProject> libraries = state != null |
| ? state.getFullLibraryProjects() : Collections.<IProject>emptyList(); |
| |
| SearchRequestor requestor = new SearchRequestor() { |
| @Override |
| public void acceptSearchMatch(SearchMatch match) throws CoreException { |
| // Ignore matches in comments |
| if (match.isInsideDocComment()) { |
| return; |
| } |
| |
| Object element = match.getElement(); |
| if (element instanceof ResolvedBinaryType) { |
| // Third party view |
| ResolvedBinaryType type = (ResolvedBinaryType) element; |
| IPackageFragment fragment = type.getPackageFragment(); |
| IPath path = fragment.getPath(); |
| String last = path.lastSegment(); |
| // Filter out android.jar stuff |
| if (last.equals(FN_FRAMEWORK_LIBRARY)) { |
| return; |
| } |
| if (!isValidView(type, layoutsOnly)) { |
| return; |
| } |
| |
| IProject matchProject = match.getResource().getProject(); |
| if (mProject == matchProject || libraries.contains(matchProject)) { |
| String fqn = type.getFullyQualifiedName(); |
| thirdPartyViews.add(fqn); |
| } |
| } else if (element instanceof ResolvedSourceType) { |
| // User custom view |
| IProject matchProject = match.getResource().getProject(); |
| if (mProject == matchProject || libraries.contains(matchProject)) { |
| ResolvedSourceType type = (ResolvedSourceType) element; |
| if (!isValidView(type, layoutsOnly)) { |
| return; |
| } |
| String fqn = type.getFullyQualifiedName(); |
| fqn = fqn.replace('$', '.'); |
| customViews.add(fqn); |
| } |
| } |
| } |
| }; |
| try { |
| IJavaProject javaProject = BaseProjectHelper.getJavaProject(mProject); |
| if (javaProject != null) { |
| String className = layoutsOnly ? CLASS_VIEWGROUP : CLASS_VIEW; |
| IType viewType = javaProject.findType(className); |
| if (viewType != null) { |
| IJavaSearchScope scope = SearchEngine.createHierarchyScope(viewType); |
| SearchParticipant[] participants = new SearchParticipant[] { |
| SearchEngine.getDefaultSearchParticipant() |
| }; |
| int matchRule = SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE; |
| |
| SearchPattern pattern = SearchPattern.createPattern("*", |
| IJavaSearchConstants.CLASS, IJavaSearchConstants.IMPLEMENTORS, |
| matchRule); |
| SearchEngine engine = new SearchEngine(); |
| engine.search(pattern, participants, scope, requestor, |
| new NullProgressMonitor()); |
| } |
| } |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| |
| |
| List<String> custom = new ArrayList<String>(customViews); |
| List<String> thirdParty = new ArrayList<String>(thirdPartyViews); |
| |
| if (!layoutsOnly) { |
| // Update our cached answers (unless we were filtered on only layouts) |
| mCustomViews = custom; |
| mThirdPartyViews = thirdParty; |
| } |
| |
| return Pair.of(custom, thirdParty); |
| } |
| |
| /** |
| * Determines whether the given member is a valid android.view.View to be added to the |
| * list of custom views or third party views. It checks that the view is public and |
| * not abstract for example. |
| */ |
| private static boolean isValidView(IType type, boolean layoutsOnly) |
| throws JavaModelException { |
| // Skip anonymous classes |
| if (type.isAnonymous()) { |
| return false; |
| } |
| int flags = type.getFlags(); |
| if (Flags.isAbstract(flags) || !Flags.isPublic(flags)) { |
| return false; |
| } |
| |
| // TODO: if (layoutsOnly) perhaps try to filter out AdapterViews and other ViewGroups |
| // not willing to accept children via XML |
| |
| // See if the class has one of the acceptable constructors |
| // needed for XML instantiation: |
| // View(Context context) |
| // View(Context context, AttributeSet attrs) |
| // View(Context context, AttributeSet attrs, int defStyle) |
| // We don't simply do three direct checks via type.getMethod() because the types |
| // are not resolved, so we don't know for each parameter if we will get the |
| // fully qualified or the unqualified class names. |
| // Instead, iterate over the methods and look for a match. |
| String typeName = type.getElementName(); |
| for (IMethod method : type.getMethods()) { |
| // Only care about constructors |
| if (!method.getElementName().equals(typeName)) { |
| continue; |
| } |
| |
| String[] parameterTypes = method.getParameterTypes(); |
| if (parameterTypes == null || parameterTypes.length < 1 || parameterTypes.length > 3) { |
| continue; |
| } |
| |
| String first = parameterTypes[0]; |
| // Look for the parameter type signatures -- produced by |
| // JDT's Signature.createTypeSignature("Context", false /*isResolved*/);. |
| // This is not a typo; they were copy/pasted from the actual parameter names |
| // observed in the debugger examining these data structures. |
| if (first.equals("QContext;") //$NON-NLS-1$ |
| || first.equals("Qandroid.content.Context;")) { //$NON-NLS-1$ |
| if (parameterTypes.length == 1) { |
| return true; |
| } |
| String second = parameterTypes[1]; |
| if (second.equals("QAttributeSet;") //$NON-NLS-1$ |
| || second.equals("Qandroid.util.AttributeSet;")) { //$NON-NLS-1$ |
| if (parameterTypes.length == 2) { |
| return true; |
| } |
| String third = parameterTypes[2]; |
| if (third.equals("I")) { //$NON-NLS-1$ |
| if (parameterTypes.length == 3) { |
| return true; |
| } |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Interface implemented by clients of the {@link CustomViewFinder} to be notified |
| * when a custom view search has completed. Will always be called on the SWT event |
| * dispatch thread. |
| */ |
| public interface Listener { |
| void viewsUpdated(Collection<String> customViews, Collection<String> thirdPartyViews); |
| } |
| |
| /** |
| * Job for performing class search off the UI thread. This is marked as a system job |
| * so that it won't show up in the progress monitor etc. |
| */ |
| private class FindViewsJob extends Job { |
| FindViewsJob() { |
| super("Find Custom Views"); |
| setSystem(true); |
| } |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| Pair<List<String>, List<String>> views = findViews(false); |
| mCustomViews = views.getFirst(); |
| mThirdPartyViews = views.getSecond(); |
| |
| // Notify listeners on SWT's UI thread |
| Display.getDefault().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| Collection<String> customViews = |
| Collections.unmodifiableCollection(mCustomViews); |
| Collection<String> thirdPartyViews = |
| Collections.unmodifiableCollection(mThirdPartyViews); |
| synchronized (this) { |
| for (Listener l : mListeners) { |
| l.viewsUpdated(customViews, thirdPartyViews); |
| } |
| mListeners.clear(); |
| mRefreshing = false; |
| } |
| } |
| }); |
| return Status.OK_STATUS; |
| } |
| } |
| } |
