Java Code Examples for android.os.IBinder

public CursorWindow(Parcel source,int foo){
  super(true);
  IBinder nativeBinder=source.readStrongBinder();
  mStartPos=source.readInt();
  native_init(nativeBinder);
}
 

private synchronized IMountService getMountService(){
  if (mMountService == null) {
    IBinder service=ServiceManager.getService("mount");
    if (service != null) {
      mMountService=IMountService.Stub.asInterface(service);
    }
 else {
      Log.e(TAG,"Can't get mount service");
    }
  }
  return mMountService;
}
 

private synchronized IMountService getMountService(){
  if (mMountService == null) {
    IBinder service=ServiceManager.getService("mount");
    if (service != null) {
      mMountService=IMountService.Stub.asInterface(service);
    }
 else {
      Log.print("Can't get mount service");
    }
  }
  return mMountService;
}
 

private IBinder bindService(Intent serviceIntent,Class<?> serviceClass,int flags,int timeout,TimeUnit timeUnit) throws TimeoutException {
  TemporaryServiceConnection serviceConnection=new TemporaryServiceConnection(timeout,timeUnit);
  instrumentation.getTargetContext().bindService(serviceIntent,serviceConnection,flags);
  IBinder serviceBinder=serviceConnection.getBinderSync();
  if (serviceBinder == null) {
    throw new TimeoutException("Timeout hit (" + timeout + " "+ timeUnit.toString().toLowerCase()+ ") while trying to connect to service"+ serviceClass != null ? " " + serviceClass.getName() : "" + ".");
  }
  serviceConnections.put(serviceBinder,serviceConnection);
  return serviceBinder;
}
 

public void showOptionDialogInternal(AlertDialog dialog){
  final IBinder windowToken=KeyboardSwitcher.getInstance().getKeyboardView().getWindowToken();
  if (windowToken == null)   return;
  dialog.setCancelable(true);
  dialog.setCanceledOnTouchOutside(true);
  final Window window=dialog.getWindow();
  final WindowManager.LayoutParams lp=window.getAttributes();
  lp.token=windowToken;
  lp.type=WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
  window.setAttributes(lp);
  window.addFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
  mOptionsDialog=dialog;
  dialog.show();
}
 

@Override public IBinder onBind(Intent intent){
  if (Log.isLoggable(TAG,Log.VERBOSE)) {
    Log.v(TAG,"getBinder()...  returning the AccountAuthenticator binder for intent " + intent);
  }
  IBinder ret=null;
  if (intent.getAction().equals(android.accounts.AccountManager.ACTION_AUTHENTICATOR_INTENT)) {
    ret=mAuthenticator.getIBinder();
  }
  return ret;
}
 

@SmallTest public void testBind(){
  final Intent intent=new Intent();
  intent.setClass(getContext(),BillingService.class);
  final IBinder service=bindService(intent);
  assertNull(service);
}
 

private void writeRenderEffect(int id){
  try {
    IBinder flinger=ServiceManager.getService("SurfaceFlinger");
    if (flinger != null) {
      Parcel data=Parcel.obtain();
      data.writeInterfaceToken("android.ui.ISurfaceComposer");
      data.writeInt(id);
      flinger.transact(1014,data,null,0);
      data.recycle();
    }
  }
 catch (  RemoteException ex) {
  }
}
 

public void showOptionDialogInternal(AlertDialog dialog){
  final IBinder windowToken=KeyboardSwitcher.getInstance().getKeyboardView().getWindowToken();
  if (windowToken == null)   return;
  dialog.setCancelable(true);
  dialog.setCanceledOnTouchOutside(true);
  final Window window=dialog.getWindow();
  final WindowManager.LayoutParams lp=window.getAttributes();
  lp.token=windowToken;
  lp.type=WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
  window.setAttributes(lp);
  window.addFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
  mOptionsDialog=dialog;
  dialog.show();
}
 

@Override public IBinder onBind(Intent intent){
  IBinder ret=null;
  if (intent.getAction().equals(android.accounts.AccountManager.ACTION_AUTHENTICATOR_INTENT)) {
    ret=getAuthenticator().getIBinder();
  }
  return ret;
}
 

