private void sendScreenshot() {
    Bitmap bitmap = mIitcWebView.getDrawingCache();
    if (bitmap == null) {
      mIitcWebView.buildDrawingCache();
      bitmap = mIitcWebView.getDrawingCache();
      if (bitmap == null) {
        Log.e("could not get bitmap!");
        return;
      }
      bitmap = Bitmap.createBitmap(bitmap);
      if (!mIitcWebView.isDrawingCacheEnabled()) mIitcWebView.destroyDrawingCache();
    } else {
      bitmap = Bitmap.createBitmap(bitmap);
    }

    try {
      final File cache = getExternalCacheDir();
      final File file = File.createTempFile("IITC screenshot", ".png", cache);
      if (!bitmap.compress(CompressFormat.PNG, 100, new FileOutputStream(file))) {
        // quality is ignored by PNG
        throw new IOException("Could not compress bitmap!");
      }
      startActivityForResult(
          ShareActivity.forFile(this, file, "image/png"),
          new ResponseHandler() {
            @Override
            public void onActivityResult(final int resultCode, final Intent data) {
              file.delete();
            }
          });
    } catch (final IOException e) {
      Log.e("Could not generate screenshot", e);
    }
  }
  public String readFromFile() {

    String ret = "";

    try {
      InputStream inputStream = context.openFileInput("locations.json");

      if (inputStream != null) {
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String receiveString = "";
        StringBuilder stringBuilder = new StringBuilder();

        while ((receiveString = bufferedReader.readLine()) != null) {
          stringBuilder.append(receiveString);
        }

        inputStream.close();
        ret = stringBuilder.toString();
      }
    } catch (FileNotFoundException ex) {
      Log.e("login activity", "File not found: " + ex.toString());
    } catch (IOException ex) {
      Log.e("login activity", "Can not read file: " + ex.toString());
    }
    return ret;
  }
 private int createProgram(final String vertexSource, final String fragmentSource) {
   final int vertexShader = this.loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
   if (vertexShader == 0) {
     return 0;
   }
   final int pixelShader = this.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
   if (pixelShader == 0) {
     return 0;
   }
   int program = GLES20.glCreateProgram();
   if (program != 0) {
     GLES20.glAttachShader(program, vertexShader);
     this.checkGlError("glAttachShader");
     GLES20.glAttachShader(program, pixelShader);
     this.checkGlError("glAttachShader");
     GLES20.glLinkProgram(program);
     final int[] linkStatus = {0};
     GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
     if (linkStatus[0] != 1) {
       Log.e("DistortionRenderer", "Could not link program: ");
       Log.e("DistortionRenderer", GLES20.glGetProgramInfoLog(program));
       GLES20.glDeleteProgram(program);
       program = 0;
     }
   }
   return program;
 }
Example #4
0
  private void addSaveRequest(SaveRequest r) {
    synchronized (this) {
      // some time onDestroy() execute before add save request which is
      // through
      // post runnable
      synchronized (mSaveServiceObject) {
        if (mSaverService == null) {
          Log.e(TAG, "[addSaveRequest]mSaverService is null,return.");
          return;
        }

        while (mSaverService.getWaitingCount() >= QUEUE_LIMIT) {
          try {
            Log.i(TAG, "[addSaveRequest],waiting count > QUEUE_LIMIT 100,wait...");
            wait();
          } catch (InterruptedException ex) {
            // ignore.
            Log.e(TAG, "[addSaveRequest]exception:", ex);
          }
        }
        Log.i(TAG, "[addSaveRequest]mSaverService.addSaveRequest...");
        mSaverService.addSaveRequest(r);
      }
    }
  }
Example #5
0
 @Override
 public void saveSync() {
   if (mData == null) {
     Log.w(TAG, "[saveSync]why mData==null???", new Throwable());
     return;
   }
   FileOutputStream out = null;
   try {
     // Write to a temporary file and rename it to the final name.
     // This
     // avoids other apps reading incomplete data.
     out = new FileOutputStream(mTempFilePath);
     out.write(mData);
     out.close();
   } catch (IOException e) {
     Log.e(TAG, "[saveSync]Failed to write image", e);
   } finally {
     if (out != null) {
       try {
         out.close();
       } catch (IOException e) {
         Log.e(TAG, "[saveSync]exception : ", e);
       }
     }
   }
 }
