public RankingModelImpl(Workspace workspace) {
   this.workspace = workspace;
   this.listeners = Collections.synchronizedList(new ArrayList<RankingListener>());
   this.autoRankings = Collections.synchronizedList(new ArrayList<AutoRanking>());
   this.interpolator = Interpolator.LINEAR;
   this.autoTransformer = new RankingAutoTransformer(this);
 }
Exemple #2
0
  private void hantei() {
    double treeLen = totalTreeLength();
    // if the current tree length is less than the previous minimum tree,
    // then copy the current tree to the min tree
    if (treeLen < minTreeLen) {
      // the current tree is now the minimum tree
      numBetterTreesFound++;
      minTreeLen = treeLen;
      synchronized (this) {
        // copy all the x,y coords and whether they're steiner min nodes
        this.minPoints = Collections.synchronizedList(new ArrayList<Point>());
        for (Point p : this.points) {
          this.minPoints.add(p.copy());
        }

        // update the number of nodes in SMT
        numNodesInSMT = this.points.size();

        // copy over all the edges
        this.minEdges = Collections.synchronizedList(new ArrayList<Edge>());
        for (int i = 0; i < this.points.size() - 1; i++) {
          this.minEdges.add(this.edges.get(i).copy());
        }
      }
      // repaint this em effin' tree
      repaintIfNecessary(true);
    }
  } // hantei
  /** Default constructor. */
  protected SIPTransactionStack() {
    super();
    this.transactionTableSize = -1;
    // a set of methods that result in dialog creation.
    this.dialogCreatingMethods = new HashSet<String>();
    // Standard set of methods that create dialogs.
    this.dialogCreatingMethods.add(Request.REFER);
    this.dialogCreatingMethods.add(Request.INVITE);
    this.dialogCreatingMethods.add(Request.SUBSCRIBE);
    // Notify may or may not create a dialog. This is handled in
    // the code.
    // Create the transaction collections

    clientTransactions = Collections.synchronizedList(new ArrayList<SIPClientTransaction>());
    serverTransactions = Collections.synchronizedList(new ArrayList<SIPServerTransaction>());
    // Dialog dable.
    this.dialogTable = new Hashtable<String, SIPDialog>();

    clientTransactionTable = new Hashtable<String, SIPTransaction>();
    serverTransactionTable = new Hashtable<String, SIPTransaction>();

    // Start the timer event thread.

    this.timer = new Timer();
    this.pendingRecordScanner = new Thread(new PendingRecordScanner(this));
    this.pendingRecordScanner.setDaemon(true);
    this.pendingTransactions = new HashSet<SIPServerTransaction>();
    pendingRecords = Collections.synchronizedList(new ArrayList<PendingRecord>());
    pendingRecordScanner.setName("PendingRecordScanner");
    pendingRecordScanner.start();
    // endif
    //

  }
 public DataNode(Communicator communicator) {
   super(communicator);
   mapTasks = Collections.synchronizedList(new ArrayList<MapTask>());
   reduceTasks = Collections.synchronizedList(new ArrayList<ReduceTask>());
   jobExecutors = new HashMap<Integer, List<ExecutorService>>();
   mapLock = new ReentrantLock();
   reduceLock = new ReentrantLock();
 }
Exemple #5
0
 /**
  * Creates a new instance of Sender, a packet sending queue.
  *
  * @param group ThreadGroup of this Session
  * @param socket Connection to the outside world
  */
 public Sender(ThreadGroup group, DatagramSocket socket) {
   super(group, group.getName() + "-Sender");
   m_socket = socket;
   m_packetsSent = 0;
   m_packets = Collections.synchronizedList(new LinkedList<DatagramPacket>());
   m_highPriorityPackets = Collections.synchronizedList(new LinkedList<DatagramPacket>());
   start();
 }
