public List<HistoryItem> loadAll() {
    if (!ctx.getFileStreamPath(HISTORY_FILENAME).exists()) {
      return null;
    }
    ObjectInputStream in = null;
    try {

      in = new ObjectInputStream(ctx.openFileInput(HISTORY_FILENAME));

      @SuppressWarnings("unchecked") // readObject() return Object.
      List<HistoryItem> res = (List<HistoryItem>) in.readObject();
      return res;
    } catch (Exception e) {
      Log.e(TAG, "Unable to deserialize history", e);
      // delete it as it's likely corrupted
      ctx.getFileStreamPath(HISTORY_FILENAME).delete();
      return null;
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          Log.e(TAG, "", e);
        }
      }
    }
  }
示例#2
0
  /** 根据文件的绝对路径判断文件是否存在 */
  public static boolean isExistDataCache(Context cxt, String file) {
    boolean exist = false;
    File data = cxt.getFileStreamPath(file);
    if (data.exists()) exist = true;

    return exist;
  }
  private static boolean writeKeyToFile(Context context, String basename, SecretKey key) {
    File file = context.getFileStreamPath(basename);
    byte[] keyBytes = key.getEncoded();
    FileOutputStream output = null;
    if (MAC_KEY_BYTE_COUNT != keyBytes.length) {
      Log.e(
          TAG,
          "writeKeyToFile got key encoded bytes length "
              + keyBytes.length
              + "; expected "
              + MAC_KEY_BYTE_COUNT);
      return false;
    }

    try {
      output = new FileOutputStream(file);
      output.write(keyBytes);
      return true;
    } catch (Exception e) {
      Log.e(TAG, "Could not write key to '" + file + "': " + e);
      return false;
    } finally {
      try {
        if (output != null) {
          output.close();
        }
      } catch (IOException e) {
        Log.e(TAG, "Could not close key output stream '" + file + "': " + e);
      }
    }
  }
  private static SecretKey readKeyFromFile(Context context, String basename, String algorithmName) {
    FileInputStream input = null;
    File file = context.getFileStreamPath(basename);
    try {
      if (file.length() != MAC_KEY_BYTE_COUNT) {
        Log.w(TAG, "Could not read key from '" + file + "': invalid file contents");
        return null;
      }

      byte[] keyBytes = new byte[MAC_KEY_BYTE_COUNT];
      input = new FileInputStream(file);
      if (MAC_KEY_BYTE_COUNT != input.read(keyBytes)) {
        return null;
      }

      try {
        return new SecretKeySpec(keyBytes, algorithmName);
      } catch (IllegalArgumentException e) {
        return null;
      }
    } catch (Exception e) {
      Log.w(TAG, "Could not read key from '" + file + "': " + e);
      return null;
    } finally {
      try {
        if (input != null) {
          input.close();
        }
      } catch (IOException e) {
        Log.e(TAG, "Could not close key input stream '" + file + "': " + e);
      }
    }
  }
示例#5
0
  /**
   * Attempts to unpack a grammar resource into cache. The unpacked copy will be deleted when the
   * application exits normally.
   *
   * @param resId The resource ID of the raw grammar resource.
   * @return the file representing by the unpacked grammar
   */
  private File unpackGrammar(int resId) {
    Context context = mContext.get();

    String extension = EXTENSION_G2G;

    Resources res = context.getResources();
    String name = res.getResourceEntryName(resId);
    File grammar = context.getFileStreamPath(name + "." + extension);
    grammar.deleteOnExit();

    try {
      grammar.getParentFile().mkdirs();

      InputStream in = res.openRawResource(resId);
      FileOutputStream out = new FileOutputStream(grammar);

      byte[] buffer = new byte[1024];
      int count = 0;

      while ((count = in.read(buffer)) > 0) {
        out.write(buffer, 0, count);
      }

      Log.i(TAG, "Unpacked base grammar to " + grammar.getPath());

      return grammar;
    } catch (IOException e) {
      e.printStackTrace();

      Log.e(TAG, e.toString());

      return null;
    }
  }
示例#6
0
 /**
  * 读取对象
  *
  * @param file
  * @return
  */
 public Serializable readObject(Context ctx, String file) {
   if (!isExistDataCache(ctx, file)) return null;
   FileInputStream fis = null;
   ObjectInputStream ois = null;
   try {
     fis = ctx.openFileInput(file);
     ois = new ObjectInputStream(fis);
     return (Serializable) ois.readObject();
   } catch (FileNotFoundException e) {
   } catch (Exception e) {
     e.printStackTrace();
     // 反序列化失败 - 删除缓存文件
     if (e instanceof InvalidClassException) {
       File data = ctx.getFileStreamPath(file);
       data.delete();
     }
   } finally {
     try {
       ois.close();
     } catch (Exception e) {
     }
     try {
       fis.close();
     } catch (Exception e) {
     }
   }
   return null;
 }
示例#7
0
 // if null so erreur
 public ArrayList<ArticleModel> getListModel(ArrayList<Article> listes, Context context) {
   ArrayList<ArticleModel> listeModel = new ArrayList<>();
   try {
     for (int i = 0; i < listes.size(); i++) {
       File file = context.getFileStreamPath(listes.get(i).getIdArticle() + ".png");
       if (file.exists()) {
         Bitmap bitmap = null;
         BitmapFactory.Options options = new BitmapFactory.Options();
         options.inPreferredConfig = Bitmap.Config.ARGB_8888;
         try {
           bitmap = BitmapFactory.decodeStream(new FileInputStream(file), null, options);
           listeModel.add(
               new ArticleModel(
                   bitmap, listes.get(i).getTitleArticle(), listes.get(i).getContentArticle()));
         } catch (FileNotFoundException e) {
           e.printStackTrace();
         }
       }
     }
     return listeModel;
   } catch (Exception e) {
     e.printStackTrace();
   }
   return null;
 }
