private void registerClientLocked(IMediaRouterClient client,
            int pid, String packageName, int userId, boolean trusted) {
        final IBinder binder = client.asBinder();
        ClientRecord clientRecord = mAllClientRecords.get(binder);
        if (clientRecord == null) {
            boolean newUser = false;
            UserRecord userRecord = mUserRecords.get(userId);
            if (userRecord == null) {
                userRecord = new UserRecord(userId);
                newUser = true;
            }
            clientRecord = new ClientRecord(userRecord, client, pid, packageName, trusted);
            try {
                binder.linkToDeath(clientRecord, 0);
            } catch (RemoteException ex) {
                throw new RuntimeException("Media router client died prematurely.", ex);
            }

            if (newUser) {
                mUserRecords.put(userId, userRecord);
                initializeUserLocked(userRecord);
            }

            userRecord.mClientRecords.add(clientRecord);
            mAllClientRecords.put(binder, clientRecord);
            initializeClientLocked(clientRecord);
        }
    }
 private final void remove_all_objects(ArrayMap<String, F[]> map, String name, Object object) {
   F[] array = map.get(name);
   if (array != null) {
     int LAST = array.length - 1;
     while (LAST >= 0 && array[LAST] == null) {
       LAST--;
     }
     for (int idx = LAST; idx >= 0; idx--) {
       if (array[idx] == object) {
         final int remain = LAST - idx;
         if (remain > 0) {
           System.arraycopy(array, idx + 1, array, idx, remain);
         }
         array[LAST] = null;
         LAST--;
       }
     }
     if (LAST < 0) {
       map.remove(name);
     } else if (LAST < (array.length / 2)) {
       F[] newa = newArray(LAST + 2);
       System.arraycopy(array, 0, newa, 0, LAST + 1);
       map.put(name, newa);
     }
   }
 }
  private String getDocIdForFile(File file) throws FileNotFoundException {
    String path = file.getAbsolutePath();

    // Find the most-specific root path
    String mostSpecificId = null;
    String mostSpecificPath = null;
    synchronized (mRootsLock) {
      for (int i = 0; i < mRoots.size(); i++) {
        final String rootId = mRoots.keyAt(i);
        final String rootPath = mRoots.valueAt(i).path.getAbsolutePath();
        if (path.startsWith(rootPath)
            && (mostSpecificPath == null || rootPath.length() > mostSpecificPath.length())) {
          mostSpecificId = rootId;
          mostSpecificPath = rootPath;
        }
      }
    }

    if (mostSpecificPath == null) {
      throw new FileNotFoundException("Failed to find root that contains " + path);
    }

    // Start at first char of path under root
    final String rootPath = mostSpecificPath;
    if (rootPath.equals(path)) {
      path = "";
    } else if (rootPath.endsWith("/")) {
      path = path.substring(rootPath.length());
    } else {
      path = path.substring(rootPath.length() + 1);
    }

    return mostSpecificId + ':' + path;
  }
Пример #4
0
  /**
   * Remove process record for voice extension service.
   *
   * @param pid process id
   * @param uid user id
   */
  public void removeProcessRecordLocked(int pid, int uid) {
    ProcessRecord record = mProcessRecords.get(pid);

    if (record != null && record.getUid() == uid) {
      mProcessRecords.remove(pid);
    }
  }