Exemple #6
0
 private void init(final String groupName, final boolean collapsed) {
   this.groupName = groupName;
   this.collapsed = collapsed;
   this.collapseable = true;
   this.rowMembers = Collections.synchronizedList(new ArrayList<T>());
   this.staticRowMembers = Collections.synchronizedList(new ArrayList<T>());
   this.childGroups = Collections.synchronizedList(new ArrayList<IRowGroup<T>>());
   this.data = new HashMap<String, Object>();
 }
 /** Initialize variables to default values. */
 public AbstractConnection() {
   internalQueue = Collections.synchronizedList(new LinkedList<KtnDatagram>());
   externalQueue = Collections.synchronizedList(new LinkedList<KtnDatagram>());
   isReceiving = false;
   nextSequenceNo = (int) (Math.random() * 10000 + 1);
   disconnectRequest = null;
   lastDataPacketSent = null;
   lastValidPacketReceived = null;
   state = State.CLOSED;
 }
 /**
  * @param flags
  * @param id
  * @param multicast
  */
 protected DNSMessage(int flags, int id, boolean multicast) {
   super();
   _flags = flags;
   _id = id;
   _multicast = multicast;
   _questions = Collections.synchronizedList(new LinkedList<DNSQuestion>());
   _answers = Collections.synchronizedList(new LinkedList<DNSRecord>());
   _authoritativeAnswers = Collections.synchronizedList(new LinkedList<DNSRecord>());
   _additionals = Collections.synchronizedList(new LinkedList<DNSRecord>());
 }
 public GameData() {
   this.mode = GameData.MODE_LOAD;
   this.figures = Collections.synchronizedList(new ArrayList<GameFigure>());
   this.lines = Collections.synchronizedList(new ArrayList<Line>());
   //        this.figures.add(new Tank(50, 50, Color.blue));
   this.tank = new Tank(50, 50, Color.blue, this);
   //        this.field = new FieldSection[23][23];
   this.field = new Field();
   this.fieldLoaded = false;
 }
  public PostProcessingManager(RajawaliRenderer renderer, int width, int height) {
    mRenderer = renderer;

    if (width == -1 && height == -1) {
      width = mRenderer.getViewportWidth();
      height = mRenderer.getViewportHeight();
    }

    mWidth = width;
    mHeight = height;

    mScreenQuad = new ScreenQuad();
    mScene = new RajawaliScene(mRenderer, GRAPH_TYPE.NONE);

    mRenderTarget1 =
        new RenderTarget(
            "rt1" + hashCode(),
            width,
            height,
            0,
            0,
            false,
            false,
            GLES20.GL_TEXTURE_2D,
            Config.ARGB_8888,
            FilterType.LINEAR,
            WrapType.CLAMP);
    mRenderTarget2 =
        new RenderTarget(
            "rt2" + hashCode(),
            width,
            height,
            0,
            0,
            false,
            false,
            GLES20.GL_TEXTURE_2D,
            Config.ARGB_8888,
            FilterType.LINEAR,
            WrapType.CLAMP);

    mWriteBuffer = mRenderTarget1;
    mReadBuffer = mRenderTarget2;

    mCopyPass = new EffectPass(new CopyPass());
    mComponents =
        Collections.synchronizedList(new CopyOnWriteArrayList<IPostProcessingComponent>());
    mPasses = Collections.synchronizedList(new CopyOnWriteArrayList<IPass>());

    mRenderer.addRenderTarget(mWriteBuffer);
    mRenderer.addRenderTarget(mReadBuffer);

    mScene.addChild(mScreenQuad);
    mRenderer.addScene(mScene);
  }
Exemple #11
0
 /*
  * (non-Javadoc)
  * @see rajawali.scenegraph.AD_AABBTree#init()
  */
 @Override
 protected void init() {
   // Pre-allocate storage here to favor modification speed
   CHILD_COUNT = 8;
   mChildren = new Octree[CHILD_COUNT];
   mMembers = Collections.synchronizedList(new CopyOnWriteArrayList<IGraphNodeMember>());
   if (mParent == null) // mOutside should not be used for children, thus we want to force the Null
     // pointer.
     mOutside = Collections.synchronizedList(new CopyOnWriteArrayList<IGraphNodeMember>());
   mChildLengths = new Vector3();
 }