Example #6
0
  public static int loadTiledTexture(int file) {
    GL.glGenTextures(1, singleID, 0);

    GL.glBindTexture(GL.GL_TEXTURE_2D, singleID[0]);

    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);

    InputStream is = Resource.getResInputStream(file);
    Bitmap bitmap = null;
    try {
      bitmap = BitmapFactory.decodeStream(is);
    } catch (Exception e) {
      Log.e(TAG, "Could not read texture file " + file, e);
      return 0;
    } finally {
      try {
        is.close();
      } catch (Exception e) {
        Log.e(TAG, "Error closing stream", e);
      }
    }

    if (bitmap != null) {
      GLUtils.texImage2D(GL.GL_TEXTURE_2D, 0, bitmap, 0);
      bitmap.recycle();
    } else {
      Log.e(TAG, "Could not read bitmap " + file);
      return 0;
    }

    return singleID[0];
  }
Example #7
0
 /**
  * 压缩
  *
  * @param file 要压缩的文件
  * @param outFile 压缩后的输出文件
  * @throws IOException
  */
 public static void zip(File file, File outFile) throws IOException {
   // 提供了一个数据项压缩成一个ZIP归档输出流
   ZipOutputStream out = null;
   try {
     out = new ZipOutputStream(new FileOutputStream(outFile));
     // 如果此文件是一个文件,否则为false。
     if (file.isFile()) {
       zipFileOrDirectory(out, file, "");
     } else {
       // 返回一个文件或空阵列。
       File[] entries = file.listFiles();
       if (entries != null) {
         for (int i = 0; i < entries.length; i++) {
           // 递归压缩,更新curPaths
           zipFileOrDirectory(out, entries[i], "");
         }
       }
     }
   } catch (IOException ex) {
     Log.e(TAG, "压缩文件失败", ex);
   } finally {
     // 关闭输出流
     if (out != null) {
       try {
         out.close();
       } catch (IOException ex) {
         Log.e(TAG, "关闭流失败", ex);
       }
     }
   }
 }
  private void loadInput() {
    Intent intent = getIntent();
    Bundle extras = intent.getExtras();

    if (extras != null) {
      aspectX = extras.getInt(Crop.Extra.ASPECT_X);
      aspectY = extras.getInt(Crop.Extra.ASPECT_Y);
      maxX = extras.getInt(Crop.Extra.MAX_X);
      maxY = extras.getInt(Crop.Extra.MAX_Y);
      saveUri = extras.getParcelable(MediaStore.EXTRA_OUTPUT);
    }

    sourceUri = intent.getData();
    if (sourceUri != null) {
      exifRotation =
          CropUtil.getExifRotation(CropUtil.getFromMediaUri(this, getContentResolver(), sourceUri));

      InputStream is = null;
      try {
        sampleSize = calculateBitmapSampleSize(sourceUri);
        is = getContentResolver().openInputStream(sourceUri);
        BitmapFactory.Options option = new BitmapFactory.Options();
        option.inSampleSize = sampleSize;
        rotateBitmap = new RotateBitmap(BitmapFactory.decodeStream(is, null, option), exifRotation);
      } catch (IOException e) {
        Log.e("Error reading image: " + e.getMessage(), e);
        setResultException(e);
      } catch (OutOfMemoryError e) {
        Log.e("OOM reading image: " + e.getMessage(), e);
        setResultException(e);
      } finally {
        CropUtil.closeSilently(is);
      }
    }
  }
Example #9
0
 // Return null when we cannot instantiate a BlobCache, e.g.:
 // there is no SD card found.
 // This can only be called from data thread.
 public static BlobCache getCache(
     Context context, String filename, int maxEntries, int maxBytes, int version) {
   synchronized (sCacheMap) {
     if (!sOldCheckDone) {
       removeOldFilesIfNecessary(context);
       sOldCheckDone = true;
     }
     BlobCache cache = sCacheMap.get(filename);
     if (cache == null) {
       /// M: [BEHAVIOR.MODIFY] @{
       /*File cacheDir = context.getExternalCacheDir();*/
       File cacheDir = FeatureHelper.getExternalCacheDir(context);
       if (cacheDir == null) {
         Log.e(TAG, "<getCache> failed to get cache dir");
         return null;
       }
       /// @}
       String path = cacheDir.getAbsolutePath() + "/" + filename;
       try {
         /// M: [DEBUG.ADD] @{
         Log.i(TAG, "<getCache> new BlobCache, path = " + path);
         /// @}
         cache = new BlobCache(path, maxEntries, maxBytes, false, version);
         sCacheMap.put(filename, cache);
       } catch (IOException e) {
         Log.e(TAG, "Cannot instantiate cache!", e);
       }
     }
     return cache;
   }
 }