示例#8
0
    private GeotriggerConfig readFromInternalStorage() {

      Log.v(Config.TAG, "read from internal storage");
      GeotriggerConfig config = null;
      try {
        File file = mContext.getFileStreamPath(CONFIG_FILE);
        if (file.exists() == true) {
          Log.v(Config.TAG, "readFileFromInternalStorage File found...");

          FileInputStream fis = mContext.openFileInput(file.getName());
          StringBuilder buffer = new StringBuilder();
          int ch;
          while ((ch = fis.read()) != -1) {
            buffer.append((char) ch);
          }

          Log.v(Config.TAG, "readFileFromInternalStorage complete.. " + buffer.toString());
          fis.close();

          config = new GeotriggerConfig(buffer.toString());
        }
      } catch (Exception e) {
        Log.v(Config.TAG, "Error: " + e.getMessage());
      }
      return config;
    }
示例#9
0
  private void openDataBase() throws SQLException {

    // Open the database
    mDataBase =
        SQLiteDatabase.openDatabase(
            context.getFileStreamPath(DB_NAME).toString(), null, SQLiteDatabase.OPEN_READWRITE);
  }
示例#10
0
 public static String getString(Context context, String chave) {
   chave += ".txt";
   File f = context.getFileStreamPath(chave);
   String s = IOUtils.readString(f);
   Log.d(TAG, "PrefsFile.getString file: " + f + " >  " + s);
   return s;
 }
