legacy/argeo-commons/org.argeo.cms.ui.workbench/src/org/argeo/cms/ui/workbench/osgi/MultiplePackagesView.java

   1 package org.argeo.cms.ui.workbench.osgi;
   2
   3 import java.util.ArrayList;
   4 import java.util.Comparator;
   5 import java.util.HashMap;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.Set;
   9 import java.util.TreeMap;
  10 import java.util.TreeSet;
  11
  12 import org.argeo.cms.ui.workbench.WorkbenchUiPlugin;
  13 import org.argeo.eclipse.ui.TreeParent;
  14 import org.eclipse.jface.viewers.ITreeContentProvider;
  15 import org.eclipse.jface.viewers.LabelProvider;
  16 import org.eclipse.jface.viewers.TreeViewer;
  17 import org.eclipse.jface.viewers.Viewer;
  18 import org.eclipse.swt.SWT;
  19 import org.eclipse.swt.widgets.Composite;
  20 import org.eclipse.ui.part.ViewPart;
  21 import org.osgi.framework.Bundle;
  22 import org.osgi.framework.BundleContext;
  23 import org.osgi.framework.ServiceReference;
  24 import org.osgi.service.packageadmin.ExportedPackage;
  25 import org.osgi.service.packageadmin.PackageAdmin;
  26
  27 /** <b>Experimental</b> The OSGi runtime from a module perspective. */
  28 @SuppressWarnings({ "deprecation", "rawtypes", "unchecked" })
  29 public class MultiplePackagesView extends ViewPart {
  30         private TreeViewer viewer;
  31         private PackageAdmin packageAdmin;
  32         private Comparator<ExportedPackage> epc = new Comparator<ExportedPackage>() {
  33                 public int compare(ExportedPackage o1, ExportedPackage o2) {
  34                         if (!o1.getName().equals(o2.getName()))
  35                                 return o1.getName().compareTo(o2.getName());
  36                         else
  37                                 return o1.getVersion().compareTo(o2.getVersion());
  38                 }
  39         };
  40
  41         @Override
  42         public void createPartControl(Composite parent) {
  43                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  44                 viewer.setContentProvider(new ModulesContentProvider());
  45                 viewer.setLabelProvider(new LabelProvider());
  46                 viewer.setInput(WorkbenchUiPlugin.getDefault().getBundle()
  47                                 .getBundleContext());
  48         }
  49
  50         @Override
  51         public void setFocus() {
  52                 viewer.getTree().setFocus();
  53         }
  54
  55         private class ModulesContentProvider implements ITreeContentProvider {
  56                 private static final long serialVersionUID = 3819934804640641721L;
  57
  58                 public Object[] getElements(Object inputElement) {
  59                         return getChildren(inputElement);
  60                 }
  61
  62                 public Object[] getChildren(Object parentElement) {
  63                         if (parentElement instanceof BundleContext) {
  64                                 BundleContext bundleContext = (BundleContext) parentElement;
  65                                 Bundle[] bundles = bundleContext.getBundles();
  66
  67                                 // scan packages
  68                                 ServiceReference paSr = bundleContext
  69                                                 .getServiceReference(PackageAdmin.class.getName());
  70                                 // TODO: make a cleaner referencing
  71                                 packageAdmin = (PackageAdmin) bundleContext.getService(paSr);
  72
  73                                 Map<Bundle, Set<ExportedPackage>> imported = new HashMap<Bundle, Set<ExportedPackage>>();
  74                                 Map<String, Set<ExportedPackage>> packages = new TreeMap<String, Set<ExportedPackage>>();
  75                                 for (Bundle bundle : bundles) {
  76                                         processBundle(bundle, imported, packages);
  77                                 }
  78
  79                                 List<MultiplePackagesNode> multiplePackages = new ArrayList<MultiplePackagesNode>();
  80                                 for (String packageName : packages.keySet()) {
  81                                         Set<ExportedPackage> pkgs = packages.get(packageName);
  82                                         if (pkgs.size() > 1) {
  83                                                 MultiplePackagesNode mpn = new MultiplePackagesNode(
  84                                                                 packageName, pkgs);
  85                                                 multiplePackages.add(mpn);
  86                                         }
  87                                 }
  88
  89                                 return multiplePackages.toArray();
  90                         } else if (parentElement instanceof TreeParent) {
  91                                 return ((TreeParent) parentElement).getChildren();
  92                         } else {
  93                                 return null;
  94                         }
  95                 }
  96
  97                 protected void processBundle(Bundle bundle,
  98                                 Map<Bundle, Set<ExportedPackage>> imported,
  99                                 Map<String, Set<ExportedPackage>> packages) {
 100                         ExportedPackage[] pkgs = packageAdmin.getExportedPackages(bundle);
 101                         if (pkgs == null)
 102                                 return;
 103                         for (ExportedPackage pkg : pkgs) {
 104                                 if (!packages.containsKey(pkg.getName()))
 105                                         packages.put(pkg.getName(), new TreeSet<ExportedPackage>(
 106                                                         epc));
 107                                 Set<ExportedPackage> expPackages = packages.get(pkg.getName());
 108                                 expPackages.add(pkg);
 109
 110                                 // imported
 111                                 for (Bundle b : pkg.getImportingBundles()) {
 112                                         if (bundle.getBundleId() != b.getBundleId()) {
 113                                                 if (!imported.containsKey(b)) {
 114                                                         imported.put(b, new TreeSet<ExportedPackage>(epc));
 115                                                 }
 116                                                 Set<ExportedPackage> impPackages = imported.get(b);
 117                                                 impPackages.add(pkg);
 118                                         }
 119                                 }
 120                         }
 121                 }
 122
 123                 public Object getParent(Object element) {
 124                         // TODO Auto-generated method stub
 125                         return null;
 126                 }
 127
 128                 public boolean hasChildren(Object element) {
 129                         if (element instanceof TreeParent) {
 130                                 return ((TreeParent) element).hasChildren();
 131                         }
 132                         return false;
 133                 }
 134
 135                 public void dispose() {
 136                 }
 137
 138                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 139                 }
 140         }
 141
 142         private class MultiplePackagesNode extends TreeParent {
 143                 public MultiplePackagesNode(String packageName,
 144                                 Set<ExportedPackage> exportedPackages) {
 145                         super(packageName);
 146                         for (ExportedPackage pkg : exportedPackages) {
 147                                 addChild(new ExportedPackageNode(pkg));
 148                         }
 149                 }
 150         }
 151
 152         private class ExportedPackageNode extends TreeParent {
 153                 public ExportedPackageNode(ExportedPackage exportedPackage) {
 154                         super(exportedPackage.getName() + " - "
 155                                         + exportedPackage.getVersion() + " ("
 156                                         + exportedPackage.getExportingBundle() + ")");
 157                         for (Bundle bundle : exportedPackage.getImportingBundles()) {
 158                                 addChild(new BundleNode(bundle, true));
 159                         }
 160                 }
 161         }
 162 }