Example #10
0
    public void saveImageToDatabase(RequestOperator r) {
      Log.i(TAG, "[saveImageToDatabase]...");
      // Insert into MediaStore.
      ContentValues values = new ContentValues(14);
      values.put(ImageColumns.TITLE, r.mTitle);
      values.put(ImageColumns.DISPLAY_NAME, r.mFileName);
      values.put(ImageColumns.DATE_TAKEN, r.mDateTaken);
      values.put(ImageColumns.MIME_TYPE, r.mMimeType);
      values.put(ImageColumns.DATA, r.mFilePath);
      values.put(ImageColumns.SIZE, r.mDataSize);
      if (r.mLocation != null) {
        values.put(ImageColumns.LATITUDE, r.mLocation.getLatitude());
        values.put(ImageColumns.LONGITUDE, r.mLocation.getLongitude());
      }
      values.put(ImageColumns.ORIENTATION, r.mOrientation);
      // M: ConShots
      values.put(Images.Media.GROUP_ID, r.mGroupId);
      values.put(Images.Media.GROUP_INDEX, r.mGroupIndex);
      values.put(Images.Media.FOCUS_VALUE_HIGH, r.mFocusValueHigh);
      values.put(Images.Media.FOCUS_VALUE_LOW, r.mFocusValueLow);
      // Add for Refocus image database
      values.put(Images.Media.CAMERA_REFOCUS, r.mTag);
      values.put(ImageColumns.WIDTH, r.mWidth);
      values.put(ImageColumns.HEIGHT, r.mHeight);
      try {
        r.mUri = mContentResolver.insert(Images.Media.EXTERNAL_CONTENT_URI, values);
        if (r.mUri != null) {
          mContext.addSecureAlbumItemIfNeeded(false, r.mUri);
          if (mContext.isNonePickIntent()) {
            // picture taken and saved by camera which is launched
            // by 3rd apps will
            // be inserted into DB. But do not broadcast
            // "New_Picture" intent,
            // otherwise, it will not pass camera CTS test.
            Util.broadcastNewPicture(mContext, r.mUri);
          }
          Log.i(TAG, "[saveImageToDatabase]mUri = " + r.mUri);
        }

      } catch (IllegalArgumentException e) { // Here we keep google
        // default, don't
        // follow check style
        // This can happen when the external volume is already mounted,
        // but
        // MediaScanner has not notify MediaProvider to add that volume.
        // The picture is still safe and MediaScanner will find it and
        // insert it into MediaProvider. The only problem is that the
        // user
        // cannot click the thumbnail to review the picture.
        Log.e(TAG, "[saveImageToDatabase]Failed to write MediaStore,IllegalArgumentException:", e);
      } catch (UnsupportedOperationException e) {
        Log.e(
            TAG,
            "[saveImageToDatabase]Failed to write MediaStore," + "UnsupportedOperationException:",
            e);
      }
    }
Example #11
0
  public Map<Match, Map<String, Map<Object, Double>>> predictMatches(Match[] matches)
      throws Exception {
    Map<Match, Map<String, Map<Object, Double>>> retval =
        new TreeMap<Match, Map<String, Map<Object, Double>>>();
    LinkedList<Match> nMatches = new LinkedList<Match>();
    for (Match match : matches) {
      if (teams.get(match.country, match.home) != null
          && teams.get(match.country, match.away) != null) nMatches.add(match);
    }
    matches = new Match[nMatches.size()];
    int i = 0;
    for (Match match : nMatches) {
      matches[i] = match;
      i++;
    }
    for (Match match : matches) {
      try {
        Map<String, Map<Object, Double>> toPut = new TreeMap<String, Map<Object, Double>>();
        // Match to predict
        double[] toPredict = this.getKamp(match.home, match.away, match.country);

        // Dataset to use
        List<DataEntry> trainingset = this.getTrainingSet(match.country, match.division);
        if (Setup.NORMALIZE_DATA) {
          Normalizer norm = this.normalizers.get(this.getDataKey(match.country, match.division));
          norm.apply(toPredict);
        }
        // The classification
        // Find number of neighbours
        int neighbours = 10; // Default
        try {
          neighbours = getBestKForNearestNeighbour(match.country, match.division);
        } catch (SQLException e1) {
          Log.e(e1);
        }
        // Find kernel
        Estimator est = null;
        try {
          est = getBestKernelForNaiveBayes(match.country, match.division);
        } catch (SQLException e1) {
          Log.e(e1);
        }

        toPut.put("lda", this.predictMatchLDA(trainingset, toPredict));
        toPut.put("nb", this.predictMatchNB(trainingset, toPredict, est));
        toPut.put("nn", this.predictMatchNN(trainingset, toPredict, neighbours));
        retval.put(match, toPut);
      } catch (Exception e) {
        Log.e(e);
      }
    }
    return retval;
  }