Exemple #12
0
  public SendToModel(List<File> fileList) {
    super();

    if (fileList == null) throw new NullPointerException("files cannot be null");
    else {
      this.fileList = Collections.synchronizedList(fileList);
      rendererList = Collections.synchronizedList(new ArrayList<Renderer>());
      milliSecondWait = 10000;

      commandList = new ArrayList<Command>();
    }
  }
  /**
   * Generates a compatibility graph between two molecules
   *
   * @param source
   * @param target
   * @param shouldMatchBonds
   * @param shouldMatchRings
   * @param matchAtomType
   * @throws java.io.IOException
   */
  public GenerateCompatibilityGraph(
      IAtomContainer source,
      IAtomContainer target,
      boolean shouldMatchBonds,
      boolean shouldMatchRings,
      boolean matchAtomType)
      throws IOException {
    this.shouldMatchRings = shouldMatchRings;
    this.shouldMatchBonds = shouldMatchBonds;
    this.matchAtomType = matchAtomType;
    this.source = source;
    this.target = target;
    compGraphNodes = new ArrayList<>();
    compGraphNodesCZero = new ArrayList<>();
    cEdges = Collections.synchronizedList(new ArrayList<Integer>());
    dEdges = Collections.synchronizedList(new ArrayList<Integer>());

    /*
    Generate all possible graphs when no ring match or atom type is required
    */
    /*
    Modification for AAM only
    */
    if ((!shouldMatchBonds || !matchAtomType)
        && source.getAtomCount() > 30
        && target.getAtomCount() > 30) {
      compatibilityGraphNodesIfCEdgeIsZero();
      compatibilityGraphCEdgeZero();
      clearCompGraphNodesCZero();
    } else {
      //        System.out.println("compatibilityGraphNodes ");
      compatibilityGraphNodes();
      //        System.out.println("compatibilityGraph ");
      compatibilityGraph();
      //        System.out.println("c-edges " + getCEgdes().size());
      //        System.out.println("d-edges " + getDEgdes().size());

      if (getCEdgesSize() == 0) {
        clearCompGraphNodes();

        clearCEgdes();
        clearDEgdes();

        resetCEdgesSize();
        resetDEdgesSize();

        compatibilityGraphNodesIfCEdgeIsZero();
        compatibilityGraphCEdgeZero();
        clearCompGraphNodesCZero();
      }
    }
  }
Exemple #14
0
public class MainApp implements Runnable, ShutdownHooks {

  volatile boolean keepRunning = true;
  volatile Thread sleepingThread = null;

  List<Runnable> jobs = Collections.synchronizedList(new ArrayList<>());
  List<Runnable> cleanUpJobs = Collections.synchronizedList(new ArrayList<>());

