private void configureLocalServices(ServiceRegistry registry) {
    registry.register(
        Keyboard.MANAGER.getName(),
        new ServiceFactory() {
          @Override
          public Binding connectToService(FlutterView view, Core core, MessagePipeHandle pipe) {
            return Keyboard.MANAGER.bind(new KeyboardImpl(view.getContext(), mKeyboardState), pipe);
          }
        });

    registry.register(
        RawKeyboardService.MANAGER.getName(),
        new ServiceFactory() {
          @Override
          public Binding connectToService(FlutterView view, Core core, MessagePipeHandle pipe) {
            return RawKeyboardService.MANAGER.bind(
                new RawKeyboardServiceImpl(mRawKeyboardState), pipe);
          }
        });

    registry.register(
        ApplicationMessages.MANAGER.getName(),
        new ServiceFactory() {
          @Override
          public Binding connectToService(FlutterView view, Core core, MessagePipeHandle pipe) {
            return ApplicationMessages.MANAGER.bind(new ApplicationMessagesImpl(), pipe);
          }
        });
  }
  public void testGetServiceProviderByClass() {
    Class[] CATEGORIES = new Class[] {ImageReaderSpi.class};

    ServiceRegistry registry = new ServiceRegistry(Arrays.<Class<?>>asList(CATEGORIES).iterator());
    ImageReaderSpi reader = new SampleImageReaderSpi();
    registry.registerServiceProvider(reader, CATEGORIES[0]);

    ImageReaderSpi provider = registry.getServiceProviderByClass(SampleImageReaderSpi.class);
    assertEquals(reader, provider);
  }
  public void testContains() {
    Class[] CATEGORIES = new Class[] {ImageReaderSpi.class};

    ServiceRegistry registry = new ServiceRegistry(Arrays.<Class<?>>asList(CATEGORIES).iterator());

    ImageReaderSpi reader1 = new SampleImageReaderSpi();
    ImageReaderSpi reader2 = new SampleImageReaderSpi();

    registry.registerServiceProvider(reader1, CATEGORIES[0]);

    assertTrue("Failed to check if reader1 registered", registry.contains(reader1));
    assertFalse("Failed to check if reader2 registered", registry.contains(reader2));
  }
  public void testDeregisterAll() {
    Class[] CATEGORIES = new Class[] {ImageReaderSpi.class};

    ServiceRegistry registry = new ServiceRegistry(Arrays.<Class<?>>asList(CATEGORIES).iterator());

    ImageReaderSpi reader1 = new Reader1Spi();
    ImageReaderSpi reader2 = new Reader2Spi();

    // Register two providers
    registry.registerServiceProvider(reader1, CATEGORIES[0]);
    registry.registerServiceProvider(reader2, CATEGORIES[0]);

    registry.deregisterAll(ImageReaderSpi.class);
    assertFalse(
        "Reader1 is still regitered, deregisterAll(Class) failed", registry.contains(reader1));
    assertFalse(
        "Reader2 is still regitered, deregisterAll(Class) failed", registry.contains(reader2));

    // Re-register two providers
    registry.registerServiceProvider(reader1, CATEGORIES[0]);
    registry.registerServiceProvider(reader2, CATEGORIES[0]);

    registry.deregisterAll();
    assertFalse("Reader1 is still regitered, deregisterAll() failed", registry.contains(reader1));
    assertFalse("Reader2 is still regitered, deregisterAll() failed", registry.contains(reader2));
  }
  @SuppressWarnings("unchecked")
  public void testDeregisterServiceProvider() throws Exception {
    Class[] CATEGORIES =
        new Class[] {
          javax.imageio.spi.ImageReaderSpi.class, javax.imageio.spi.SampleImageReaderSpi.class
        };

    ServiceRegistry registry = new ServiceRegistry(Arrays.<Class<?>>asList(CATEGORIES).iterator());

    SampleImageReaderSpi spi = new SampleImageReaderSpi();

    // Test deregisterServiceProvider(Object, Class)
    registry.registerServiceProvider(spi, CATEGORIES[0]);

    assertTrue(
        "deregisterServiceProvider(Object, Class) returns incorrect value for a registered provider ",
        registry.deregisterServiceProvider(spi, CATEGORIES[0]));

    assertFalse(
        "deregisterServiceProvider(Object, Class) returns incorrect value for a unregistered provider",
        registry.deregisterServiceProvider(spi, CATEGORIES[0]));

    // Test deregisterServiceProvider(Object)
    registry.registerServiceProvider(spi, CATEGORIES[0]);
    registry.registerServiceProvider(spi, CATEGORIES[1]);

    registry.deregisterServiceProvider(spi);

    assertFalse(
        "deregisterServiceProvider(Object) failed to remove all providers",
        registry.deregisterServiceProvider(spi, CATEGORIES[0]));
    assertFalse(
        "deregisterServiceProvider(Object) failed to remove all providers",
        registry.deregisterServiceProvider(spi, CATEGORIES[1]));
  }
  public void testRegistryServiceProvider() throws Exception {
    Class[] CATEGORIES = new Class[] {ImageWriterSpi.class, ImageReaderSpi.class};

    ServiceRegistry registry = new ServiceRegistry(Arrays.<Class<?>>asList(CATEGORIES).iterator());

    SampleImageReaderSpi spiA = new SampleImageReaderSpi();
    SampleImageReaderSpi spiB = new SampleImageReaderSpi();

    assertTrue(
        "registerServiceProvider() returns incorrect value for the empty registry",
        registry.registerServiceProvider(spiA, CATEGORIES[1]));
    assertFalse(
        "registerServiceProvider() returns incorrect value if a provider of the same class was previously registered",
        registry.registerServiceProvider(spiB, CATEGORIES[1]));
  }
  public void testLookupProviders() {
    // lookup from a correct provider-configuration file
    Iterator it = ServiceRegistry.lookupProviders(CorrectProviderConfiguration.class);
    assertEquals(
        "Failed to find provider and instantiate it",
        "class javax.imageio.spi.CorrectProviderConfiguration",
        it.next().getClass().toString());

    // lookup from incorrect provider-configuration file
    try {
      it = ServiceRegistry.lookupProviders(IncorrectProviderConfiguration.class);
      fail("ServiceConfigurationError expected");
    } catch (Error e) {
      // Ok
    }
  }
  /** Destroy the wrapper. This is called when the bundle is stopped. */
  protected void close() {
    valid = false; /* invalidate context */

    final ServiceRegistry registry = framework.getServiceRegistry();

    registry.removeAllServiceListeners(this);
    framework.removeAllListeners(this);

    /* service's registered by the bundle, if any, are unregistered. */
    registry.unregisterServices(this);

    /* service's used by the bundle, if any, are released. */
    registry.releaseServicesInUse(this);

    synchronized (contextLock) {
      servicesInUse = null;
    }
  }
 @SuppressWarnings("unchecked")
 void start() {
   m_slReg =
       (ServiceRegistration<StartLevel>)
           m_registry.registerService(
               m_felix,
               new String[] {StartLevel.class.getName()},
               new StartLevelImpl(m_felix),
               null);
 }
 public void unregister() {
   synchronized (this) {
     if (!isValid() || m_isUnregistering) {
       throw new IllegalStateException("Service already unregistered.");
     }
     m_isUnregistering = true;
   }
   m_registry.unregisterService(m_bundle, this);
   synchronized (this) {
     m_svcObj = null;
     m_factory = null;
   }
 }