Example #12
0
  private MemberModel() {
    // init memberMap
    memberMap = new HashMap<>();
    // init entitledMap (1 to many relation between memberID and BookNumber)
    entitledMap = new HashMap<>();
    boolean readFlag = false;
    ObjectInputStream oin = null;
    Member tm;
    String[] sa = new String[3];
    try {
      oin = new ObjectInputStream(new FileInputStream("members1.dat"));
      readFlag = true;
    } catch (Exception e) {
      e.printStackTrace();
    }
    // read in from file
    while (readFlag) {
      try {
        // Read a member data from inputstream
        // Structure for reading
        // __________________________________________________________
        // |String|String|String|Boolean or Double|ArrayList<String>|
        // ----------------------------------------------------------

        sa[ID_INDEX] = oin.readUTF();
        sa[TITLE_INDEX] = oin.readUTF();
        sa[PHONENO_INDEX] = oin.readUTF();
        if (sa[ID_INDEX].indexOf("STA") != -1) {
          tm = new Staff(sa[ID_INDEX], sa[TITLE_INDEX], sa[PHONENO_INDEX]);
          ((Staff) tm).setBookOverdue(oin.readBoolean());
        } else {
          tm = new Student(sa[ID_INDEX], sa[TITLE_INDEX], sa[PHONENO_INDEX]);
          ((Student) tm).setFinesOwing(oin.readDouble());
        }
        // Raw data map without relationship to book
        memberMap.put(tm.getMemberID(), tm);
        // Map for storing relation
        entitledMap.put(tm.getMemberID(), (ArrayList<String>) oin.readObject());
      } catch (EOFException e) {
        Log.e(e.getMessage());
        readFlag = false;
      } catch (Exception e) {
        Log.e(e.getMessage());
      }
    }
    try {
      oin.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Example #13
0
 /**
  * Generates a PublicKey instance from a string containing the
  * Base64-encoded public key.
  *
  * @param encodedPublicKey Base64-encoded public key
  * @throws IllegalArgumentException if encodedPublicKey is invalid
  */
 public static PublicKey generatePublicKey(String encodedPublicKey) {
     try {
         byte[] decodedKey = Base64.decode(encodedPublicKey);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM);
         return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));
     } catch (NoSuchAlgorithmException e) {
         throw new RuntimeException(e);
     } catch (InvalidKeySpecException e) {
         Log.e(TAG, "Invalid key specification.");
         throw new IllegalArgumentException(e);
     } catch (Base64DecoderException e) {
         Log.e(TAG, "Base64 decoding failed.");
         throw new IllegalArgumentException(e);
     }
 }
 public int[] readProgress() {
   int progress[] = new int[2];
   try {
     DataInputStream in =
         new DataInputStream(new BufferedInputStream(new FileInputStream(resume_file)));
     progress[0] = in.readInt();
     progress[1] = in.readInt();
     in.close();
   } catch (FileNotFoundException e) {
     Log.e(TAG, "readProgress file not found.");
   } catch (IOException e) {
     Log.e(TAG, e.getMessage());
   }
   return progress;
 }