Пример #5
0
 /**
  * Gets the primary activity without calling from an Activity class
  *
  * @return the main Activity
  */
 @TargetApi(Build.VERSION_CODES.KITKAT)
 public static Activity getActivity() {
   /*ActivityManager am = (ActivityManager)getContext().getSystemService(Context.ACTIVITY_SERVICE);
   ComponentName cn = am.getRunningTasks(1).get(0).topActivity;*/
   try {
     Class activityThreadClass = Class.forName("android.app.ActivityThread");
     Object activityThread = activityThreadClass.getMethod("currentActivityThread").invoke(null);
     Field activitiesField = activityThreadClass.getDeclaredField("mActivities");
     activitiesField.setAccessible(true);
     ArrayMap activities = (ArrayMap) activitiesField.get(activityThread);
     for (Object activityRecord : activities.values()) {
       Class activityRecordClass = activityRecord.getClass();
       Field pausedField = activityRecordClass.getDeclaredField("paused");
       pausedField.setAccessible(true);
       if (!pausedField.getBoolean(activityRecord)) {
         Field activityField = activityRecordClass.getDeclaredField("activity");
         activityField.setAccessible(true);
         return (Activity) activityField.get(activityRecord);
       }
     }
   } catch (final java.lang.Throwable e) {
     // handle exception
     throw new IllegalArgumentException("No activity could be retrieved!");
   }
   throw new IllegalArgumentException("No activity could be found!");
 }
 /**
  * Sets a specific transition to occur when the given pair of scenes is exited/entered.
  *
  * @param fromScene The scene being exited when the given transition will be run
  * @param toScene The scene being entered when the given transition will be run
  * @param transition The transition that will play when the given scene is entered. A value of
  *     null will result in the default behavior of using the default transition instead.
  */
 public void setTransition(Scene fromScene, Scene toScene, Transition transition) {
   ArrayMap<Scene, Transition> sceneTransitionMap = mScenePairTransitions.get(toScene);
   if (sceneTransitionMap == null) {
     sceneTransitionMap = new ArrayMap<Scene, Transition>();
     mScenePairTransitions.put(toScene, sceneTransitionMap);
   }
   sceneTransitionMap.put(fromScene, transition);
 }
Пример #7
0
 public <T extends RxViewDispatch> void unregisterRxError(final T object) {
   String tag = object.getClass().getSimpleName() + "_error";
   Subscription subscription = mRxActionMap.get(tag);
   if (subscription != null && !subscription.isUnsubscribed()) {
     subscription.unsubscribe();
     mRxActionMap.remove(tag);
   }
 }
 /**
  * Put an int value into the meta data. Custom keys may be used, but if the METADATA_KEYs
  * defined in this class are used they may only be one of the following:
  *
  * <ul>
  *   <li>{@link #METADATA_KEY_RDS_PTY}
  *   <li>{@link #METADATA_KEY_RBDS_PTY}
  * </ul>
  *
  * @param key The key for referencing this value
  * @param value The int value to store
  * @return the same Builder instance
  */
 public Builder putInt(String key, int value) {
   if (!METADATA_KEYS_TYPE.containsKey(key)
       || METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_INT) {
     throw new IllegalArgumentException("The " + key + " key cannot be used to put a long");
   }
   mBundle.putInt(key, value);
   return this;
 }
 /**
  * Put a {@link Bitmap} into the meta data. Custom keys may be used, but if the METADATA_KEYs
  * defined in this class are used they may only be one of the following:
  *
  * <ul>
  *   <li>{@link #METADATA_KEY_ICON}
  *   <li>{@link #METADATA_KEY_ART}
  * </ul>
  *
  * <p>
  *
  * @param key The key for referencing this value
  * @param value The Bitmap to store
  * @return the same Builder instance
  */
 public Builder putBitmap(String key, Bitmap value) {
   if (!METADATA_KEYS_TYPE.containsKey(key)
       || METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_BITMAP) {
     throw new IllegalArgumentException("The " + key + " key cannot be used to put a Bitmap");
   }
   mBundle.putParcelable(key, value);
   return this;
 }
 int putStringFromNative(int nativeKey, String value) {
   String key = getKeyFromNativeKey(nativeKey);
   if (!METADATA_KEYS_TYPE.containsKey(key) || METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_TEXT) {
     return -1;
   }
   mBundle.putString(key, value);
   return 0;
 }
 Request removeRequest(IBinder reqInterface) {
   synchronized (this) {
     Request req = mActiveRequests.get(reqInterface);
     if (req != null) {
       mActiveRequests.remove(req);
     }
     return req;
   }
 }
 public void resetSimulation(IndentingPrintWriter pw) {
   synchronized (mLock) {
     pw.println("Removing all simulated ports and ending simulation.");
     if (!mSimulatedPorts.isEmpty()) {
       mSimulatedPorts.clear();
       updatePortsLocked(pw);
     }
   }
 }
 public UsbPort[] getPorts() {
   synchronized (mLock) {
     final int count = mPorts.size();
     final UsbPort[] result = new UsbPort[count];
     for (int i = 0; i < count; i++) {
       result[i] = mPorts.valueAt(i).mUsbPort;
     }
     return result;
   }
 }