Пример #11
0
 /**
  * Matches a service in the registry with the supplied type. If no match is found and a parent
  * registry has been delclared, the lookup request is passed onto the parent registry, otherwise
  * null is returned.
  *
  * @param type the service type
  * @return an instance of the type or null if the type could not be resolved
  */
 public <T> T lookup(Class<T> type) {
   for (Object object : m_args) {
     if (null != object) {
       Class c = object.getClass();
       if (type.isAssignableFrom(c)) {
         return type.cast(object);
       }
     }
   }
   if (null != m_parent) {
     return m_parent.lookup(type);
   }
   return null;
 }
 public void setProperties(Dictionary dict) {
   Map oldProps;
   synchronized (this) {
     // Make sure registration is valid.
     if (!isValid()) {
       throw new IllegalStateException("The service registration is no longer valid.");
     }
     // Remember old properties.
     oldProps = m_propMap;
     // Set the properties.
     initializeProperties(dict);
   }
   // Tell registry about it.
   m_registry.servicePropertiesModified(this, new MapToDictionary(oldProps));
 }
 void ungetService(Bundle relBundle, Object svcObj) {
   // If the service object is a service factory, then
   // let it release the service object.
   if (m_factory != null) {
     try {
       if (System.getSecurityManager() != null) {
         AccessController.doPrivileged(new ServiceFactoryPrivileged(relBundle, svcObj));
       } else {
         ungetFactoryUnchecked(relBundle, svcObj);
       }
     } catch (Exception ex) {
       m_registry
           .getLogger()
           .log(
               m_bundle,
               Logger.LOG_ERROR,
               "ServiceRegistrationImpl: Error ungetting service.",
               ex);
     }
   }
 }
 private Bundle[] getUsingBundles() {
   return m_registry.getUsingBundles(m_ref);
 }
  public void testGetServiceProviders() {
    Class[] CATEGORIES = new Class[] {ImageReaderSpi.class};

    ServiceRegistry registry = new ServiceRegistry(Arrays.<Class<?>>asList(CATEGORIES).iterator());

    ImageReaderSpi reader = new SampleImageReaderSpi();
    ImageReaderSpi reader1 = new Reader1Spi();
    ImageReaderSpi reader2 = new Reader2Spi();

    // Add 3 different providers to the registry
    registry.registerServiceProvider(reader, CATEGORIES[0]);
    registry.registerServiceProvider(reader1, CATEGORIES[0]);
    registry.registerServiceProvider(reader2, CATEGORIES[0]);

    // Add a different type of provider to the category
    ImageWriterSpi writer = new SampleImageWriterSpi();
    try {
      registry.registerServiceProvider(writer, CATEGORIES[0]);
      fail("ClassCastException expected");
    } catch (ClassCastException expected) {
      // Ok
    }

    // Set ordering between these providers
    // reader2 > reader1 >  reader
    assertTrue(
        "Failed to set ordering: reader2 > reader1",
        registry.setOrdering(CATEGORIES[0], reader2, reader1));
    assertTrue(
        "Failed to set ordering: reader1 > reader",
        registry.setOrdering(CATEGORIES[0], reader1, reader));

    // Return false if this ordering has already been set
    assertFalse(
        "Failed to check if the ordering reader1 > reader has been set",
        registry.setOrdering(CATEGORIES[0], reader1, reader));

    // If two providers are the same
    try {
      registry.setOrdering(CATEGORIES[0], reader, reader);
      fail("IllegalArgumentException expected");
    } catch (IllegalArgumentException expected) {
      // Ok
    }

    // If either provider is null
    try {
      registry.setOrdering(CATEGORIES[0], null, reader);
      fail("IllegalArgumentException expected");
    } catch (IllegalArgumentException expected) {
      // Ok
    }

    // Get the iterator of sorted providers
    Iterator it = registry.getServiceProviders(CATEGORIES[0], true);

    // Verify the order
    assertEquals("Failed to return reader2", it.next(), reader2);
    assertEquals("Failed to return reader1", it.next(), reader1);
    assertEquals("Failed to return reader", it.next(), reader);

    // The iterator should be able to run more than once
    it = registry.getServiceProviders(CATEGORIES[0], true);

    // Verify the order
    assertEquals("Failed to return reader2", it.next(), reader2);
    assertEquals("Failed to return reader1", it.next(), reader1);
    assertEquals("Failed to return reader", it.next(), reader);

    // Unset orderings
    assertTrue(
        "Failed to unset ordering: reader2 > reader1",
        registry.unsetOrdering(CATEGORIES[0], reader2, reader1));
    assertTrue(
        "Failed to unset ordering: reader1 > reader",
        registry.unsetOrdering(CATEGORIES[0], reader1, reader));

    // Return false if this ordering is not set
    assertFalse(
        "Failed to check if the ordering is not set",
        registry.unsetOrdering(CATEGORIES[0], reader2, reader));
  }