Example #15
0
    @Override
    public void saveRequest() {
      // need video compute duration
      try {
        File temp = new File(mTempFilePath);
        File file = new File(mFilePath);
        temp.renameTo(file);
        mDataSize = file.length();

        ContentValues values = new ContentValues(13);
        values.put(Video.Media.TITLE, mTitle);
        values.put(Video.Media.DISPLAY_NAME, mFileName);
        values.put(Video.Media.DATE_TAKEN, mDateTaken);
        values.put(Video.Media.MIME_TYPE, mMimeType);
        values.put(Video.Media.DATA, mFilePath);
        values.put(Video.Media.SIZE, mDataSize);
        values.put(Video.Media.ORIENTATION, mOrientation);
        if (mLocation != null) {
          values.put(Video.Media.LATITUDE, mLocation.getLatitude());
          values.put(Video.Media.LONGITUDE, mLocation.getLongitude());
        }
        values.put(Video.Media.RESOLUTION, mResolution);
        values.put(Video.Media.DURATION, mDuration);
        values.put(Video.Media.SLOW_MOTION_SPEED, "(0,0)x" + mSlowMotionSpeed);
        mUri = mContentResolver.insert(Video.Media.EXTERNAL_CONTENT_URI, values);
        if (mUri != null) {
          mContext.addSecureAlbumItemIfNeeded(true, mUri);
          mContext.sendBroadcast(new Intent(android.hardware.Camera.ACTION_NEW_VIDEO, mUri));
        }
      } catch (IllegalArgumentException th) { // Here we keep google
        // default, don't
        // follow check style
        // This can happen when the external volume is already mounted,
        // but
        // MediaScanner has not notify MediaProvider to add that volume.
        // The picture is still safe and MediaScanner will find it and
        // insert it into MediaProvider. The only problem is that the
        // user
        // cannot click the thumbnail to review the picture.
        Log.e(TAG, "[saveRequest]VideoOperator,Failed to write MediaStore,exception:", th);
      } catch (UnsupportedOperationException e) {
        Log.e(
            TAG,
            "[saveImageToDatabase]Failed to write MediaStore," + "UnsupportedOperationException:",
            e);
      }
      Log.i(TAG, "[saveRequest]VideoOperator,end of wirte to DB,mUri = " + mUri);
    }
 @Override
 public void onTrigger(View v, int target) {
   Log.d(this, "onTrigger() view=" + v + " target=" + target);
   final int resId = getResourceIdForTarget(target);
   switch (resId) {
     case R.drawable.ic_lockscreen_answer:
       mAnswerListener.onAnswer(VideoProfile.STATE_AUDIO_ONLY, getContext());
       mTargetTriggered = true;
       break;
     case R.drawable.ic_lockscreen_decline:
       mAnswerListener.onDecline(getContext());
       mTargetTriggered = true;
       break;
     case R.drawable.ic_lockscreen_text:
       mAnswerListener.onText();
       mTargetTriggered = true;
       break;
     case R.drawable.ic_videocam:
     case R.drawable.ic_lockscreen_answer_video:
       mAnswerListener.onAnswer(mVideoState, getContext());
       mTargetTriggered = true;
       break;
     case R.drawable.ic_lockscreen_decline_video:
       mAnswerListener.onDeclineUpgradeRequest(getContext());
       mTargetTriggered = true;
       break;
     default:
       // Code should never reach here.
       Log.e(this, "Trigger detected on unhandled resource. Skipping.");
   }
 }
Example #17
0
 public String readTwitterFeed() {
   StringBuilder builder = new StringBuilder();
   HttpClient client = new DefaultHttpClient();
   HttpGet httpGet = new HttpGet("http:'//twitter.com/users/show/vogella.json");
   try {
     HttpResponse response = client.execute(httpGet);
     StatusLine statusLine = response.getStatusLine();
     int statusCode = statusLine.getStatusCode();
     if (statusCode == 200) {
       HttpEntity entity = response.getEntity();
       InputStream content = entity.getContent();
       BufferedReader reader = new BufferedReader(new InputStreamReader(content));
       String line;
       while ((line = reader.readline()) != null) {
         builder.append(line);
       }
     } else {
       Log.e(MainActivity2.class.toString(), "Failed to download file");
     }
   } catch (ClientProtocolExpcetion e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   }
   return builder.toString();
 }
  public void onReceive(Context context, Intent intent) {
    Log.e("auth failure receiver received");

    if (sIsHandling || !PrefUtil.getInstance(context).isLogined()) {
      return;
    }
    sIsHandling = true;

    PrefUtil.getInstance(context).logoutAccount();
    ManageAccountsActivity.deleteDatasInDB(context);
    Database database = new Database(context);
    database.close();
    // 变换Database,Connect2的标志位(用户判断是否切换了用户)
    Database.sFlagIndex++;
    Connect2.sFlagIndex++;

    // auth failure, don't need to logout.
    //        WowTalkWebServerIF mWeb = WowTalkWebServerIF.getInstance(context);
    //        mWeb.fLogout();
    WowTalkVoipIF.getInstance(context).fStopWowTalkService();
    Intent loginIntent = new Intent(context, LoginActivity.class);
    // android.util.AndroidRuntimeException: Calling startActivity() from outside of an Activity
    // context requires the FLAG_ACTIVITY_NEW_TASK flag. Is this really what you want?
    loginIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    loginIntent.putExtra(
        LoginActivity.EXTRA_PROMPT, context.getString(R.string.account_web_api_auth_failure));
    context.startActivity(loginIntent);

    if (null != StartActivity.instance()) {
      StartActivity.instance().finish();
    }
    sIsHandling = false;
  }
