src/com/android/telecomm/CallServiceFinder.java - android_packages_services_Telecomm - Gitiles

 /*
  * Copyright (C) 2013 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.telecomm;

 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.os.IBinder;
 import android.os.Bundle;
 import android.os.RemoteException;
 import android.telecomm.ICallService;
 import android.telecomm.ICallServiceLookupResponse;
 import android.telecomm.ICallServiceProvider;
 import android.util.Log;

 import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;

 import java.util.List;
 import java.util.Set;
 import java.util.Timer;
 import java.util.TimerTask;

 /**
  * Finds {@link ICallService} and {@link ICallServiceProvider} implementations on the device.
  * Uses binder APIs to find ICallServiceProviders and calls method on ICallServiceProvider to
  * find ICallService implementations.
  * TODO(santoscordon): Add performance timing to async calls.
  */
 final class CallServiceFinder {

     /**
      * Helper class to register/unregister call-service providers.
      */
     private class ProviderRegistrar {

         /**
          * The name of the call-service provider that is expected to register with this finder.
          */
         private ComponentName mProviderName;

         /**
          * A unique identifier for a given lookup cycle, see nextLookupId.
          * TODO(gilad): Potentially unnecessary, consider removing.
          */
         int mLookupId;

         /**
          * Persists the specified parameters.
          *
          * @param providerName The component name of the relevant provider.
          * @param lookupId The lookup-cycle ID.
          */
         ProviderRegistrar(ComponentName providerName, int lookupId) {
             this.mProviderName = providerName;
             this.mLookupId = lookupId;
         }

         ComponentName getProviderName() {
             return mProviderName;
         }

         /**
          * Registers the specified call-service provider.
          *
          * @param provider The provider object to register.
          */
         void register(ICallServiceProvider provider) {
             registerProvider(mLookupId, mProviderName, provider);
         }

         /** Unregisters this provider. */
         void unregister() {
             unregisterProvider(mProviderName);
         }
     }

     /**
      * Wrapper around ICallServiceProvider, mostly used for binding etc.
      *
      * TODO(gilad): Consider making this wrapper unnecessary.
      */
     private class ProviderWrapper {

         /**
          * Persists the specified parameters and attempts to bind the specified provider.
          *
          * TODO(gilad): Consider embedding ProviderRegistrar into this class and do away
          * with the former, or vice versa.
          *
          * @param context The relevant application context.
          * @param registrar The registrar with which to register and unregister this provider.
          */
         ProviderWrapper(Context context, final ProviderRegistrar registrar) {
           ComponentName name = registrar.getProviderName();
           Preconditions.checkNotNull(name);
           Preconditions.checkNotNull(context);

           Intent serviceIntent = new Intent(CALL_SERVICE_PROVIDER_CLASS_NAME).setComponent(name);
           Log.i(TAG, "Binding to ICallServiceProvider through " + serviceIntent);

           // Connection object for the service binding.
           ServiceConnection connection = new ServiceConnection() {
               @Override
               public void onServiceConnected(ComponentName className, IBinder service) {
                   registrar.register(ICallServiceProvider.Stub.asInterface(service));
               }

               @Override
               public void onServiceDisconnected(ComponentName className) {
                   registrar.unregister();
               }
           };

           if (!context.bindService(serviceIntent, connection, Context.BIND_AUTO_CREATE)) {
               // TODO(santoscordon): Handle error.
           }
         }
     }

     /**
      * A timer task to ensure each lookup cycle is time-bound, see LOOKUP_TIMEOUT.
      */
     private class LookupTerminator extends TimerTask {
         @Override
         public void run() {
           terminateLookup();
         }
     }

     private static final String TAG = CallServiceFinder.class.getSimpleName();

     /**
      * The longest period in milliseconds each lookup cycle is allowed to span over, see mTimer.
      * TODO(gilad): Likely requires tuning.
      */
     private static final int LOOKUP_TIMEOUT = 100;

     /**
      * Used to retrieve all known ICallServiceProvider implementations from the framework.
      * TODO(gilad): Move to a more logical place for this to be shared.
      */
     static final String CALL_SERVICE_PROVIDER_CLASS_NAME = ICallServiceProvider.class.getName();

     private final Switchboard mSwitchboard;

     /**
      * Determines whether or not a lookup cycle is already running.
      */
     private boolean mIsLookupInProgress = false;

     /**
      * Used to generate unique lookup-cycle identifiers. Incremented upon initiateLookup calls.
      */
     private int mNextLookupId = 0;

     /**
      * The set of bound call-service providers.  Only populated via initiateLookup scenarios.
      * Providers should only be removed upon unbinding.
      */
     private Set<ICallServiceProvider> mProviderRegistry = Sets.newHashSet();

     /**
      * Stores the names of the providers to bind to in one lookup cycle.  The set size represents
      * the number of call-service providers this finder expects to hear back from upon initiating
      * call-service lookups, see initiateLookup. Whenever all providers respond before the lookup
      * timeout occurs, the complete set of (available) call services is passed to the switchboard
      * for further processing of outgoing calls etc.  When the timeout occurs before all responds
      * are received, the partial (potentially empty) set gets passed (to the switchboard) instead.
      * Note that cached providers do not require finding and hence are excluded from this count.
      * Also noteworthy is that providers are dynamically removed from this set as they register.
      */
     private Set<ComponentName> mUnregisteredProviders;

     /**
      * Used to interrupt lookup cycles that didn't terminate naturally within the allowed
      * period, see LOOKUP_TIMEOUT.
      */
     private Timer mTimer;

     /**
      * Persists the specified parameters.
      *
      * @param switchboard The switchboard for this finer to work against.
      */
     CallServiceFinder(Switchboard switchboard) {
         mSwitchboard = switchboard;
     }

     /**
      * Initiates a lookup cycle for call-service providers.
      * TODO(gilad): Expand this comment to describe the lookup flow in more detail.
      *
      * @param context The relevant application context.
      */
     synchronized void initiateLookup(Context context) {
         if (mIsLookupInProgress) {
             // At most one active lookup is allowed at any given time, bail out.
             return;
         }

         List<ComponentName> providerNames = getProviderNames(context);
         if (providerNames.isEmpty()) {
             Log.i(TAG, "No ICallServiceProvider implementations found.");
             updateSwitchboard();
             return;
         }

         mIsLookupInProgress = true;
         mUnregisteredProviders = Sets.newHashSet();

         int lookupId = mNextLookupId++;
         for (ComponentName name : providerNames) {
             if (!mProviderRegistry.contains(name)) {
                 // The provider is either not yet registered or has been unregistered
                 // due to unbinding etc.
                 ProviderRegistrar registrar = new ProviderRegistrar(name, lookupId);
                 new ProviderWrapper(context, registrar);
                 mUnregisteredProviders.add(name);
             }
         }

         int providerCount = providerNames.size();
         int unregisteredProviderCount = mUnregisteredProviders.size();

         Log.i(TAG, "Found " + providerCount + " implementations for ICallServiceProvider, "
                 + unregisteredProviderCount + " of which are not currently registered.");

         if (unregisteredProviderCount == 0) {
             // All known (provider) implementations are already registered, pass control
             // back to the switchboard.
             updateSwitchboard();
         } else {
             // Start the timeout for this lookup cycle.
             // TODO(gilad): Consider reusing the same timer instead of creating new ones.
             if (mTimer != null) {
                 // Shouldn't be running but better safe than sorry.
                 mTimer.cancel();
             }
             mTimer = new Timer();
             mTimer.schedule(new LookupTerminator(), LOOKUP_TIMEOUT);
         }
     }

     /**
      * Returns the all-inclusive list of call-service-provider names.
      *
      * @param context The relevant/application context to query against.
      * @return The list containing the (component) names of all known ICallServiceProvider
      *     implementations or the empty list upon no available providers.
      */
     private List<ComponentName> getProviderNames(Context context) {
         // The list of provider names to return to the caller, may be populated below.
         List<ComponentName> providerNames = Lists.newArrayList();

         PackageManager packageManager = context.getPackageManager();
         Intent intent = new Intent(CALL_SERVICE_PROVIDER_CLASS_NAME);
         for (ResolveInfo entry : packageManager.queryIntentServices(intent, 0)) {
             ServiceInfo serviceInfo = entry.serviceInfo;
             if (serviceInfo != null) {
                 // The entry resolves to a proper service, add it to the list of provider names.
                 providerNames.add(
                         new ComponentName(serviceInfo.packageName, serviceInfo.name));
             }
         }

         return providerNames;
     }

     /**
      * Queries the supplied provider asynchronously for its CallServices and passes the list through
      * to {@link #registerCallServices} which will relinquish control back to switchboard.
      *
      * @param lookupId The lookup-cycle ID.
      * @param providerName The component name of the relevant provider.
      * @param provider The provider object to register.
      */
     private void registerProvider(
             final int lookupId,
             final ComponentName providerName,
             final ICallServiceProvider provider) {

         // Query the provider for {@link ICallService} implementations.
         try {
             provider.lookupCallServices(new ICallServiceLookupResponse.Stub() {
                 @Override
                 public void onResult(List<IBinder> binderList) {
                     List<ICallService> callServices = Lists.newArrayList();
                     for (IBinder binder : binderList) {
                         callServices.add(ICallService.Stub.asInterface(binder));
                     }
                     registerCallServices(lookupId, providerName, provider, callServices);
                 }
             });
         } catch (RemoteException e) {
             Log.e(TAG, "Could not retrieve call services from: " + providerName);
         }
     }

     /**
      * Registers the {@link CallService}s for the specified provider and performs the necessary
      * bookkeeping to potentially return control to the switchboard before the timeout for the
      * current lookup cycle.
      * TODO(santoscordon): Consider replacing this method's use of synchronized with a Handler
      * queue.
      *
      * @param lookupId The lookup-cycle ID.
      * @param providerName The component name of the relevant provider.
      * @param provider The provider associated with callServices.
      * @param callServices The {@link CallService}s to register.
      */
     synchronized private void registerCallServices(
             int lookupId,
             ComponentName providerName,
             ICallServiceProvider provider,
             List<ICallService> callServices) {

         // TODO(santoscordon): When saving the call services into this class, also add code to
         // unregister (remove) the call services upon disconnect. Potenially use RemoteCallbackList.

         if (mUnregisteredProviders.remove(providerName)) {
             mProviderRegistry.add(provider);
             if (mUnregisteredProviders.size() < 1) {
                 terminateLookup();  // No other providers to wait for.
             }
         } else {
             Log.i(TAG, "Received multiple lists of call services in lookup " + lookupId +
                     " from " + providerName);
         }
     }

     /**
      * Unregisters the specified provider.
      *
      * @param providerName The component name of the relevant provider.
      */
     private void unregisterProvider(ComponentName providerName) {
         mProviderRegistry.remove(providerName);
     }

     /**
      * Timeouts the current lookup cycle, see LookupTerminator.
      */
     private void terminateLookup() {
         if (mTimer != null) {
             mTimer.cancel();  // Terminate the timer thread.
         }

         updateSwitchboard();
         mIsLookupInProgress = false;
     }

     /**
      * Updates the switchboard passing the relevant call services (as opposed
      * to call-service providers).
      */
     private void updateSwitchboard() {
         synchronized (mProviderRegistry) {
             // TODO(gilad): More here.
             mSwitchboard.setCallServices(null);
         }
     }
 }
	/*
	* Copyright (C) 2013 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.telecomm;

	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.content.pm.PackageManager;
	import android.content.pm.ResolveInfo;
	import android.content.pm.ServiceInfo;
	import android.os.IBinder;
	import android.os.Bundle;
	import android.os.RemoteException;
	import android.telecomm.ICallService;
	import android.telecomm.ICallServiceLookupResponse;
	import android.telecomm.ICallServiceProvider;
	import android.util.Log;

	import com.google.common.base.Preconditions;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Sets;

	import java.util.List;
	import java.util.Set;
	import java.util.Timer;
	import java.util.TimerTask;

	/**
	* Finds {@link ICallService} and {@link ICallServiceProvider} implementations on the device.
	* Uses binder APIs to find ICallServiceProviders and calls method on ICallServiceProvider to
	* find ICallService implementations.
	* TODO(santoscordon): Add performance timing to async calls.
	*/
	final class CallServiceFinder {

	/**
	* Helper class to register/unregister call-service providers.
	*/
	private class ProviderRegistrar {

	/**
	* The name of the call-service provider that is expected to register with this finder.
	*/
	private ComponentName mProviderName;

	/**
	* A unique identifier for a given lookup cycle, see nextLookupId.
	* TODO(gilad): Potentially unnecessary, consider removing.
	*/
	int mLookupId;

	/**
	* Persists the specified parameters.
	*
	* @param providerName The component name of the relevant provider.
	* @param lookupId The lookup-cycle ID.
	*/
	ProviderRegistrar(ComponentName providerName, int lookupId) {
	this.mProviderName = providerName;
	this.mLookupId = lookupId;
	}

	ComponentName getProviderName() {
	return mProviderName;
	}

	/**
	* Registers the specified call-service provider.
	*
	* @param provider The provider object to register.
	*/
	void register(ICallServiceProvider provider) {
	registerProvider(mLookupId, mProviderName, provider);
	}

	/** Unregisters this provider. */
	void unregister() {
	unregisterProvider(mProviderName);
	}
	}

	/**
	* Wrapper around ICallServiceProvider, mostly used for binding etc.
	*
	* TODO(gilad): Consider making this wrapper unnecessary.
	*/
	private class ProviderWrapper {

	/**
	* Persists the specified parameters and attempts to bind the specified provider.
	*
	* TODO(gilad): Consider embedding ProviderRegistrar into this class and do away
	* with the former, or vice versa.
	*
	* @param context The relevant application context.
	* @param registrar The registrar with which to register and unregister this provider.
	*/
	ProviderWrapper(Context context, final ProviderRegistrar registrar) {
	ComponentName name = registrar.getProviderName();
	Preconditions.checkNotNull(name);
	Preconditions.checkNotNull(context);

	Intent serviceIntent = new Intent(CALL_SERVICE_PROVIDER_CLASS_NAME).setComponent(name);
	Log.i(TAG, "Binding to ICallServiceProvider through " + serviceIntent);

	// Connection object for the service binding.
	ServiceConnection connection = new ServiceConnection() {
	@Override
	public void onServiceConnected(ComponentName className, IBinder service) {
	registrar.register(ICallServiceProvider.Stub.asInterface(service));
	}

	@Override
	public void onServiceDisconnected(ComponentName className) {
	registrar.unregister();
	}
	};

	if (!context.bindService(serviceIntent, connection, Context.BIND_AUTO_CREATE)) {
	// TODO(santoscordon): Handle error.
	}
	}
	}

	/**
	* A timer task to ensure each lookup cycle is time-bound, see LOOKUP_TIMEOUT.
	*/
	private class LookupTerminator extends TimerTask {
	@Override
	public void run() {
	terminateLookup();
	}
	}

	private static final String TAG = CallServiceFinder.class.getSimpleName();

	/**
	* The longest period in milliseconds each lookup cycle is allowed to span over, see mTimer.
	* TODO(gilad): Likely requires tuning.
	*/
	private static final int LOOKUP_TIMEOUT = 100;

	/**
	* Used to retrieve all known ICallServiceProvider implementations from the framework.
	* TODO(gilad): Move to a more logical place for this to be shared.
	*/
	static final String CALL_SERVICE_PROVIDER_CLASS_NAME = ICallServiceProvider.class.getName();

	private final Switchboard mSwitchboard;

	/**
	* Determines whether or not a lookup cycle is already running.
	*/
	private boolean mIsLookupInProgress = false;

	/**
	* Used to generate unique lookup-cycle identifiers. Incremented upon initiateLookup calls.
	*/
	private int mNextLookupId = 0;

	/**
	* The set of bound call-service providers. Only populated via initiateLookup scenarios.
	* Providers should only be removed upon unbinding.
	*/
	private Set<ICallServiceProvider> mProviderRegistry = Sets.newHashSet();

	/**
	* Stores the names of the providers to bind to in one lookup cycle. The set size represents
	* the number of call-service providers this finder expects to hear back from upon initiating
	* call-service lookups, see initiateLookup. Whenever all providers respond before the lookup
	* timeout occurs, the complete set of (available) call services is passed to the switchboard
	* for further processing of outgoing calls etc. When the timeout occurs before all responds
	* are received, the partial (potentially empty) set gets passed (to the switchboard) instead.
	* Note that cached providers do not require finding and hence are excluded from this count.
	* Also noteworthy is that providers are dynamically removed from this set as they register.
	*/
	private Set<ComponentName> mUnregisteredProviders;

	/**
	* Used to interrupt lookup cycles that didn't terminate naturally within the allowed
	* period, see LOOKUP_TIMEOUT.
	*/
	private Timer mTimer;

	/**
	* Persists the specified parameters.
	*
	* @param switchboard The switchboard for this finer to work against.
	*/
	CallServiceFinder(Switchboard switchboard) {
	mSwitchboard = switchboard;
	}

	/**
	* Initiates a lookup cycle for call-service providers.
	* TODO(gilad): Expand this comment to describe the lookup flow in more detail.
	*
	* @param context The relevant application context.
	*/
	synchronized void initiateLookup(Context context) {
	if (mIsLookupInProgress) {
	// At most one active lookup is allowed at any given time, bail out.
	return;
	}

	List<ComponentName> providerNames = getProviderNames(context);
	if (providerNames.isEmpty()) {
	Log.i(TAG, "No ICallServiceProvider implementations found.");
	updateSwitchboard();
	return;
	}

	mIsLookupInProgress = true;
	mUnregisteredProviders = Sets.newHashSet();

	int lookupId = mNextLookupId++;
	for (ComponentName name : providerNames) {
	if (!mProviderRegistry.contains(name)) {
	// The provider is either not yet registered or has been unregistered
	// due to unbinding etc.
	ProviderRegistrar registrar = new ProviderRegistrar(name, lookupId);
	new ProviderWrapper(context, registrar);
	mUnregisteredProviders.add(name);
	}
	}

	int providerCount = providerNames.size();
	int unregisteredProviderCount = mUnregisteredProviders.size();

	Log.i(TAG, "Found " + providerCount + " implementations for ICallServiceProvider, "
	+ unregisteredProviderCount + " of which are not currently registered.");

	if (unregisteredProviderCount == 0) {
	// All known (provider) implementations are already registered, pass control
	// back to the switchboard.
	updateSwitchboard();
	} else {
	// Start the timeout for this lookup cycle.
	// TODO(gilad): Consider reusing the same timer instead of creating new ones.
	if (mTimer != null) {
	// Shouldn't be running but better safe than sorry.
	mTimer.cancel();
	}
	mTimer = new Timer();
	mTimer.schedule(new LookupTerminator(), LOOKUP_TIMEOUT);
	}
	}

	/**
	* Returns the all-inclusive list of call-service-provider names.
	*
	* @param context The relevant/application context to query against.
	* @return The list containing the (component) names of all known ICallServiceProvider
	* implementations or the empty list upon no available providers.
	*/
	private List<ComponentName> getProviderNames(Context context) {
	// The list of provider names to return to the caller, may be populated below.
	List<ComponentName> providerNames = Lists.newArrayList();

	PackageManager packageManager = context.getPackageManager();
	Intent intent = new Intent(CALL_SERVICE_PROVIDER_CLASS_NAME);
	for (ResolveInfo entry : packageManager.queryIntentServices(intent, 0)) {
	ServiceInfo serviceInfo = entry.serviceInfo;
	if (serviceInfo != null) {
	// The entry resolves to a proper service, add it to the list of provider names.
	providerNames.add(
	new ComponentName(serviceInfo.packageName, serviceInfo.name));
	}
	}

	return providerNames;
	}

	/**
	* Queries the supplied provider asynchronously for its CallServices and passes the list through
	* to {@link #registerCallServices} which will relinquish control back to switchboard.
	*
	* @param lookupId The lookup-cycle ID.
	* @param providerName The component name of the relevant provider.
	* @param provider The provider object to register.
	*/
	private void registerProvider(
	final int lookupId,
	final ComponentName providerName,
	final ICallServiceProvider provider) {

	// Query the provider for {@link ICallService} implementations.
	try {
	provider.lookupCallServices(new ICallServiceLookupResponse.Stub() {
	@Override
	public void onResult(List<IBinder> binderList) {
	List<ICallService> callServices = Lists.newArrayList();
	for (IBinder binder : binderList) {
	callServices.add(ICallService.Stub.asInterface(binder));
	}
	registerCallServices(lookupId, providerName, provider, callServices);
	}
	});
	} catch (RemoteException e) {
	Log.e(TAG, "Could not retrieve call services from: " + providerName);
	}
	}

	/**
	* Registers the {@link CallService}s for the specified provider and performs the necessary
	* bookkeeping to potentially return control to the switchboard before the timeout for the
	* current lookup cycle.
	* TODO(santoscordon): Consider replacing this method's use of synchronized with a Handler
	* queue.
	*
	* @param lookupId The lookup-cycle ID.
	* @param providerName The component name of the relevant provider.
	* @param provider The provider associated with callServices.
	* @param callServices The {@link CallService}s to register.
	*/
	synchronized private void registerCallServices(
	int lookupId,
	ComponentName providerName,
	ICallServiceProvider provider,
	List<ICallService> callServices) {

	// TODO(santoscordon): When saving the call services into this class, also add code to
	// unregister (remove) the call services upon disconnect. Potenially use RemoteCallbackList.

	if (mUnregisteredProviders.remove(providerName)) {
	mProviderRegistry.add(provider);
	if (mUnregisteredProviders.size() < 1) {
	terminateLookup(); // No other providers to wait for.
	}
	} else {
	Log.i(TAG, "Received multiple lists of call services in lookup " + lookupId +
	" from " + providerName);
	}
	}

	/**
	* Unregisters the specified provider.
	*
	* @param providerName The component name of the relevant provider.
	*/
	private void unregisterProvider(ComponentName providerName) {
	mProviderRegistry.remove(providerName);
	}

	/**
	* Timeouts the current lookup cycle, see LookupTerminator.
	*/
	private void terminateLookup() {
	if (mTimer != null) {
	mTimer.cancel(); // Terminate the timer thread.
	}

	updateSwitchboard();
	mIsLookupInProgress = false;
	}

	/**
	* Updates the switchboard passing the relevant call services (as opposed
	* to call-service providers).
	*/
	private void updateSwitchboard() {
	synchronized (mProviderRegistry) {
	// TODO(gilad): More here.
	mSwitchboard.setCallServices(null);
	}
	}
	}