protected IActivityManager create(){
  IBinder b=ServiceManager.getService("activity");
  if (false) {
    Log.v("ActivityManager","default service binder = " + b);
  }
  IActivityManager am=asInterface(b);
  if (false) {
    Log.v("ActivityManager","default service = " + am);
  }
  return am;
}
 

@Override public void onPause(){
  super.onPause();
  SessionList sessions=mTermSessions;
  TermViewFlipper viewFlipper=mViewFlipper;
  viewFlipper.onPause();
  if (sessions != null) {
    sessions.removeCallback(this);
    WindowListAdapter adapter=mWinListAdapter;
    if (adapter != null) {
      sessions.removeCallback(adapter);
      sessions.removeTitleChangedListener(adapter);
      viewFlipper.removeCallback(adapter);
    }
  }
  if (AndroidCompat.SDK < 5) {
    mBackKeyPressed=false;
  }
  final IBinder token=viewFlipper.getWindowToken();
  new Thread(){
    @Override public void run(){
      InputMethodManager imm=(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
      imm.hideSoftInputFromWindow(token,0);
    }
  }
.start();
}
 

/** 
 * Default cctor
 */
public NetworkQueryProxy(Context context){
  try {
    ClassLoader cl=context.getClassLoader();
    Class networkQueryServiceClassDefinition=cl.loadClass("com.android.phone.NetworkQueryService");
    @SuppressWarnings("rawtypes") Class serviceManagerClass=cl.loadClass("android.os.ServiceManager");
    @SuppressWarnings("rawtypes") Class[] paramTypesGetService=new Class[1];
    paramTypesGetService[0]=String.class;
    @SuppressWarnings("unchecked") Method methodGetService=serviceManagerClass.getMethod("getService",paramTypesGetService);
    Object[] paramsGetService=new Object[1];
    paramsGetService[0]="networkquery";
    IBinder serviceBinder=(IBinder)methodGetService.invoke(serviceManagerClass,paramsGetService);
    context.startService(new Intent(context,networkQueryServiceClassDefinition));
    if (serviceBinder == null) {
      Log.e(TAG,"no binder to networkquery found");
    }
 else {
      Log.e(TAG,"binder to networkquery acquired");
    }
  }
 catch (  Exception e) {
    Log.e("TAG","An exception occured in NetworkQueryProxy(). Message: " + e.getMessage() + ", cause: "+ e.getCause().getMessage());
    m_Instance=null;
  }
}
 

private void goToDirectoryInEditText(){
  File browseto=new File(mEditDirectory.getText().toString());
  IBinder windowToken=mEditDirectory.getWindowToken();
  if (browseto.equals(currentDirectory)) {
    showDirectoryInput(false);
    hideKeyboard(windowToken,0);
  }
 else {
    if (mHaveShownErrorMessageForFile != null && mHaveShownErrorMessageForFile.equals(browseto)) {
      mHaveShownErrorMessageForFile=null;
      showDirectoryInput(false);
      hideKeyboard(windowToken,0);
    }
 else {
      if (!browseto.exists()) {
        mHaveShownErrorMessageForFile=browseto;
      }
 else {
        showDirectoryInput(false);
        hideKeyboard(windowToken,0);
      }
      browseTo(browseto);
    }
  }
}
 

@Override public void onCreate(){
  super.onCreate();
  mAdapter=BluetoothAdapter.getDefaultAdapter();
  mPowerManager=(PowerManager)getSystemService(Context.POWER_SERVICE);
  mBtHandsfree=PhoneApp.getInstance().getBluetoothHandsfree();
  mAg=new BluetoothAudioGateway(mAdapter);
  IntentFilter filter=new IntentFilter(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED);
  filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
  filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
  filter.addAction(AudioManager.VOLUME_CHANGED_ACTION);
  filter.addAction(BluetoothDevice.ACTION_UUID);
  registerReceiver(mBluetoothReceiver,filter);
  IBinder b=ServiceManager.getService(BluetoothAdapter.BLUETOOTH_SERVICE);
  if (b == null) {
    throw new RuntimeException("Bluetooth service not available");
  }
  mBluetoothService=IBluetooth.Stub.asInterface(b);
  mRemoteHeadsets=new HashMap<BluetoothDevice,BluetoothRemoteHeadset>();
}
 

@Override public void onServiceConnected(final ComponentName classname,final IBinder obj){
  mService=IMediaPlaybackService.Stub.asInterface(obj);
  try {
    if (Utils.isNotEmpty(mService.getPath())) {
      podcastPlayer.setVisibility(View.VISIBLE);
      updateTrackInfo();
      refreshNow();
      return;
    }
 else {
      podcastPlayer.setVisibility(View.GONE);
    }
  }
 catch (  final RemoteException ex) {
  }
}
 

private void bindSshAgentTo(Context context){
  Intent intent=new Intent("org.openintents.ssh.BIND_SSH_AGENT_SERVICE");
  intent.setComponent(preferredAuthAgentComponentNameProvider.get());
  context.bindService(intent,new ServiceConnection(){
    public void onServiceDisconnected(    ComponentName name){
      Log.i(TAG,"onServiceDisconnected() : Lost " + authAgent);
      authAgent=null;
    }
    public void onServiceConnected(    ComponentName name,    IBinder binder){
      Log.i(TAG,"onServiceConnected() : componentName=" + name + " binder="+ binder);
      authAgent=AndroidAuthAgent.Stub.asInterface(binder);
      signalAuthAgentBound();
    }
  }
,BIND_AUTO_CREATE);
  Log.i(TAG,"made request using context " + context + " to bind to the SSH_AGENT_SERVICE");
}
 

/** 
 * This is called when we are connected to the MarketBillingService. This runs in the main UI thread.
 */
@Override public void onServiceConnected(ComponentName name,IBinder service){
  if (Consts.DEBUG) {
    Log.d(TAG,"Billing service connected");
  }
  mService=IMarketBillingService.Stub.asInterface(service);
  runPendingRequests();
}
 

public void onServiceConnected(ComponentName name,IBinder service){
  mManager=((ChatManager.ChatBinder)service).getService();
  if (getIntent().hasExtra("id")) {
    Bundle extras=getIntent().getExtras();
    ServerDetail details=new ServerDetail(ChatActivity.this,extras.getLong("id"));
    boolean found=false;
synchronized (mManager.mConnections) {
      for (      Server s : mManager.mConnections.values()) {
        if (s.mName.equals(details.mName)) {
          found=true;
        }
      }
    }
    if (!found) {
      Log.d(AppConstants.CHAT_TAG,"need to establish a connection.");
      mManager.openServerConnection(ChatActivity.this,details);
    }
  }
  if (AppConstants.DEBUG) {
    Log.d(AppConstants.CHAT_TAG,"Connected to the service.");
  }
  runOnUiThread(updateChatViews);
}
 

@Override public void onServiceConnected(final ComponentName className,IBinder service){
  Log.d(PluginConstants.LOG_TAG,"Enter LiveViewService.ServiceConnection.onServiceConnected.");
  mLiveView=IPluginServiceV1.Stub.asInterface(service);
  LiveViewCallback lvCallback=new LiveViewCallback();
  try {
    if (mLiveView != null) {
      mPluginId=mLiveView.register(lvCallback,mMenuIcon,mPluginName,false,getPackageName());
      Log.d(PluginConstants.LOG_TAG,"Plugin registered with id: " + mPluginId);
    }
  }
 catch (  RemoteException re) {
    Log.e(PluginConstants.LOG_TAG,"Failed to install plugin. Stop self.");
    stopSelf();
  }
  Log.d(PluginConstants.LOG_TAG,"Plugin registered. mPluginId: " + mPluginId);
}
 

/** 
 * Bind to the buddycloud service, if not yet bound or dead.
 */
protected final synchronized void bindBCService(){
  Intent serviceIntent=new Intent(IBuddycloudService.class.getCanonicalName());
  startService(serviceIntent);
  if (connection == null) {
    connection=new ServiceConnection(){
      public void onServiceDisconnected(      ComponentName name){
      }
      public void onServiceConnected(      ComponentName name,      IBinder binder){
        service=IBuddycloudService.Stub.asInterface(binder);
        onBuddycloudServiceBound();
      }
    }
;
  }
  if (service != null) {
    if (service.asBinder().isBinderAlive()) {
      return;
    }
 else {
      service=null;
    }
  }
  bindService(new Intent(IBuddycloudService.class.getName()),connection,Context.BIND_AUTO_CREATE);
}
 

/** 
 * This is called when we are connected to the MarketBillingService. This runs in the main UI thread.
 */
public void onServiceConnected(ComponentName name,IBinder service){
  if (Consts.DEBUG) {
    Log.d(TAG,"Billing service connected");
  }
  mService=IMarketBillingService.Stub.asInterface(service);
  runPendingRequests();
}
 

@Override public IBinder onBind(Intent intent){
  if (Log.isLoggable(TAG,Log.VERBOSE)) {
    Log.v(TAG,"getBinder()...  returning the AccountAuthenticator binder for intent " + intent);
  }
  return mAuthenticator.getIBinder();
}
 

private void connect(final String username,final String password){
  mVpnManager.startVpnService();
  ServiceConnection c=new ServiceConnection(){
    public void onServiceConnected(    ComponentName className,    IBinder service){
      try {
        boolean success=IVpnService.Stub.asInterface(service).connect(mProfile,username,password);
        if (!success) {
          Log.d(TAG,"~~~~~~ connect() failed!");
        }
 else {
          Log.d(TAG,"~~~~~~ connect() succeeded!");
        }
      }
 catch (      Throwable e) {
        Log.e(TAG,"connect()",e);
        broadcastConnectivity(VpnState.IDLE,VpnManager.VPN_ERROR_CONNECTION_FAILED);
      }
 finally {
        mContext.unbindService(this);
      }
    }
    public void onServiceDisconnected(    ComponentName className){
      checkStatus();
    }
  }
;
  if (!bindService(c)) {
    broadcastConnectivity(VpnState.IDLE,VpnManager.VPN_ERROR_CONNECTION_FAILED);
  }
}
 

@Override public void onServiceConnected(ComponentName name,IBinder service){
  mBinder=(LDAPService.LDAPBinder)service;
  mBinder.setActivityCallBackHandler(messageHandler);
  mBinder.setRunnable(new ShowDirResultsRunnable(mContext));
  for (  Account acc : AccountManager.get(mContext).getAccounts()) {
    if (acc.name.equals(mSelectedAccount.getName()) && acc.type.equals(mSelectedAccount.getType())) {
      instance=new ServerInstance(AccountManager.get(mContext),acc);
      break;
    }
  }
  mBinder.searchDirs(instance);
}
 

void setListener(){
  Intent rService=new Intent(this,RecordingService.class);
  ServiceConnection sc=new ServiceConnection(){
    public void onServiceDisconnected(    ComponentName name){
    }
    public void onServiceConnected(    ComponentName name,    IBinder service){
      IRecordService rs=(IRecordService)service;
      if (RecordingActivity.this.isRecording) {
        rs.resumeRecording();
      }
 else {
        rs.pauseRecording();
      }
      unbindService(this);
    }
  }
;
  bindService(rService,sc,Context.BIND_AUTO_CREATE);
}
 

public void onServiceConnected(ComponentName className,IBinder service){
  mService=IRemoteECFService.Stub.asInterface(service);
  mStartServiceButton.setEnabled(true);
  mCallbackText.setText("Attached.");
  try {
    mService.registerCallback(mCallback);
  }
 catch (  RemoteException e) {
  }
  Toast.makeText(ServerContainer.this,R.string.remote_service_connected,Toast.LENGTH_SHORT).show();
}
 

void _nfcEeClose(int callingPid,IBinder binder) throws IOException {
synchronized (NfcService.this) {
    if (!isNfcEnabledOrShuttingDown()) {
      throw new IOException("NFC adapter is disabled");
    }
    if (mOpenEe == null) {
      throw new IOException("NFC EE closed");
    }
    if (callingPid != -1 && callingPid != mOpenEe.pid) {
      throw new SecurityException("Wrong PID");
    }
    if (mOpenEe.binder != binder) {
      throw new SecurityException("Wrong binder handle");
    }
    binder.unlinkToDeath(mOpenEe,0);
    mDeviceHost.resetTimeouts();
    mSecureElement.doDisconnect(mOpenEe.handle);
    mOpenEe=null;
    applyRouting(true);
  }
}
 

@Override public void onServiceConnected(ComponentName name,IBinder service){
  UpdaterBinder binder=(UpdaterBinder)service;
  mService=binder.getService();
  mBound=true;
  mService.registerUpdaterListener(UpdaterFragment.this);
  if (!mService.isRunning())   mService.getManifest();
}
 

@Override public IBinder onBind(Intent intent){
  if (AccountManager.ACTION_AUTHENTICATOR_INTENT.equals(intent.getAction())) {
    return new Authenticator(this).getIBinder();
  }
 else {
    return null;
  }
}
 

@Override public IBinder onBind(Intent intent){
  if (IAndTweetService.class.getName().equals(intent.getAction())) {
    return mBinder;
  }
  return null;
}
 

/** 
 * This is called when we are connected to the MarketBillingService. This runs in the main UI thread.
 */
public void onServiceConnected(ComponentName name,IBinder service){
  if (Consts.DEBUG) {
    Log.d(TAG,"Billing service connected");
  }
  mService=IMarketBillingService.Stub.asInterface(service);
  runPendingRequests();
}
 

@Override public void onServiceConnected(ComponentName className,IBinder service){
  mDownloadManagerService=IDownloadManagerService.Stub.asInterface(service);
  Log.i(AnkiDroidApp.TAG,"onServiceConnected");
  try {
    mDownloadManagerService.registerPersonalDeckCallback(mCallback);
  }
 catch (  RemoteException e) {
  }
}
 

@Override public AbstractInputMethodImpl onCreateInputMethodInterface(){
  return new InputMethodImpl(){
    @Override public void attachToken(    IBinder token){
      super.attachToken(token);
      mImeToken=token;
    }
  }
;
}
 

public Connection(Context ctx,OnConnectionServiceReadyListener ocsrListener){
  mOnConnectionServiceReadyListener=ocsrListener;
  mContext=ctx;
  mPackageName=ctx.getPackageName();
  mServiceConnection=new ServiceConnection(){
    public void onServiceConnected(    ComponentName name,    IBinder service){
synchronized (mStartLock) {
        mIconnection=IConnection.Stub.asInterface(service);
        mStarted=true;
        if (mOnConnectionServiceReadyListener != null) {
          mOnConnectionServiceReadyListener.OnConnectionServiceReady();
        }
      }
    }
    public void onServiceDisconnected(    ComponentName name){
synchronized (mStartLock) {
        try {
          mStarted=false;
          mIconnection.unregisterCallback(mPackageName);
          mIconnection.shutdown(mPackageName);
        }
 catch (        RemoteException e) {
          Log.e(TAG,"RemoteException in onServiceDisconnected",e);
        }
        mIconnection=null;
      }
    }
  }
;
  Intent intent=new Intent("com.google.intent.action.BT_ClickLinkCompete_SERVICE");
  intent.addCategory("com.google.intent.category.BT_ClickLinkCompete");
  mContext.bindService(intent,mServiceConnection,Context.BIND_AUTO_CREATE);
}
 

/** 
 * Bind to the xmpp service.
 */
private final synchronized void bindService(){
  if (serviceConnection == null) {
    serviceConnection=new ServiceConnection(){
      public void onServiceDisconnected(      ComponentName name){
      }
      public void onServiceConnected(      ComponentName name,      IBinder binder){
        service=IXmppTransportService.Stub.asInterface(binder);
      }
    }
;
  }
  authenticatorActivity.bindService(new Intent(IXmppTransportService.class.getName()),serviceConnection,Context.BIND_AUTO_CREATE);
}
 

/** 
 * Cast an IBinder object into an ILicenseResultListener interface, generating a proxy if needed.
 */
public static com.android.vending.licensing.ILicenseResultListener asInterface(android.os.IBinder obj){
  if ((obj == null)) {
    return null;
  }
  android.os.IInterface iin=(android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);
  if (((iin != null) && (iin instanceof com.android.vending.licensing.ILicenseResultListener))) {
    return ((com.android.vending.licensing.ILicenseResultListener)iin);
  }
  return new com.android.vending.licensing.ILicenseResultListener.Stub.Proxy(obj);
}
 

public void onServiceConnected(ComponentName className,IBinder service){
  resourceServiceBound=true;
  resourceMessenger=new Messenger(service);
  sendMessageToService(ResourceService.MSG_REGISTER_CLIENT);
  ListIterator<Message> iterator=messageQueue.listIterator();
  while (iterator.hasNext()) {
    sendMessageToService(iterator.next());
  }
  messageQueue.clear();
}
 

public void onServiceConnected(ComponentName className,IBinder service){
  mService=new Messenger(service);
  AndroidSpineServerMainActivity.getInstance().setmService(mService);
  Log.i(TAG,"Service Connected");
  try {
    Message msg=Message.obtain(null,MSG_REGISTER_CLIENT);
    msg.replyTo=mMessenger;
    mService.send(msg);
  }
 catch (  RemoteException e) {
    Log.e(TAG,"Remove exception " + e.toString());
  }
}
 

@Override public void onServiceConnected(ComponentName name,IBinder service){
  midiService=((BluetoothMidiService.BluetoothMidiBinder)service).getService();
  try {
    midiService.init(observer,receiver);
  }
 catch (  IOException e) {
    toast("MIDI not available");
    finish();
  }
}
 

/** 
 * Called when the activity is first created. 
 */
@Override public void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  System.out.println(">>> onCreate");
  Intent service=new Intent(this,AIDLDeadlockService.class);
  ServiceConnection connection=new ServiceConnection(){
    @Override public void onServiceDisconnected(    ComponentName name){
    }
    @Override public void onServiceConnected(    ComponentName name,    IBinder service){
      mService=IDeadlock.Stub.asInterface(service);
      System.out.println(">>> onService Connected");
      try {
synchronized (LOCK1) {
          mService.setCallback(mCB);
          mService.doStep1();
        }
      }
 catch (      RemoteException e) {
        e.printStackTrace();
      }
    }
  }
;
  bindService(service,connection,BIND_AUTO_CREATE);
}
 