Example #19
0
  @Override
  public void onBackPressed() {
    boolean handled = false;
    try {
      FragmentManager fm = getSupportFragmentManager();
      Fragment frag = fm.findFragmentById(R.id.fragment_content);
      if (!(frag instanceof FragUtils.BackPressedHandler)) {
        Log.d(TAG, "frag type was: " + (frag == null ? "null" : frag.getClass().getSimpleName()));
        return;
      }

      if (!frag.isVisible()) {
        Log.d(TAG, "frag was not visible!");
        return;
      }

      handled = ((FragUtils.BackPressedHandler) frag).handleBackPressed();
      //      Log.w(TAG, "handleBackPressed returned: " + handled);
    } catch (Exception e) {
      Log.e(TAG, "Could not check onBackPressed", e);
    } finally {
      if (!handled) {
        super.onBackPressed();
      }
    }
  }
  public void recalculateCodebooks() throws IOException {
    String dir =
        "/Users/thomaskaiser/Documents/MCM/MC480_Project_I/SVN/trunk/Implementation/ProjectFiles/mobile phone folder structure";
    HashMap<String, String> sampleDirectories = readSampleDirectories(dir);
    Set<String> keySet = sampleDirectories.keySet();

    for (String speakerId : keySet) {
      Log.d("Recalculating codebook for %s", speakerId);
      FeatureVector pl = null;
      try {
        pl = readFeatureVectorFile(sampleDirectories.get(speakerId));
      } catch (Exception e) {
        Log.e("Error reading feature vector", e);
      }

      KMeans kmeans = new KMeans(Constants.CLUSTER_COUNT, pl, Constants.CLUSTER_MAX_ITERATIONS);
      Log.d("Prepared k means clustering");
      long start = System.currentTimeMillis();
      kmeans.run();
      Log.d("Clustering finished, total time = " + (System.currentTimeMillis() - start) + "ms");

      Codebook cb = makeCodebook(kmeans);

      writeCodebook(sampleDirectories.get(speakerId), cb);
    }
  }
Example #21
0
  public void readLangFile(String language) {
    String filename = getLangFolder() + File.separator + language + ".yml";

    try {
      Configuration config = new Configuration(new File(filename));

      config.load();

      List<String> keys = config.getKeys();

      if (!langDb.containsKey(language)) {
        langDb.put(language, new HashMap<String, String>());
      }

      Map<String, String> langMap = langDb.get(language);

      for (Iterator<String> it = keys.iterator(); it.hasNext(); ) {
        String key = it.next();

        Log.v("Adding " + language + "." + key + ";");
        langMap.put(key, config.getString(key));
      }

      Log.d("Done parsing localization file '" + filename + "' for language '" + language + "'");
    } catch (Exception ex) {
      Log.e("Could not load localizaion file '" + filename + "'");
    }
  }
Example #22
0
  private void deleteLocation(LocationInfo info) {
    if (NavigineApp.Navigation == null) return;

    if (info != null) {
      try {
        (new File(info.archiveFile)).delete();
        info.localVersion = -1;
        info.localModified = false;

        String locationDir = LocationLoader.getLocationDir(mContext, info.title);
        File dir = new File(locationDir);
        File[] files = dir.listFiles();
        for (int i = 0; i < files.length; ++i) files[i].delete();
        dir.delete();

        String mapFile = NavigineApp.Settings.getString("map_file", "");
        if (mapFile.equals(info.archiveFile)) {
          NavigineApp.Navigation.loadArchive(null);
          SharedPreferences.Editor editor = NavigineApp.Settings.edit();
          editor.putString("map_file", "");
          editor.commit();
        }

        mAdapter.updateList();
      } catch (Throwable e) {
        Log.e(TAG, Log.getStackTraceString(e));
      }
    }
  }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    addPreferencesFromResource(R.xml.notification_pref);

    mNotification = (CheckBoxPreference) this.findPreference("notification_bar");
    mNotifyIcon = (ListPreference) this.findPreference("notification_bar_icon");
    mLed = (CheckBoxPreference) this.findPreference("led_enabled");
    mLedPattern = (ListPreference) this.findPreference("led_pattern");
    mLedColor = (ListPreference) this.findPreference("led_color");
    mRinger = (CheckBoxPreference) this.findPreference("ringer_enabled");
    mRingtone = (RingtonePref) this.findPreference("ringtone");
    mRingVolume = (VolumePref) this.findPreference("ring_volume");
    mVibrate = (CheckBoxPreference) this.findPreference("vibrate_enabled");
    mVibratePattern = (ListPreference) this.findPreference("vibrate_pattern");

    if (mNotification == null
        || mLed == null
        || mRinger == null
        || mVibrate == null
        || mRingtone == null
        || mRingVolume == null
        || mNotifyIcon == null
        || mLedPattern == null
        || mLedColor == null
        || mVibratePattern == null) {
      if (Log.LOGV)
        Log.e(
            TAG
                + "One of our preferences has a null pointer and none of  them should be null\n bailing...");
      finish();
      return;
    }
  }