示例#11
0
  @Override
  public void onReceive(Context context, Intent intent) {
    SharedPreferences sharedPrefs = context.getSharedPreferences(PREFS_NAME, 0);
    mSmsDisabled = sharedPrefs.getBoolean(PREFS_IS_SMS_BLOCKED, false);

    if (mSmsDisabled) {
      // Prevent other apps from receiving the SMS
      abortBroadcast();

      List<SmsDataCache> currBlockedMsgs = new ArrayList<SmsDataCache>();

      // Check if file exists with our cached messages
      if (context.getFileStreamPath(SMS_FILENAME).exists()) {
        // Build array of currently blocked messages from app's private file
        try {
          FileInputStream fis = context.openFileInput(SMS_FILENAME);
          ObjectInputStream ois = new ObjectInputStream(fis);

          try {
            // Read messages and updated currBlockedMsgs array.
            ArrayList<SmsDataCache> cachedMsgs = (ArrayList<SmsDataCache>) ois.readObject();
            for (Iterator<SmsDataCache> iter = cachedMsgs.iterator(); iter.hasNext(); ) {
              SmsDataCache cachedMsg = iter.next();
              currBlockedMsgs.add(cachedMsg);
            }
          } catch (Exception e) {
            e.printStackTrace();
          }

          ois.close();
          fis.close();
        } catch (FileNotFoundException e) {
          e.printStackTrace();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      // Update private file with the message that was just received
      try {
        // Update array of blocked messages with the last received message
        SmsDataCache receivedMsg = new SmsDataCache(intent);
        currBlockedMsgs.add(receivedMsg);

        FileOutputStream fos = context.openFileOutput(SMS_FILENAME, Context.MODE_PRIVATE);

        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(currBlockedMsgs);

        oos.flush();
        oos.close();
        fos.close();
      } catch (FileNotFoundException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
 private Bitmap readImageFromInternalStorage(String filename) {
   try {
     File filePath = context.getFileStreamPath(filename);
     FileInputStream fi = new FileInputStream(filePath);
     return BitmapFactory.decodeStream(fi);
   } catch (Exception ex) {
     Log.e("err in readImageFromInternalStorage()", ex.getMessage());
     return null;
   }
 }
示例#13
0
 public static void setString(Context context, String chave, String valor) {
   try {
     chave += ".txt";
     File file = context.getFileStreamPath(chave);
     FileOutputStream out = context.openFileOutput(chave, Context.MODE_PRIVATE);
     IOUtils.writeString(out, valor);
     Log.d(TAG, "PrefsFile.setString file: " + file + " >  " + valor);
   } catch (IOException ex) {
     Log.e(TAG, ex.getMessage(), ex);
   }
 }
示例#14
0
  /**
   * Create a temp file to store the result of a download.
   *
   * @param context
   * @param url
   * @return
   * @throws IOException
   */
  private static File getTemporaryFile(final Context context, final String url) throws IOException {

    // This is what you'd normally call to get a unique temporary
    // file, but for testing purposes we always name the file the
    // same to avoid filling up student phones with numerous
    // files!
    // return context.getFileStreamPath(Base64.encodeToString(url.getBytes(),
    //                                  Base64.NO_WRAP)
    //                                  + System.currentTimeMillis());

    return context.getFileStreamPath(Base64.encodeToString(url.getBytes(), Base64.NO_WRAP));
  }
示例#15
0
  /**
   * Loads the available slots in a grammar using the entries in the supplied GrammarMap. You must
   * load a grammar before calling this method.
   *
   * @param map A populated GrammarMap object.
   * @return <code>true</code> on success
   */
  public boolean loadSlots(GrammarMap map) {
    Context context = mContext.get();

    Resources res = context.getResources();
    File cached = context.getFileStreamPath("compiled." + EXTENSION_G2G);
    cached.deleteOnExit();

    for (Entry<String, List<GrammarEntry>> pair : map.getEntries()) {
      String slot = pair.getKey();
      List<GrammarEntry> entries = pair.getValue();

      for (GrammarEntry entry : entries) {
        mSrecGrammar.addWordToSlot(slot, entry.word, entry.pron, entry.weight, entry.tag);
      }
    }

    // Attempt to compile and save grammar to cache
    try {
      mSrecGrammar.compile();
      cached.getParentFile().mkdirs();
      mSrecGrammar.save(cached.getPath());

      Log.i(TAG, "Compiled grammar to " + cached.getAbsolutePath());
    } catch (IOException e) {
      e.printStackTrace();

      return false;
    }

    // Destroy the old grammar
    mSrecGrammar.destroy();
    mSrecGrammar = null;

    // Attempt to load new grammar from cached copy
    try {
      mGrammar = cached;
      mSrecGrammar = mSrec.new Grammar(cached.getPath());
      mSrecGrammar.setupRecognizer();
    } catch (IOException e) {
      e.printStackTrace();

      return false;
    }

    return true;
  }
 /** Copy the content of sourceUri to the destination. */
 private Uri copyTo(final Uri sourceUri, String filename) throws IOException {
   Log.i(
       LOG_TAG,
       String.format("Copy a Uri to app local storage (%s -> %s)", sourceUri, filename));
   final Context context = ImportVCardActivity.this;
   final ContentResolver resolver = context.getContentResolver();
   ReadableByteChannel inputChannel = null;
   WritableByteChannel outputChannel = null;
   Uri destUri = null;
   try {
     inputChannel = Channels.newChannel(resolver.openInputStream(sourceUri));
     destUri = Uri.parse(context.getFileStreamPath(filename).toURI().toString());
     outputChannel = context.openFileOutput(filename, Context.MODE_PRIVATE).getChannel();
     final ByteBuffer buffer = ByteBuffer.allocateDirect(8192);
     while (inputChannel.read(buffer) != -1) {
       if (mCanceled) {
         Log.d(LOG_TAG, "Canceled during caching " + sourceUri);
         return null;
       }
       buffer.flip();
       outputChannel.write(buffer);
       buffer.compact();
     }
     buffer.flip();
     while (buffer.hasRemaining()) {
       outputChannel.write(buffer);
     }
   } finally {
     if (inputChannel != null) {
       try {
         inputChannel.close();
       } catch (IOException e) {
         Log.w(LOG_TAG, "Failed to close inputChannel.");
       }
     }
     if (outputChannel != null) {
       try {
         outputChannel.close();
       } catch (IOException e) {
         Log.w(LOG_TAG, "Failed to close outputChannel");
       }
     }
   }
   return destUri;
 }
示例#17
0
  public static String ensureSuTools(Context context) {
    File suTools = context.getFileStreamPath("sutools");
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
    int sutoolsVersion = prefs.getInt("sutoolsVersion", 0);

    PackageManager pm = context.getPackageManager();
    int appVersionCode;
    try {
      PackageInfo info = pm.getPackageInfo(context.getPackageName(), 0);
      appVersionCode = info.versionCode;
    } catch (NameNotFoundException e) {
      appVersionCode = 0;
    }

    if (suTools.exists() && appVersionCode == sutoolsVersion) {
      return suTools.getAbsolutePath();
    }
    Log.d(TAG, "extracting sutools");

    try {
      copyFromAssets(context, "sutools-" + Build.CPU_ABI.split("-")[0], "sutools");
    } catch (IOException e) {
      Log.e(TAG, "Could not extract sutools");
      return null;
    }

    Process process;
    try {
      process =
          new ProcessBuilder()
              .command("chmod", "700", suTools.getAbsolutePath())
              .redirectErrorStream(true)
              .start();
      process.waitFor();
      process.destroy();
    } catch (IOException e) {
      Log.e(TAG, "Failed to set filemode of sutools");
      return null;
    } catch (InterruptedException e) {
      Log.w(TAG, "process interrupted");
    }

    prefs.edit().putInt("sutoolsVersion", appVersionCode).commit();
    return suTools.getAbsolutePath();
  }
  private static void setUrlDrawable(
      final Context context,
      ImageView imageView,
      final String url,
      final Drawable defaultDrawable,
      long cacheDurationMs,
      final UrlImageViewCallback callback) {
    cleanup(context);
    // disassociate this ImageView from any pending downloads
    if (isNullOrEmpty(url)) {
      if (imageView != null) imageView.setImageDrawable(defaultDrawable);
      return;
    }

    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    int tw = display.getWidth();
    int th = display.getHeight();

    if (mDeadCache == null) mDeadCache = new UrlLruCache(getHeapSize(context) / 8);
    Drawable drawable;
    BitmapDrawable zd = mDeadCache.remove(url);
    if (zd != null) {
      // this drawable was resurrected, it should not be in the live cache
      if (Constants.LOG_ENABLED) Log.i(Constants.LOGTAG, "zombie load");
      Assert.assertTrue(!mAllCache.contains(zd));
      drawable = new ZombieDrawable(url, zd);
    } else {
      drawable = mLiveCache.get(url);
    }

    if (drawable != null) {
      if (Constants.LOG_ENABLED) Log.i(Constants.LOGTAG, "Cache hit on: " + url);
      if (imageView != null) imageView.setImageDrawable(drawable);
      if (callback != null) callback.onLoaded(imageView, drawable, url, true);
      return;
    }

    // oh noes, at this point we definitely do not have the file available in memory
    // let's prepare for an asynchronous load of the image.

    final String filename = context.getFileStreamPath(getFilenameForUrl(url)).getAbsolutePath();

    // null it while it is downloading
    if (imageView != null) imageView.setImageDrawable(defaultDrawable);

    // since listviews reuse their views, we need to
    // take note of which url this view is waiting for.
    // This may change rapidly as the list scrolls or is filtered, etc.
    if (Constants.LOG_ENABLED) Log.i(Constants.LOGTAG, "Waiting for " + url);
    if (imageView != null) mPendingViews.put(imageView, url);

    ArrayList<ImageView> currentDownload = mPendingDownloads.get(url);
    if (currentDownload != null) {
      // Also, multiple vies may be waiting for this url.
      // So, let's maintain a list of these views.
      // When the url is downloaded, it sets the imagedrawable for
      // every view in the list. It needs to also validate that
      // the imageview is still waiting for this url.
      if (imageView != null) currentDownload.add(imageView);
      return;
    }

    final ArrayList<ImageView> downloads = new ArrayList<ImageView>();
    if (imageView != null) downloads.add(imageView);
    mPendingDownloads.put(url, downloads);

    final int targetWidth = tw <= 0 ? Integer.MAX_VALUE : tw;
    final int targetHeight = th <= 0 ? Integer.MAX_VALUE : th;
    final Loader loader =
        new Loader() {
          @Override
          public void run() {
            try {
              result = loadDrawableFromStream(context, url, filename, targetWidth, targetHeight);
            } catch (Exception ex) {
            }
          }
        };

    final Runnable completion =
        new Runnable() {
          @Override
          public void run() {
            Assert.assertEquals(Looper.myLooper(), Looper.getMainLooper());
            Drawable usableResult = loader.result;
            if (usableResult == null) usableResult = defaultDrawable;
            mPendingDownloads.remove(url);
            mLiveCache.put(url, usableResult);
            for (ImageView iv : downloads) {
              // validate the url it is waiting for
              String pendingUrl = mPendingViews.get(iv);
              if (!url.equals(pendingUrl)) {
                if (Constants.LOG_ENABLED)
                  Log.i(Constants.LOGTAG, "Ignoring out of date request to update view for " + url);
                continue;
              }
              mPendingViews.remove(iv);
              if (usableResult != null) {
                //                        System.out.println(String.format("imageView: %dx%d,
                // %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(),
                // imageView.getWidth(), imageView.getHeight()));
                iv.setImageDrawable(usableResult);
                //                        System.out.println(String.format("imageView: %dx%d,
                // %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(),
                // imageView.getWidth(), imageView.getHeight()));
                if (callback != null) callback.onLoaded(iv, loader.result, url, false);
              }
            }
          }
        };

    File file = new File(filename);
    if (file.exists()) {
      try {
        if (cacheDurationMs == CACHE_DURATION_INFINITE
            || System.currentTimeMillis() < file.lastModified() + cacheDurationMs) {
          if (Constants.LOG_ENABLED)
            Log.i(
                Constants.LOGTAG,
                "File Cache hit on: "
                    + url
                    + ". "
                    + (System.currentTimeMillis() - file.lastModified())
                    + "ms old.");

          AsyncTask<Void, Void, Void> fileloader =
              new AsyncTask<Void, Void, Void>() {
                protected Void doInBackground(Void[] params) {
                  loader.run();
                  return null;
                }

                protected void onPostExecute(Void result) {
                  completion.run();
                }
              };
          executeTask(fileloader);
          return;
        } else {
          if (Constants.LOG_ENABLED) Log.i(Constants.LOGTAG, "File cache has expired. Refreshing.");
        }
      } catch (Exception ex) {
      }
    }

    mDownloader.download(context, url, filename, loader, completion);
  }
示例#19
0
 private static File getGuestDir(Context context) {
   if (mGuestDir == null) {
     mGuestDir = context.getFileStreamPath("guest");
   }
   return mGuestDir;
 }
    @Override
    public void run() {
      Log.i(LOG_TAG, "vCard cache thread starts running.");
      if (mConnection == null) {
        throw new NullPointerException(
            "vCard cache thread must be launched " + "after a service connection is established");
      }

      mWakeLock.acquire();
      try {
        /// M: ALPS01022668 first vcard import finished,
        //  second vcard still caching, can't stop service in this case.
        mConnection.setVCardCaching(true);
        if (mCanceled == true) {
          Log.i(LOG_TAG, "vCard cache operation is canceled.");
          return;
        }

        final Context context = ImportVCardActivity.this;
        // Uris given from caller applications may not be opened twice: consider when
        // it is not from local storage (e.g. "file:///...") but from some special
        // provider (e.g. "content://...").
        // Thus we have to once copy the content of Uri into local storage, and read
        // it after it.
        //
        // We may be able to read content of each vCard file during copying them
        // to local storage, but currently vCard code does not allow us to do so.
        int cache_index = 0;
        ArrayList<ImportRequest> requests = new ArrayList<ImportRequest>();
        if (mSource != null) {
          try {
            requests.add(constructImportRequest(mSource, null, mDisplayName));
          } catch (VCardException e) {
            Log.e(LOG_TAG, "Maybe the file is in wrong format", e);
            showFailureNotification(R.string.fail_reason_not_supported);
            return;
          }
        } else {
          final ContentResolver resolver = ImportVCardActivity.this.getContentResolver();
          for (Uri sourceUri : mSourceUris) {
            String filename = null;
            // Note: caches are removed by VCardService.
            while (true) {
              filename = VCardService.CACHE_FILE_PREFIX + cache_index + ".vcf";
              final File file = context.getFileStreamPath(filename);
              if (!file.exists()) {
                break;
              } else {
                if (cache_index == Integer.MAX_VALUE) {
                  throw new RuntimeException("Exceeded cache limit");
                }
                cache_index++;
              }
            }
            final Uri localDataUri = copyTo(sourceUri, filename);
            if (mCanceled) {
              Log.i(LOG_TAG, "vCard cache operation is canceled.");
              break;
            }
            if (localDataUri == null) {
              Log.w(LOG_TAG, "destUri is null");
              break;
            }

            String displayName = null;
            Cursor cursor = null;
            // Try to get a display name from the given Uri. If it fails, we just
            // pick up the last part of the Uri.
            try {
              cursor =
                  resolver.query(
                      sourceUri, new String[] {OpenableColumns.DISPLAY_NAME}, null, null, null);
              if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) {
                if (cursor.getCount() > 1) {
                  Log.w(LOG_TAG, "Unexpected multiple rows: " + cursor.getCount());
                }
                int index = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
                if (index >= 0) {
                  displayName = cursor.getString(index);
                }
              }
              /// M: @{
            } catch (Exception e) {
              // we just want the name. so exception should be igrnored. anyway, if
              // displayName is not set, the follwing code will use given uri as display name.
              Log.w(LOG_TAG, "exception caught ", e);
              /// @}
            } finally {
              if (cursor != null) {
                cursor.close();
              }
            }
            if (TextUtils.isEmpty(displayName)) {
              displayName = sourceUri.getLastPathSegment();
            }

            final ImportRequest request;
            try {
              request = constructImportRequest(null, localDataUri, displayName);
            } catch (VCardException e) {
              Log.e(LOG_TAG, "Maybe the file is in wrong format", e);
              /// M: Fixed cr ALPS00598462 @{
              String reason = getString(R.string.fail_reason_not_supported);
              VcardUtils.showFailureNotification(
                  ImportVCardActivity.this, reason, displayName, cache_index, mHandler);
              continue;
              /// @}
              /// Bug fix ALPS00318987 @{
            } catch (IllegalArgumentException e) {
              LogUtils.e(LOG_TAG, "Maybe the file is in wrong format", e);
              /// M: Fixed cr ALPS00598462
              String reason = getString(R.string.fail_reason_not_supported);
              VcardUtils.showFailureNotification(
                  ImportVCardActivity.this, reason, displayName, cache_index, mHandler);
              continue;
              /// @}
            } catch (IOException e) {
              Log.e(LOG_TAG, "Unexpected IOException", e);
              /// M: Fixed cr ALPS00598462 @{
              String reason = getString(R.string.fail_reason_io_error);
              VcardUtils.showFailureNotification(
                  ImportVCardActivity.this, reason, displayName, cache_index, mHandler);
              continue;
              /// @}
            }
            if (mCanceled) {
              Log.i(LOG_TAG, "vCard cache operation is canceled.");
              return;
            }
            requests.add(request);
          }
        }
        if (!requests.isEmpty()) {
          mConnection.sendImportRequest(requests);
        } else {
          Log.w(LOG_TAG, "Empty import requests. Ignore it.");
        }
      } catch (OutOfMemoryError e) {
        Log.e(LOG_TAG, "OutOfMemoryError occured during caching vCard");
        System.gc();
        runOnUiThread(
            new DialogDisplayer(getString(R.string.fail_reason_low_memory_during_import)));
      } catch (FileNotFoundException e) {
        /// M: Fix ALPS00874343,if the vcf file is not exist,toast error msg. @{
        LogUtils.w(LOG_TAG, "[run] the vcf file is not found when import! exception:" + e);
        VcardUtils.showErrorInfo(R.string.import_failure_no_vcard_file, ImportVCardActivity.this);
        /// @}
      } catch (IOException e) {
        Log.e(LOG_TAG, "IOException during caching vCard", e);
        runOnUiThread(new DialogDisplayer(getString(R.string.fail_reason_io_error)));
      } finally {
        Log.i(LOG_TAG, "Finished caching vCard.");
        /// M: ALPS01022668 first vcard import finished,
        //  second vcard still caching, can't stop service in this case.
        mConnection.setVCardCaching(false);
        mWakeLock.release();
        /// M: @{
        if (!ImportVCardActivity.this.isFinishing()
            && (null != mConnection)
            && mConnection.isServiceBinded()) {
          unbindService(mConnection);
          mConnection = null;
        } else {
          LogUtils.d(LOG_TAG, "in VcardCacheThread, Run(), mConnection==null !!! ");
        }
        /// @}
        mProgressDialogForCachingVCard.dismiss();
        mProgressDialogForCachingVCard = null;
        finish();
      }
    }
  /**
   * Download and shrink an Image located at a specified URL, and display it in the provided {@link
   * ImageView}.
   *
   * @param context A {@link Context} to allow setUrlDrawable to load and save files.
   * @param imageView The {@link ImageView} to display the image to after it is loaded.
   * @param url The URL of the image that should be loaded.
   * @param defaultDrawable A {@link Drawable} that should be displayed in {@code imageView} while
   *     the image has not been loaded. This image will also be displayed if the image fails to
   *     load. This can be set to {@code null}.
   * @param cacheDurationMs The length of time, in milliseconds, that this image should be cached
   *     locally.
   * @param callback An instance of {@link UrlImageViewCallback} that is called when the image
   *     successfully finishes loading. This value can be null.
   */
  private static void setUrlDrawable(
      final Context context,
      final ImageView imageView,
      final String url,
      final Drawable defaultDrawable,
      final long cacheDurationMs,
      final UrlImageViewCallback callback) {
    cleanup(context);
    // disassociate this ImageView from any pending downloads
    if (isNullOrEmpty(url)) {
      if (imageView != null) {
        imageView.setImageDrawable(defaultDrawable);
      }
      return;
    }

    final int tw;
    final int th;
    if (mMetrics == null) prepareResources(context);
    tw = mMetrics.widthPixels;
    th = mMetrics.heightPixels;

    final String filename = context.getFileStreamPath(getFilenameForUrl(url)).getAbsolutePath();
    final File file = new File(filename);

    if (mDeadCache == null) {
      mDeadCache = new UrlLruCache(getHeapSize(context) / 8);
    }
    Drawable drawable;
    final BitmapDrawable bd = mDeadCache.remove(url);
    if (bd != null) {
      // this drawable was resurrected, it should not be in the live cache
      clog("zombie load: " + url);
      Assert.assertTrue(url, !mAllCache.contains(bd));
      drawable = new ZombieDrawable(url, bd);
    } else {
      drawable = mLiveCache.get(url);
    }

    if (drawable != null) {
      clog("Cache hit on: " + url);
      // if the file age is older than the cache duration, force a refresh.
      // note that the file must exist, otherwise it is using a default.
      // not checking for file existence would do a network call on every
      // 404 or failed load.
      if (file.exists() && !checkCacheDuration(file, cacheDurationMs)) {
        clog("Cache hit, but file is stale. Forcing reload: " + url);
        if (drawable instanceof ZombieDrawable) ((ZombieDrawable) drawable).headshot();
        drawable = null;
      } else {
        clog("Using cached: " + url);
      }
    }

    if (drawable != null) {
      if (imageView != null) {
        imageView.setImageDrawable(drawable);
      }
      if (callback != null) {
        callback.onLoaded(imageView, drawable, url, true);
      }
      return;
    }

    // oh noes, at this point we definitely do not have the file available in memory
    // let's prepare for an asynchronous load of the image.

    // null it while it is downloading
    if (imageView != null) {
      imageView.setImageDrawable(defaultDrawable);
    }

    // since listviews reuse their views, we need to
    // take note of which url this view is waiting for.
    // This may change rapidly as the list scrolls or is filtered, etc.
    clog("Waiting for " + url);
    if (imageView != null) {
      mPendingViews.put(imageView, url);
    }

    final ArrayList<ImageView> currentDownload = mPendingDownloads.get(url);
    if (currentDownload != null) {
      // Also, multiple vies may be waiting for this url.
      // So, let's maintain a list of these views.
      // When the url is downloaded, it sets the imagedrawable for
      // every view in the list. It needs to also validate that
      // the imageview is still waiting for this url.
      if (imageView != null) {
        currentDownload.add(imageView);
      }
      return;
    }

    final ArrayList<ImageView> downloads = new ArrayList<ImageView>();
    if (imageView != null) {
      downloads.add(imageView);
    }
    mPendingDownloads.put(url, downloads);

    final int targetWidth = tw <= 0 ? Integer.MAX_VALUE : tw;
    final int targetHeight = th <= 0 ? Integer.MAX_VALUE : th;
    final Loader loader =
        new Loader() {
          @Override
          public void run() {
            try {
              result = loadDrawableFromStream(context, url, filename, targetWidth, targetHeight);
            } catch (final Exception ex) {
            }
          }
        };

    final Runnable completion =
        new Runnable() {
          @Override
          public void run() {
            Assert.assertEquals(Looper.myLooper(), Looper.getMainLooper());
            Drawable usableResult = loader.result;
            if (usableResult == null) {
              usableResult = defaultDrawable;
            }
            mPendingDownloads.remove(url);
            mLiveCache.put(url, usableResult);
            if (callback != null && imageView == null)
              callback.onLoaded(null, loader.result, url, false);
            int waitingCount = 0;
            for (final ImageView iv : downloads) {
              // validate the url it is waiting for
              final String pendingUrl = mPendingViews.get(iv);
              if (!url.equals(pendingUrl)) {
                clog("Ignoring out of date request to update view for " + url);
                continue;
              }
              waitingCount++;
              mPendingViews.remove(iv);
              if (usableResult != null) {
                //                        System.out.println(String.format("imageView: %dx%d,
                // %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(),
                // imageView.getWidth(), imageView.getHeight()));
                iv.setImageDrawable(usableResult);
                //                        System.out.println(String.format("imageView: %dx%d,
                // %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(),
                // imageView.getWidth(), imageView.getHeight()));
                if (callback != null && iv == imageView)
                  callback.onLoaded(iv, loader.result, url, false);
              }
            }
            clog("Populated: " + waitingCount);
          }
        };

    if (file.exists()) {
      try {
        if (checkCacheDuration(file, cacheDurationMs)) {
          clog(
              "File Cache hit on: "
                  + url
                  + ". "
                  + (System.currentTimeMillis() - file.lastModified())
                  + "ms old.");

          final AsyncTask<Void, Void, Void> fileloader =
              new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(final Void... params) {
                  loader.run();
                  return null;
                }

                @Override
                protected void onPostExecute(final Void result) {
                  completion.run();
                }
              };
          executeTask(fileloader);
          return;
        } else {
          clog("File cache has expired. Refreshing.");
        }
      } catch (final Exception ex) {
      }
    }

    mDownloader.download(context, url, filename, loader, completion);
  }
示例#22
0
 /**
  * 判断缓存是否存在
  *
  * @param cachefile
  * @return
  */
 private boolean isExistDataCache(Context ctx, String cachefile) {
   boolean exist = false;
   File data = ctx.getFileStreamPath(cachefile);
   if (data.exists()) exist = true;
   return exist;
 }
示例#23
0
 /**
  * Create a file to store the result of a download.
  *
  * @param context
  * @param url
  * @return
  * @throws IOException
  */
 private File getTemporaryFile(final Context context, final String url) throws IOException {
   return context.getFileStreamPath(
       Base64.encodeToString(url.getBytes(), Base64.NO_WRAP) + System.currentTimeMillis());
 }
  /**
   * Download and shrink an Image located at a specified URL, and display it in the provided {@link
   * ImageView}.
   *
   * @param context A {@link Context} to allow setUrlDrawable to load and save files.
   * @param imageView The {@link ImageView} to display the image to after it is loaded.
   * @param url The URL of the image that should be loaded.
   * @param defaultDrawable A {@link Drawable} that should be displayed in {@code imageView} while
   *     the image has not been loaded. This image will also be displayed if the image fails to
   *     load. This can be set to {@code null}.
   * @param cacheDurationMs The length of time, in milliseconds, that this image should be cached
   *     locally.
   * @param callback An instance of {@link UrlImageViewCallback} that is called when the image
   *     successfully finishes loading. This value can be null.
   */
  private static void setUrlDrawable(
      final Context context,
      final ImageView imageView,
      final String url,
      final Drawable defaultDrawable,
      final long cacheDurationMs,
      final UrlImageViewCallback callback) {
    assert (Looper.getMainLooper().getThread() == Thread.currentThread())
        : "setUrlDrawable and loadUrlDrawable should only be called from the main thread.";
    cleanup(context);
    // disassociate this ImageView from any pending downloads
    if (isNullOrEmpty(url)) {
      if (imageView != null) {
        mPendingViews.remove(imageView);
        imageView.setImageDrawable(defaultDrawable);
      }
      return;
    }

    final int tw;
    final int th;
    if (mMetrics == null) prepareResources(context);
    tw = mMetrics.widthPixels;
    th = mMetrics.heightPixels;

    final String filename = context.getFileStreamPath(getFilenameForUrl(url)).getAbsolutePath();
    final File file = new File(filename);

    // check the dead and live cache to see if we can find this url's bitmap
    if (mDeadCache == null) {
      mDeadCache = new LruBitmapCache(getHeapSize(context) / 8);
    }
    Drawable drawable = null;
    Bitmap bitmap = mDeadCache.remove(url);
    if (bitmap != null) {
      clog("zombie load: " + url);
    } else {
      drawable = mLiveCache.get(url);
    }

    // if something was found, verify it was fresh.
    if (drawable != null || bitmap != null) {
      clog("Cache hit on: " + url);
      // if the file age is older than the cache duration, force a refresh.
      // note that the file must exist, otherwise it is using a default.
      // not checking for file existence would do a network call on every
      // 404 or failed load.
      if (file.exists() && !checkCacheDuration(file, cacheDurationMs)) {
        clog("Cache hit, but file is stale. Forcing reload: " + url);
        if (drawable != null && drawable instanceof ZombieDrawable)
          ((ZombieDrawable) drawable).headshot();
        drawable = null;
        bitmap = null;
      } else {
        clog("Using cached: " + url);
      }
    }

    // if the bitmap is fresh, set the imageview
    if (drawable != null || bitmap != null) {
      if (imageView != null) {
        mPendingViews.remove(imageView);
        if (drawable instanceof ZombieDrawable)
          drawable = ((ZombieDrawable) drawable).clone(mResources);
        else if (bitmap != null) drawable = new ZombieDrawable(url, mResources, bitmap);

        imageView.setImageDrawable(drawable);
      }
      // invoke any bitmap callbacks
      if (callback != null) {
        // when invoking the callback from cache, check to see if this was
        // a drawable that was successfully loaded from the filesystem or url.
        // this will be indicated by it being a ZombieDrawable (ie, something we are managing).
        // The default drawables will be BitmapDrawables (or whatever else the user passed in).
        if (bitmap == null && drawable instanceof ZombieDrawable)
          bitmap = ((ZombieDrawable) drawable).getBitmap();
        callback.onLoaded(imageView, bitmap, url, true);
      }
      return;
    }

    // oh noes, at this point we definitely do not have the file available in memory
    // let's prepare for an asynchronous load of the image.

    // null it while it is downloading
    // since listviews reuse their views, we need to
    // take note of which url this view is waiting for.
    // This may change rapidly as the list scrolls or is filtered, etc.
    clog("Waiting for " + url + " " + imageView);
    if (imageView != null) {
      imageView.setImageDrawable(defaultDrawable);
      mPendingViews.put(imageView, url);
    }

    final ArrayList<ImageView> currentDownload = mPendingDownloads.get(url);
    if (currentDownload != null && currentDownload.size() != 0) {
      // Also, multiple vies may be waiting for this url.
      // So, let's maintain a list of these views.
      // When the url is downloaded, it sets the imagedrawable for
      // every view in the list. It needs to also validate that
      // the imageview is still waiting for this url.
      if (imageView != null) {
        currentDownload.add(imageView);
      }
      return;
    }

    final ArrayList<ImageView> downloads = new ArrayList<ImageView>();
    if (imageView != null) {
      downloads.add(imageView);
    }
    mPendingDownloads.put(url, downloads);

    final int targetWidth = tw <= 0 ? Integer.MAX_VALUE : tw;
    final int targetHeight = th <= 0 ? Integer.MAX_VALUE : th;
    final Loader loader =
        new Loader() {
          @Override
          public void onDownloadComplete(
              UrlDownloader downloader, InputStream in, String existingFilename) {
            try {
              assert (in == null || existingFilename == null);
              if (in == null && existingFilename == null) return;
              String targetFilename = filename;
              if (in != null) {
                in = new BufferedInputStream(in, 8192);
                OutputStream fout = new BufferedOutputStream(new FileOutputStream(filename), 8192);
                copyStream(in, fout);
                fout.close();
              } else {
                targetFilename = existingFilename;
              }
              result =
                  loadBitmapFromStream(context, url, targetFilename, targetWidth, targetHeight);
            } catch (final Exception ex) {
              // always delete busted files when we throw.
              new File(filename).delete();
              if (Constants.LOG_ENABLED) Log.e(Constants.LOGTAG, "Error loading " + url, ex);
            } finally {
              // if we're not supposed to cache this thing, delete the temp file.
              if (downloader != null && !downloader.allowCache()) new File(filename).delete();
            }
          }
        };

    final Runnable completion =
        new Runnable() {
          @Override
          public void run() {
            assert (Looper.myLooper().equals(Looper.getMainLooper()));
            Bitmap bitmap = loader.result;
            Drawable usableResult = null;
            if (bitmap != null) {
              usableResult = new ZombieDrawable(url, mResources, bitmap);
            }
            if (usableResult == null) {
              clog("No usable result, defaulting " + url);
              usableResult = defaultDrawable;
              mLiveCache.put(url, usableResult);
            }
            mPendingDownloads.remove(url);
            //                mLiveCache.put(url, usableResult);
            if (callback != null && imageView == null)
              callback.onLoaded(null, loader.result, url, false);
            int waitingCount = 0;
            for (final ImageView iv : downloads) {
              // validate the url it is waiting for
              final String pendingUrl = mPendingViews.get(iv);
              if (!url.equals(pendingUrl)) {
                clog(
                    "Ignoring out of date request to update view for "
                        + url
                        + " "
                        + pendingUrl
                        + " "
                        + iv);
                continue;
              }
              waitingCount++;
              mPendingViews.remove(iv);
              if (usableResult != null) {
                //                        System.out.println(String.format("imageView: %dx%d,
                // %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(),
                // imageView.getWidth(), imageView.getHeight()));
                iv.setImageDrawable(usableResult);
                //                        System.out.println(String.format("imageView: %dx%d,
                // %dx%d", imageView.getMeasuredWidth(), imageView.getMeasuredHeight(),
                // imageView.getWidth(), imageView.getHeight()));
                // onLoaded is called with the loader's result (not what is actually used). null
                // indicates failure.
              }
              if (callback != null && iv == imageView)
                callback.onLoaded(iv, loader.result, url, false);
            }
            clog("Populated: " + waitingCount);
          }
        };

    if (file.exists()) {
      try {
        if (checkCacheDuration(file, cacheDurationMs)) {
          clog(
              "File Cache hit on: "
                  + url
                  + ". "
                  + (System.currentTimeMillis() - file.lastModified())
                  + "ms old.");

          final AsyncTask<Void, Void, Void> fileloader =
              new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(final Void... params) {
                  loader.onDownloadComplete(null, null, filename);
                  return null;
                }

                @Override
                protected void onPostExecute(final Void result) {
                  completion.run();
                }
              };
          executeTask(fileloader);
          return;
        } else {
          clog("File cache has expired. Refreshing.");
        }
      } catch (final Exception ex) {
      }
    }

    for (UrlDownloader downloader : mDownloaders) {
      if (downloader.canDownloadUrl(url)) {
        try {
          downloader.download(context, url, filename, loader, completion);
        } catch (Exception e) {
          clog("Can't download from url: " + url + " Exception: " + e.getMessage());
          mPendingDownloads.remove(url);
          if (imageView != null) {
            mPendingViews.remove(imageView);
          }
        }
        return;
      }
    }

    imageView.setImageDrawable(defaultDrawable);
  }