Пример #14
0
  public synchronized void unregisterAll() {
    for (Subscription subscription : mRxActionMap.values()) {
      subscription.unsubscribe();
    }

    for (Subscription subscription : mRxStoreMap.values()) {
      subscription.unsubscribe();
    }

    mRxActionMap.clear();
    mRxStoreMap.clear();
  }
 public boolean isSnoozed(String packageName) {
   final String key = snoozeKey(packageName, mUser);
   Long snoozedUntil = mSnoozedPackages.get(key);
   if (snoozedUntil != null) {
     if (snoozedUntil > SystemClock.elapsedRealtime()) {
       if (DEBUG) Log.v(TAG, key + " snoozed");
       return true;
     }
     mSnoozedPackages.remove(packageName);
   }
   return false;
 }
  public void removeSimulatedPort(String portId, IndentingPrintWriter pw) {
    synchronized (mLock) {
      final int index = mSimulatedPorts.indexOfKey(portId);
      if (index < 0) {
        pw.println("Cannot remove simulated port which does not exist.");
        return;
      }

      pw.println("Disconnecting simulated port: portId=" + portId);
      mSimulatedPorts.removeAt(index);
      updatePortsLocked(pw);
    }
  }
  private void startObserving(File file, Uri notifyUri) {
    synchronized (mObservers) {
      DirectoryObserver observer = mObservers.get(file);
      if (observer == null) {
        observer = new DirectoryObserver(file, getContext().getContentResolver(), notifyUri);
        observer.startWatching();
        mObservers.put(file, observer);
      }
      observer.mRefCount++;

      if (LOG_INOTIFY) Log.d(TAG, "after start: " + observer);
    }
  }
  private void stopObserving(File file) {
    synchronized (mObservers) {
      DirectoryObserver observer = mObservers.get(file);
      if (observer == null) return;

      observer.mRefCount--;
      if (observer.mRefCount == 0) {
        mObservers.remove(file);
        observer.stopWatching();
      }

      if (LOG_INOTIFY) Log.d(TAG, "after stop: " + observer);
    }
  }