Example #24
0
  // Removes the old files if the data is wiped.
  private static void removeOldFilesIfNecessary(Context context) {
    SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(context);
    int n = 0;
    try {
      n = pref.getInt(KEY_CACHE_UP_TO_DATE, 0);
    } catch (Throwable t) {
      // ignore.
    }
    if (n != 0) return;
    pref.edit().putInt(KEY_CACHE_UP_TO_DATE, 1).commit();

    /// M: [BEHAVIOR.MODIFY] @{
    /*File cacheDir = context.getExternalCacheDir();*/
    File cacheDir = FeatureHelper.getExternalCacheDir(context);
    if (cacheDir == null) {
      Log.e(TAG, "<removeOldFilesIfNecessary> failed to get cache dir");
      return;
    }
    /// @}

    String prefix = cacheDir.getAbsolutePath() + "/";

    BlobCache.deleteFiles(prefix + "imgcache");
    BlobCache.deleteFiles(prefix + "rev_geocoding");
    BlobCache.deleteFiles(prefix + "bookmark");
  }
  /** Loads the default values if we have them if not then blank it all out */
  private void loadDefaultValues() {
    try {
      mNotification.setChecked(pNotify.notify_active);
      mLed.setChecked(pNotify.led_active);
      mRinger.setChecked(pNotify.ringer_active);
      mVibrate.setChecked(pNotify.vibrate_active);
      mRingtone.setRingtone(Uri.parse(pNotify.ringtone));
      mRingVolume.setVolume(pNotify.ringer_vol);

      if (mNotifyIcon.findIndexOfValue(pNotify.notify_icon) > -1)
        mNotifyIcon.setValueIndex(mNotifyIcon.findIndexOfValue(pNotify.notify_icon));

      if (mLedPattern.findIndexOfValue(pNotify.led_pat) > -1)
        mLedPattern.setValueIndex(mLedPattern.findIndexOfValue(pNotify.led_pat));

      if (mLedColor.findIndexOfValue(pNotify.led_color) > -1)
        mLedColor.setValueIndex(mLedColor.findIndexOfValue(pNotify.led_color));

      if (mVibratePattern.findIndexOfValue(pNotify.vibrate_pat) > -1)
        mVibratePattern.setValueIndex(mVibratePattern.findIndexOfValue(pNotify.vibrate_pat));

    } catch (NullPointerException e) {
      if (Log.LOGV) Log.e(TAG + "Null pointer exception " + e.getLocalizedMessage().toString());
    } catch (RuntimeException e) {

    }
  }