@Override public void onServiceConnected(ComponentName name,IBinder binder){
  Log.v(Cicada.TAG,"DeviceService bound");
  service=((DeviceService.DeviceServiceBinder)binder).getService();
  connectionListener=createConnectionListener();
  service.setListener(connectionListener);
  connected=true;
}
 

@Override public void onServiceConnected(ComponentName name,IBinder service){
  serviceMovie=IServiceMovie.Stub.asInterface(service);
  try {
    serviceMovie.registerCallback(m_callback);
  }
 catch (  RemoteException e) {
    e.printStackTrace();
  }
}
 

public void onServiceConnected(ComponentName className,IBinder service){
  bound=((TerminalManager.TerminalBinder)service).getService();
  bound.disconnectHandler=disconnectHandler;
  Log.d(TAG,String.format("Connected to TerminalManager and found bridges.size=%d",bound.bridges.size()));
  bound.setResizeAllowed(true);
  bound.hardKeyboardHidden=(getResources().getConfiguration().hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES);
  if (bound.getFullScreen() == 0) {
    if (prefs.getBoolean(PreferenceConstants.FULLSCREEN,false))     setFullScreen(FULLSCREEN_ON);
 else     setFullScreen(FULLSCREEN_OFF);
  }
 else   if (fullScreen != bound.getFullScreen())   setFullScreen(bound.getFullScreen());
  flip.removeAllViews();
  final String requestedNickname=(requested != null) ? requested.getFragment() : null;
  int requestedIndex=-1;
  TerminalBridge requestedBridge=bound.getConnectedBridge(requestedNickname);
  if (requestedNickname != null && requestedBridge == null) {
    try {
      Log.d(TAG,String.format("We couldnt find an existing bridge with URI=%s (nickname=%s), so creating one now",requested.toString(),requestedNickname));
      requestedBridge=bound.openConnection(requested);
    }
 catch (    Exception e) {
      Log.e(TAG,"Problem while trying to create new requested bridge from URI",e);
    }
  }
  for (  TerminalBridge bridge : bound.bridges) {
    final int currentIndex=addNewTerminalView(bridge);
    if (bridge == requestedBridge) {
      requestedIndex=currentIndex;
      bound.defaultBridge=bridge;
    }
  }
  if (requestedIndex < 0) {
    requestedIndex=getFlipIndex(bound.defaultBridge);
    if (requestedIndex < 0)     requestedIndex=0;
  }
  setDisplayedTerminal(requestedIndex);
}