Пример #19
0
 /**
  * Perform a {@link #put(Object, Object)} of all key/value pairs in <var>array</var>
  *
  * @param array The array whose contents are to be retrieved.
  */
 public void putAll(ArrayMap<? extends K, ? extends V> array) {
   final int N = array.mSize;
   ensureCapacity(mSize + N);
   if (mSize == 0) {
     if (N > 0) {
       System.arraycopy(array.mHashes, 0, mHashes, 0, N);
       System.arraycopy(array.mArray, 0, mArray, 0, N << 1);
       mSize = N;
     }
   } else {
     for (int i = 0; i < N; i++) {
       put(array.keyAt(i), array.valueAt(i));
     }
   }
 }
  private File getFileForDocId(String docId, boolean visible) throws FileNotFoundException {
    final int splitIndex = docId.indexOf(':', 1);
    final String tag = docId.substring(0, splitIndex);
    final String path = docId.substring(splitIndex + 1);

    RootInfo root;
    synchronized (mRootsLock) {
      root = mRoots.get(tag);
    }
    if (root == null) {
      throw new FileNotFoundException("No root for " + tag);
    }

    File target = visible ? root.visiblePath : root.path;
    if (target == null) {
      return null;
    }
    if (!target.exists()) {
      target.mkdirs();
    }
    target = new File(target, path);
    if (!target.exists()) {
      throw new FileNotFoundException("Missing file for " + docId + " at " + target);
    }
    return target;
  }
  @Override
  public Cursor querySearchDocuments(String rootId, String query, String[] projection)
      throws FileNotFoundException {
    final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));

    final File parent;
    synchronized (mRootsLock) {
      parent = mRoots.get(rootId).path;
    }

    final LinkedList<File> pending = new LinkedList<File>();
    pending.add(parent);
    while (!pending.isEmpty() && result.getCount() < 24) {
      final File file = pending.removeFirst();
      if (file.isDirectory()) {
        for (File child : file.listFiles()) {
          pending.add(child);
        }
      }
      if (file.getName().toLowerCase().contains(query)) {
        includeFile(result, null, file);
      }
    }
    return result;
  }
    private void setSelectedRouteLocked(IMediaRouterClient client,
            String routeId, boolean explicit) {
        ClientRecord clientRecord = mAllClientRecords.get(client.asBinder());
        if (clientRecord != null) {
            final String oldRouteId = clientRecord.mSelectedRouteId;
            if (!Objects.equals(routeId, oldRouteId)) {
                if (DEBUG) {
                    Slog.d(TAG, clientRecord + ": Set selected route, routeId=" + routeId
                            + ", oldRouteId=" + oldRouteId
                            + ", explicit=" + explicit);
                }

                clientRecord.mSelectedRouteId = routeId;
                if (explicit) {
                    // Any app can disconnect from the globally selected route.
                    if (oldRouteId != null) {
                        clientRecord.mUserRecord.mHandler.obtainMessage(
                                UserHandler.MSG_UNSELECT_ROUTE, oldRouteId).sendToTarget();
                    }
                    // Only let the system connect to new global routes for now.
                    // A similar check exists in the display manager for wifi display.
                    if (routeId != null && clientRecord.mTrusted) {
                        clientRecord.mUserRecord.mHandler.obtainMessage(
                                UserHandler.MSG_SELECT_ROUTE, routeId).sendToTarget();
                    }
                }
            }
        }
    }
 Request newRequest(IVoiceInteractorCallback callback) {
   synchronized (this) {
     Request req = new Request(callback, this);
     mActiveRequests.put(req.mInterface.asBinder(), req);
     return req;
   }
 }
 private MediaRouterClientState getStateLocked(IMediaRouterClient client) {
     ClientRecord clientRecord = mAllClientRecords.get(client.asBinder());
     if (clientRecord != null) {
         return clientRecord.getState();
     }
     return null;
 }
  public void addSimulatedPort(String portId, int supportedModes, IndentingPrintWriter pw) {
    synchronized (mLock) {
      if (mSimulatedPorts.containsKey(portId)) {
        pw.println("Port with same name already exists.  Please remove it first.");
        return;
      }

      pw.println(
          "Adding simulated port: portId="
              + portId
              + ", supportedModes="
              + UsbPort.modeToString(supportedModes));
      mSimulatedPorts.put(portId, new SimulatedPortInfo(portId, supportedModes));
      updatePortsLocked(pw);
    }
  }
  public void dump(IndentingPrintWriter pw) {
    synchronized (mLock) {
      pw.print("USB Port State:");
      if (!mSimulatedPorts.isEmpty()) {
        pw.print(" (simulation active; end with 'dumpsys usb reset')");
      }
      pw.println();

      if (mPorts.isEmpty()) {
        pw.println("  <no ports>");
      } else {
        for (PortInfo portInfo : mPorts.values()) {
          pw.println("  " + portInfo.mUsbPort.getId() + ": " + portInfo);
        }
      }
    }
  }
 private void snooze() {
   if (mMostRecentPackageName != null) {
     mSnoozedPackages.put(
         snoozeKey(mMostRecentPackageName, mUser),
         SystemClock.elapsedRealtime() + mSnoozeLengthMs);
   }
   releaseAndClose();
 }
 static {
   METADATA_KEYS_TYPE = new ArrayMap<String, Integer>();
   METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_PI, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_PS, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_PTY, METADATA_TYPE_INT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_RBDS_PTY, METADATA_TYPE_INT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_RT, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_TITLE, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_ARTIST, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_ALBUM, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_GENRE, METADATA_TYPE_TEXT);
   METADATA_KEYS_TYPE.put(METADATA_KEY_ICON, METADATA_TYPE_BITMAP);
   METADATA_KEYS_TYPE.put(METADATA_KEY_ART, METADATA_TYPE_BITMAP);
 }
 int putBitmapFromNative(int nativeKey, byte[] value) {
   String key = getKeyFromNativeKey(nativeKey);
   if (!METADATA_KEYS_TYPE.containsKey(key)
       || METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_BITMAP) {
     return -1;
   }
   Bitmap bmp = null;
   try {
     bmp = BitmapFactory.decodeByteArray(value, 0, value.length);
   } catch (Exception e) {
   } finally {
     if (bmp == null) {
       return -1;
     }
     mBundle.putParcelable(key, bmp);
     return 0;
   }
 }
Пример #30
0
  /**
   * Get the process record with the same pid & uid.
   *
   * @param pid process id
   * @param uid user id
   * @return process record
   */
  public ProcessRecord getProcessRecordLocked(int pid, int uid) {
    ProcessRecord record = mProcessRecords.get(pid);

    if (record != null && record.getUid() != uid) {
      record = null;
      // mProcessRecords.remove(pid);
    }
    return record;
  }