Example #26
0
  @SuppressWarnings("unchecked")
  public static <T extends Model> List<T> processCursor(
      Class<? extends Model> type, Cursor cursor) {
    final List<T> entities = new ArrayList<T>();

    try {
      Constructor<?> entityConstructor = type.getConstructor();

      if (cursor.moveToFirst()) {
        do {
          Model entity = Cache.getEntity(type, cursor.getLong(cursor.getColumnIndex("Id")));
          if (entity == null) {
            entity = (T) entityConstructor.newInstance();
          }

          entity.loadFromCursor(cursor);
          entities.add((T) entity);
        } while (cursor.moveToNext());
      }

    } catch (Exception e) {
      Log.e("Failed to process cursor.", e);
    }

    return entities;
  }
  private void saveOutput(Bitmap croppedImage) {
    if (saveUri != null) {
      OutputStream outputStream = null;
      try {
        outputStream = getContentResolver().openOutputStream(saveUri);
        if (outputStream != null) {
          croppedImage.compress(Bitmap.CompressFormat.JPEG, 90, outputStream);
        }
      } catch (IOException e) {
        setResultException(e);
        Log.e("Cannot open file: " + saveUri, e);
      } finally {
        CropUtil.closeSilently(outputStream);
      }

      CropUtil.copyExifRotation(
          CropUtil.getFromMediaUri(this, getContentResolver(), sourceUri),
          CropUtil.getFromMediaUri(this, getContentResolver(), saveUri));

      setResultUri(saveUri);
    }

    final Bitmap b = croppedImage;
    handler.post(
        new Runnable() {
          public void run() {
            imageView.clear();
            b.recycle();
          }
        });

    finish();
  }
 private void a(CircuitBreaker circuitBreaker, byte[] bArr, String str) {
   if (!circuitBreaker.b()) {
     try {
       OutputStream bufferedOutputStream = new BufferedOutputStream(a(str));
       try {
         a(bufferedOutputStream, bArr);
         try {
           bufferedOutputStream.flush();
           bufferedOutputStream.close();
         } catch (IOException e) {
         }
       } catch (IOException e2) {
         try {
           Log.w(a, "Caught IOException while writing asset to disk: %s", new Object[] {str});
           circuitBreaker.a();
           try {
             bufferedOutputStream.flush();
             bufferedOutputStream.close();
           } catch (IOException e3) {
           }
         } catch (Throwable th) {
           try {
             bufferedOutputStream.flush();
             bufferedOutputStream.close();
           } catch (IOException e4) {
           }
         }
       }
     } catch (IOException e5) {
       Log.e(a, "Could not write an asset to disk: %s", new Object[] {str});
       circuitBreaker.a();
     }
   }
 }
Example #29
0
  /**
   * A convenience method to set an alarm in the Alarms content provider.
   *
   * @return Time when the alarm will fire. Or < 1 if update failed.
   */
  public static long setAlarm(Context context, Alarm alarm) {
    ContentValues values = createContentValues(context, alarm);
    ContentResolver resolver = context.getContentResolver();
    long rowsUpdated =
        resolver.update(
            ContentUris.withAppendedId(Alarm.Columns.CONTENT_URI, alarm.id), values, null, null);
    if (rowsUpdated < 1) {
      Log.e("Error updating alarm " + alarm);
      return rowsUpdated;
    }

    long timeInMillis = calculateAlarm(alarm);

    if (alarm.enabled) {
      // Disable the snooze if we just changed the snoozed alarm. This
      // only does work if the snoozed alarm is the same as the given
      // alarm.
      // TODO: disableSnoozeAlert should have a better name.
      disableSnoozeAlert(context, alarm.id);

      // Disable the snooze if this alarm fires before the snoozed alarm.
      // This works on every alarm since the user most likely intends to
      // have the modified alarm fire next.
      clearSnoozeIfNeeded(context, timeInMillis);
    }

    setNextAlert(context);

    return timeInMillis;
  }
    JsonElement genJsonElement(TypeMirror t, Element el, Kind kind) {
      if (kind == null) {
        Log.e("invalid state. this is APT bugs.");
        encountError = true;
        return defaultAction(t, el);
      }

      JsonElement jsonElement = new JsonElement();
      jsonElement.setKey(getElementKeyString(el));

      JsonKey key = el.getAnnotation(JsonKey.class);

      String setter = getElementSetter(el);
      if (key.in() && setter == null) {
        Log.e("can't find setter method", el);
        encountError = true;
        return defaultAction(t, el);
      }

      String getter = getElementGetter(el);
      if (key.out() && getter == null) {
        Log.e("can't find getter method", el);
        encountError = true;
        return defaultAction(t, el);
      }

      String converterClassName = getConverterClassName(el);
      if (converterClassName != null) {
        TypeElement element = processingEnv.getElementUtils().getTypeElement(converterClassName);
        Log.d(element != null ? element.asType().toString() : null);
        if (element == null
            || !isMethodExists(element, "getInstance", Modifier.PUBLIC, Modifier.STATIC)) {
          Log.e("converter needs [public static getInstance()].", element);
        }
        kind = Kind.CONVERTER;
      }

      jsonElement.setIn(key.in());
      jsonElement.setSetter(setter);
      jsonElement.setOut(key.out());
      jsonElement.setGetter(getter);
      jsonElement.setModelName(t.toString());
      jsonElement.setKind(kind);
      jsonElement.setConverter(converterClassName);

      return jsonElement;
    }