  public void sleep(long millis) {
    try {
      Thread.sleep(millis);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  @Override
  public synchronized void run() {
    work();

    while (keepRunning) {
      System.out.println("I am Running.");
      sleepingThread = Thread.currentThread();
      sleep(3_000);
    }
  }

  public boolean isRunning() {
    return keepRunning;
  }

  public void work() {
    for (Runnable job : jobs) {
      job.run();
    }
  }

  public void cleanup() {
    for (Runnable job : cleanUpJobs) {
      job.run();
    }
  }

  @Override
  public void closeInside() {
    if (sleepingThread != null)
      if (sleepingThread != Thread.currentThread()) {
        this.sleepingThread.interrupt();
      }
    this.keepRunning = false;
  }
}
 public SubscriptionRecordQueue(String id, int queueRecordCapacity, int queueTimeCapacity) {
   this.consumers = new ConcurrentHashMap<String, Integer>(10, 0.75f, 4);
   this.producers = new ConcurrentHashMap<String, Integer>(10, 0.75f, 4);
   if (queueRecordCapacity <= 0) {
     this.subscriptionRecordQueue = Collections.synchronizedList(new LinkedList<Record>());
   } else {
     this.subscriptionRecordQueue =
         Collections.synchronizedList(new ArrayList<Record>(queueRecordCapacity));
   }
   this.queueRecordCapacity = queueRecordCapacity;
   this.queueTimeCapacity = queueTimeCapacity;
   this.id = id;
 }
Exemple #16
0
 /**
  * Constructs a new <code>Session</code>.
  *
  * @param changed <code>true</code> if the session has changed, <code>false</code> otherwise.
  */
 public Session(File descriptorFile, boolean changed) {
   this.descriptorFile = descriptorFile;
   this.changed = changed;
   sessionListeners = Collections.synchronizedList(new ArrayList<SessionListener>());
   sessionElementListeners = Collections.synchronizedList(new ArrayList<SessionElementListener>());
   objectSelectionChangeListeners =
       Collections.synchronizedList(new ArrayList<ObjectSelectionChangeListener>());
   descriptors = Collections.synchronizedList(new ArrayList<SessionElementDescriptor>());
   selectedObjects = new SessionElementDescriptor[0];
   pcs = new PropertyChangeSupport(this);
   clientProperties = Collections.synchronizedMap(new HashMap<String, String>());
   persistentClientProperties = Collections.synchronizedMap(new HashMap<String, String>());
 }
  public FileDownloader(
      Context context,
      FileDownloaderListener listener,
      File rootDirectory,
      List<DownloadableObject> downloadableObjects) {
    super();
    this.context = context;
    this.listener = listener;
    this.rootDirectory = rootDirectory;

    // lets make sure the List is synchronized
    this.downloadableObjects = Collections.synchronizedList(downloadableObjects);
    arDownloadSize = Collections.synchronizedList(new ArrayList<String>(300));
  }
Exemple #18
0
  public Model(GameActivity gameActivity, Surface view) {
    m_view = view;
    m_gameActivity = gameActivity;
    m_view.addModel(this);
    m_barriers = Collections.synchronizedList(new ArrayList<Barrier>());
    m_balls = Collections.synchronizedList(new ArrayList<Ball>());
    m_bonusBalls = Collections.synchronizedList(new ArrayList<BonusBall>());
    m_newScorePoints = Collections.synchronizedList(new ArrayList<ScorePoint>());
    m_run = true;
    m_speed = m_defaultSpeed = 1;
    m_spaceBetweenRectangles = 0;
    m_score = 0;
    m_sleep = m_defaultSleep = 10;
    m_points = 2;
    m_nameToMediaPlayer = Collections.synchronizedMap(new HashMap<String, MediaPlayer>());
    mStartScore = 0;

    SharedPreferences prefs =
        PreferenceManager.getDefaultSharedPreferences(m_gameActivity.getApplicationContext());
    m_playSounds = !prefs.getBoolean("MuteSound", true);

    if (m_playSounds) {
      m_nameToMediaPlayer.put(
          "bomb", MediaPlayer.create(m_gameActivity.getBaseContext(), R.raw.bomb_bonus));
      m_nameToMediaPlayer.put(
          "color", MediaPlayer.create(m_gameActivity.getBaseContext(), R.raw.color_bonus));
      m_nameToMediaPlayer.put(
          "gameover", MediaPlayer.create(m_gameActivity.getBaseContext(), R.raw.gameover));
      m_nameToMediaPlayer.put(
          "points", MediaPlayer.create(m_gameActivity.getBaseContext(), R.raw.new_point));
      m_nameToMediaPlayer.put(
          "time", MediaPlayer.create(m_gameActivity.getBaseContext(), R.raw.time_bonus));
      m_nameToMediaPlayer.put(
          "win", MediaPlayer.create(m_gameActivity.getBaseContext(), R.raw.win));
    }

    prefs = PreferenceManager.getDefaultSharedPreferences(gameActivity.getApplicationContext());
    m_dificulty = prefs.getString("Dificulty", "Easy");

    if (m_dificulty.equalsIgnoreCase("Normal")) {
      m_points = 2;
      mStartScore = 701;
    } else if (m_dificulty.equalsIgnoreCase("Hard")) {
      m_points = 3;
      mStartScore = 1401;
    }

    m_defBallSpeed = m_ballSpeed = prefs.getInt("BallSpeed", 3);
  }
  public List<HoldingResult> Direction6() {
    List<HoldingResult> templist = Collections.synchronizedList(new ArrayList<HoldingResult>());
    // limitation for the shifts
    int ShiftX = this.n1 - this.X2max;
    int ShiftY = 0;

    int[][] matrixTemp = new int[this.n1][this.m];
    int[][] matrixPadded = new int[this.n1][this.m];
    if (this.n2 < this.n1) matrixPadded = this.SetingMaticesToSameDimension();
    else matrixPadded = this.discreteLane2;
    ZeroPadding zp = new ZeroPadding();
    Overlaping over = new Overlaping();
    boolean shift =
        true; // it is true by default -> if it is false then there is no overlapping of patterns

    // all possible not overlapping solutions (x,y shifts)

    List<Point> listOfEmbeding = Collections.synchronizedList(new ArrayList<Point>());

    for (int i = 0; i < ShiftX; i++) {
      // zero padding for appropriate shift
      matrixTemp = zp.Shifting(matrixPadded, i, 0, this.n1, this.m, 6);
      // checking if at this shift we have overlapping of patterns from both lanes
      shift =
          over.CheckOverlapingOfTwoDiscretizedLanes(
              this.discreteLane1,
              matrixTemp,
              this.X1min,
              this.X1max,
              this.X2min + i,
              this.X2max + i,
              this.Y1min,
              this.Y1max,
              this.Y2min,
              this.Y2max);
      if (shift == false) {
        HoldingResult temp = new HoldingResult();
        temp.setRepassing(true);
        temp.setDirection(6);
        temp.setShiftX(i);
        temp.setShiftY(0);
        templist.add(temp);
      }
      shift = true;
    }

    return templist;
  }
  static PsiElement[] getOccurrences(GrIntroduceParameterSettings settings) {
    final GrParametersOwner scope = settings.getToReplaceIn();

    final GrExpression expression = settings.getExpression();
    if (expression != null) {
      final PsiElement expr = PsiUtil.skipParentheses(expression, false);
      if (expr == null) return PsiElement.EMPTY_ARRAY;

      final PsiElement[] occurrences = GroovyRefactoringUtil.getExpressionOccurrences(expr, scope);
      if (occurrences == null || occurrences.length == 0) {
        throw new GrRefactoringError(GroovyRefactoringBundle.message("no.occurrences.found"));
      }
      return occurrences;
    } else {
      final GrVariable var = settings.getVar();
      LOG.assertTrue(var != null);
      final List<PsiElement> list = Collections.synchronizedList(new ArrayList<PsiElement>());
      ReferencesSearch.search(var, new LocalSearchScope(scope))
          .forEach(
              new Processor<PsiReference>() {
                @Override
                public boolean process(PsiReference psiReference) {
                  final PsiElement element = psiReference.getElement();
                  if (element != null) {
                    list.add(element);
                  }
                  return true;
                }
              });
      return list.toArray(new PsiElement[list.size()]);
    }
  }
 public SingleConnectionFactory() {
   super();
   setRequestedHeartbeat(CONNECTION_HEARTBEAT_IN_SEC);
   setConnectionTimeout(CONNECTION_TIMEOUT_IN_MS);
   connectionListeners = Collections.synchronizedList(new LinkedList<ConnectionListener>());
   connectionShutdownListener = new ConnectionShutDownListener();
 }
public class TTSService extends Service implements TextToSpeech.OnInitListener {
  private TextToSpeech textToSpeech;
  private List<String> textQ =
      Collections.synchronizedList(
          new ArrayList<String>()); // Just  in  two Service (two sms ) arrives too fast

  @Override
  public IBinder onBind(Intent arg0) {
    return null;
  }

  @Override
  public void onCreate() {
    super.onCreate();
  }

  @Override
  public void onDestroy() {
    if (textToSpeech != null) {
      textToSpeech.stop();
      textToSpeech.shutdown();
    }
    super.onDestroy();
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    Log.e(SpeedCopConstants.TAG, "INSIDE ONSTART OF TEH SERVUCE");
    String textToRead =
        intent != null
            ? intent.getStringExtra(SpeedCopConstants.INTENT_EXTRA_TEXT_TO_READ_OUT)
            : null;
    if (textToRead == null) textToRead = "Empty Message";
    textQ.add(textToRead);
    textToSpeech = new TextToSpeech(this, this);
    Log.e(SpeedCopConstants.TAG, "END FROM SERVICE");
    return super.onStartCommand(intent, flags, startId);
  }

  @Override
  public void onInit(int status) {
    Log.e(SpeedCopConstants.TAG, "INSIDE THE ONINIT");
    if (status != TextToSpeech.SUCCESS) {
      Log.e(SpeedCopConstants.TAG, "Could not initialize TextToSpeech.");
    } else {
      synchronized (textQ) {
        for (int i = 0; i < textQ.size(); i++) readText(textQ.get(i));
        Log.e(SpeedCopConstants.TAG, "TEXT Q SIZE-->" + textQ.size());
        textQ.clear();
      }
    }
    Log.e(SpeedCopConstants.TAG, "DONE THE ONINIT");
  }

  private void readText(String text) {
    Log.e(SpeedCopConstants.TAG, "called and now inside the readTEXT...==>" + text);
    textToSpeech.speak(text, TextToSpeech.QUEUE_ADD, null);
    Log.e(SpeedCopConstants.TAG, "DONE the readTEXT...");
  }
}
Exemple #23
0
 public static void main(String args[]) {
   Semaphore s = new Semaphore(5);
   NumberServer n = new NumberServer();
   ExecutorService executorService = Executors.newFixedThreadPool(10);
   List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>());
   for (int i = 0; i < 10; i++) {
     try {
       s.acquire();
     } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
     }
     executorService.execute(
         new Runnable() {
           public void run() {
             list.add(n.getNumber());
             s.release();
           }
         });
   }
   executorService.shutdown();
   try {
     s.acquire(5);
   } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
   for (int i = 0; i < 10; i++) {
     System.out.println(list.get(i));
   }
 }
Exemple #24
0
  private static class BlockingReceiver extends ReceiverAdapter {
    final CountDownLatch latch;
    final List<Integer> msgs = Collections.synchronizedList(new LinkedList<Integer>());

    public BlockingReceiver(CountDownLatch latch) {
      this.latch = latch;
    }

    public List<Integer> getMsgs() {
      return msgs;
    }

    public void receive(Message msg) {
      if (!msg.isFlagSet(Message.OOB)) {
        try {
          System.out.println(Thread.currentThread() + ": waiting on latch");
          latch.await(25000, TimeUnit.MILLISECONDS);
          System.out.println(Thread.currentThread() + ": DONE waiting on latch");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }

      msgs.add((Integer) msg.getObject());
    }
  }
  public static void reload() {
    LogLocation = tekkitrestrict.config.getString("LogLocation");
    LogNameFormat = tekkitrestrict.config.getString("LogNameFormat");
    LogStringFormat = tekkitrestrict.config.getString("LogStringFormat");
    LogIsEnabled = tekkitrestrict.config.getBoolean("LogIsEnabled");
    LogChat = tekkitrestrict.config.getBoolean("LogChat");
    LogChunkRemoval = tekkitrestrict.config.getBoolean("LogChunkUnload");
    LogLowPerformance = tekkitrestrict.config.getBoolean("LogLowPerformance");
    LogDupes = tekkitrestrict.config.getBoolean("LogDupes");
    LogAmulets = tekkitrestrict.config.getBoolean("LogAmulets");
    LogRings = tekkitrestrict.config.getBoolean("LogRings");
    LogGemPowers = tekkitrestrict.config.getBoolean("LogGemPowers");

    LogDMTools = tekkitrestrict.config.getBoolean("LogDMTools");
    LogRMTools = tekkitrestrict.config.getBoolean("LogRMTools");
    LogOpenAlc = tekkitrestrict.config.getBoolean("LogOpenAlc");
    LogEEMisc = tekkitrestrict.config.getBoolean("LogEEMisc");
    LogEEDestructive = tekkitrestrict.config.getBoolean("LogEEDestructive");
    LogDebug = tekkitrestrict.config.getBoolean("LogDebug");
    BroadcastDupes = tekkitrestrict.config.getStringList("BroadcastDupes");
    for (int i = 0; i < BroadcastDupes.size(); i++) {
      BroadcastDupes.set(i, BroadcastDupes.get(i).toLowerCase());
    }
    BroadcastDupeString = tekkitrestrict.config.getString("BroadcastDupeString");
    hacks = Collections.synchronizedList(tekkitrestrict.config.getStringList("BroadcastHacks"));
    BroadcastHackString = tekkitrestrict.config.getString("BroadcastHackString");
    LogFlyHack = tekkitrestrict.config.getBoolean("LogFlyHack");
    LogForcefieldHack = tekkitrestrict.config.getBoolean("LogForcefieldHack");
    LogSpeedHack = tekkitrestrict.config.getBoolean("LogSpeedHack");
  }
Exemple #26
0
  public static ActFmSyncThread initializeSyncComponents(
      TaskDao taskDao,
      TagDataDao tagDataDao,
      UserActivityDao userActivityDao,
      TaskAttachmentDao taskAttachmentDao,
      TaskListMetadataDao taskListMetadataDao) {
    if (instance == null) {
      synchronized (ActFmSyncThread.class) {
        if (instance == null) {
          List<ClientToServerMessage<?>> syncQueue =
              Collections.synchronizedList(new LinkedList<ClientToServerMessage<?>>());
          ActFmSyncMonitor monitor = ActFmSyncMonitor.getInstance();
          ActFmSyncWaitingPool waitingPool = ActFmSyncWaitingPool.getInstance();

          instance = new ActFmSyncThread(syncQueue, monitor);

          taskDao.addListener(new SyncDatabaseListener<Task>(instance, ModelType.TYPE_TASK));
          tagDataDao.addListener(new SyncDatabaseListener<TagData>(instance, ModelType.TYPE_TAG));
          userActivityDao.addListener(
              new SyncDatabaseListener<UserActivity>(instance, ModelType.TYPE_ACTIVITY));
          taskAttachmentDao.addListener(
              new SyncDatabaseListener<TaskAttachment>(instance, ModelType.TYPE_ATTACHMENT));
          taskListMetadataDao.addListener(
              new TaskListMetadataSyncDatabaseListener(
                  instance, waitingPool, ModelType.TYPE_TASK_LIST_METADATA));

          instance.startSyncThread();
        }
      }
    }
    return instance;
  }
Exemple #27
0
 public PopupAgent(
     ControlPanel cp,
     FactoryFrame ff,
     Integer index,
     Transducer t,
     TChannel channelType) // ArrayList<Robot> inputRobots
     {
   super("popupAgent");
   this.cp = cp;
   factoryFrame = ff;
   myIndex = index;
   glasses = Collections.synchronizedList(new ArrayList<MyGlass>());
   nextFamilyAvailable = true;
   transducer = t;
   myChannel = channelType;
   if (myChannel == TChannel.DRILL) expectationTime = 29;
   else if (myChannel == TChannel.CROSS_SEAMER) expectationTime = 13;
   else if (myChannel == TChannel.GRINDER) expectationTime = 32;
   //		for(Robot r: inputRobots)
   //		{
   //			robots.add(new MyRobot(r));
   //		}
   robots.add(new MyRobot());
   robots.add(new MyRobot());
   t.register(this, TChannel.CONVEYOR);
   t.register(this, TChannel.SENSOR);
   t.register(this, TChannel.POPUP);
   // need to listen to another work station
   t.register(this, myChannel);
 }
Exemple #28
0
 /**
  * Construct a provider holder with a given set of providers. This will maintain the current order
  * as long as it does not violate the rules for {@link OrderedService}s.
  *
  * @param currentProviders the current set of providers to register in this stack
  */
 public ProviderStack(T[] currentProviders) {
   providers = Collections.synchronizedList(new ArrayList<ProviderHolder<T>>());
   ArrayList<T> tList = new ArrayList<T>();
   // first add in the ordered ones
   for (int i = 0; i < currentProviders.length; i++) {
     T t = currentProviders[i];
     if (t instanceof NotProvider) {
       continue; // skip all the NotProviders
     }
     if (t instanceof OrderedService) {
       tList.add(t);
     }
   }
   // sort the ordered ones
   Collections.sort(tList, new OrderedServiceComparator());
   // now add in the rest in the order given
   for (int i = 0; i < currentProviders.length; i++) {
     T t = currentProviders[i];
     if (!(t instanceof OrderedService)) {
       if (t instanceof NotProvider) {
         continue; // skip all the NotProviders
       }
       tList.add(t);
     }
   }
   // now put these into holders
   for (T t : tList) {
     providers.add(new ProviderHolder<T>(t));
   }
   tList.clear();
 }
  class DisplayListener extends SimpleImageLoadingListener {

    final List<String> displayedImages = Collections.synchronizedList(new LinkedList<String>());

    @Override
    public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
      if (loadedImage != null) {
        ImageView imageView = (ImageView) view;
        int h = dp2px.dip2px(98);
        int w = h * loadedImage.getWidth() / loadedImage.getHeight();
        FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(w, h);
        // imageView.setLayoutParams(lp);
        imageView.setScaleType(ScaleType.CENTER_CROP);
        boolean firstDisplay = !displayedImages.contains(imageUri);
        if (firstDisplay) {
          FadeInBitmapDisplayer.animate(imageView, 500);
          displayedImages.add(imageUri);
        }
      } else {
        ImageView imageView = (ImageView) view;
        int h = imageView.getHeight();
        FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(h, h);
        lp.setMargins(dp2px.dip2px(10), dp2px.dip2px(10), 0, dp2px.dip2px(10));
        imageView.setLayoutParams(lp);
        imageView.setImageResource(R.drawable.img_default);
      }
    }
  }
  /** 初始化DownloadManager */
  public synchronized void init(DownloaderManagerConfiguration configuration) {
    FileDownloader.init(configuration.getContext(), configuration.getOkHttpClientCustomMaker());
    FileDownloader.getImpl().bindService();

    ILogger.DEBUG = configuration.isDebug();
    FileDownloadLog.NEED_LOG = ILogger.DEBUG;

    this.mConfiguration = configuration;
    this.mExtFieldMap = configuration.getDbExtField();
    mDbController =
        new FileDownloaderDBController(
            configuration.getContext(),
            configuration.getDbVersion(),
            mExtFieldMap,
            configuration.getDbUpgradeListener());
    mAllTasks = mDbController.getAllTasks();
    mConnectListenerList = new ArrayList<>();
    mListenerManager = new ListenerManager();
    mAutoRetryTimes = configuration.getAutoRetryTimes();
    mHeaders = configuration.getHeaders();

    // 设置下载保存目录
    if (!StringUtils.isEmpty(configuration.getDownloadStorePath())) {
      FileDownloadUtils.setDefaultSaveRootPath(configuration.getDownloadStorePath());
    }

    mWaitQueue = new LinkedList<>();
    mDownloadingList = Collections.synchronizedList(new ArrayList<FileDownloaderModel>());
    mDownloadManager = this;

    ShellUtils.execCommand("chmod 777 " + configuration.getDownloadStorePath(), false);
  }