public boolean equals(SyncLogEntry entry) {

    Logger.e(
        "entry: "
            + entry.m_file_name
            + " tags: "
            + entry.m_tags
            + " hash: "
            + entry.m_hash_sum
            + " timestamp:"
            + entry.m_time_stamp);
    Logger.e(
        "this: "
            + this.m_file_name
            + " tags: "
            + this.m_tags
            + " hash: "
            + this.m_hash_sum
            + " timestamp:"
            + this.m_time_stamp);
    return this.m_file_name.equals(entry.m_file_name)
        && this.m_tags.equals(entry.m_tags)
        && this.m_hash_sum.equals(entry.m_hash_sum)
        && this.m_time_stamp.equals(entry.m_time_stamp);
  }
  private boolean queryInstance(final URL authorizationEndpointUrl) {

    // It will query prod instance to verify the authority
    // construct query string for this instance
    URL queryUrl;
    boolean result = false;
    try {
      queryUrl =
          buildQueryString(
              TRUSTED_QUERY_INSTANCE, getAuthorizationCommonEndpoint(authorizationEndpointUrl));

      result = sendRequest(queryUrl);
    } catch (MalformedURLException e) {
      Logger.e(TAG, "Invalid authority", "", ADALError.DEVELOPER_AUTHORITY_IS_NOT_VALID_URL, e);
      result = false;
    } catch (JSONException e) {
      Logger.e(TAG, "Json parsing error", "", ADALError.DEVELOPER_AUTHORITY_CAN_NOT_BE_VALIDED, e);
      result = false;
    }

    if (result) {
      // it is validated
      addValidHostToList(authorizationEndpointUrl);
    }

    return result;
  }
 /**
  * Send a ERROR message.
  *
  * @param tag Used to identify the source of a log message. It usually identifies the class or
  *     activity where the log call occurs.
  * @param formatString The string you would like logged plus format specifiers.
  * @param args Variable number of Object args to be used as params to formatString.
  */
 public static void e(String tag, String formatString, Object... args) {
   if (logger != null && isLoggingEnabled(tag, ERROR)) {
     try {
       logger.e(tag, String.format(formatString, args));
     } catch (Exception e) {
       logger.e(tag, String.format("Unable to format log: %s", formatString), e);
     }
   }
 }
  /**
   * Gets intent for authentication activity from Broker component to start from calling app's
   * activity to control the lifetime of the activity.
   */
  @Override
  public Intent getIntentForBrokerActivity(final AuthenticationRequest request) {
    Intent intent = null;
    AccountManagerFuture<Bundle> result = null;
    try {
      // Callback is not passed since it is making a blocking call to get
      // intent. Activity needs to be launched from calling app
      // to get the calling app's metadata if needed at BrokerActivity.
      Bundle addAccountOptions = getBrokerOptions(request);
      result =
          mAcctManager.addAccount(
              AuthenticationConstants.Broker.BROKER_ACCOUNT_TYPE,
              AuthenticationConstants.Broker.AUTHTOKEN_TYPE,
              null,
              addAccountOptions,
              null,
              null,
              mHandler);

      // Making blocking request here
      Bundle bundleResult = result.getResult();
      // Authenticator should throw OperationCanceledException if
      // token is not available
      intent = bundleResult.getParcelable(AccountManager.KEY_INTENT);

      // Add flag to this intent to signal that request is for broker
      // logic
      if (intent != null) {
        intent.putExtra(
            AuthenticationConstants.Broker.BROKER_REQUEST,
            AuthenticationConstants.Broker.BROKER_REQUEST);
      }
    } catch (OperationCanceledException e) {
      Logger.e(TAG, "Authenticator cancels the request", "", ADALError.AUTH_FAILED_CANCELLED, e);
    } catch (AuthenticatorException e) {
      //
      // TODO add retry logic since authenticator is not responding to
      // the request
      Logger.e(
          TAG,
          "Authenticator cancels the request",
          "",
          ADALError.BROKER_AUTHENTICATOR_NOT_RESPONDING);
    } catch (IOException e) {
      // Authenticator gets problem from webrequest or file read/write
      Logger.e(
          TAG,
          "Authenticator cancels the request",
          "",
          ADALError.BROKER_AUTHENTICATOR_IO_EXCEPTION);
    }

    return intent;
  }
Beispiel #5
0
  public static Object post(RequestModel model) {

    //		Authenticator.setDefault(new Authenticator() {
    //	        protected PasswordAuthentication getPasswordAuthentication() {
    //	            return new PasswordAuthentication (Loggerin, password.toCharArray());
    //	        }
    //	    });
    DefaultHttpClient client = new DefaultHttpClient();
    String url = model.host.concat(model.context.getString(model.requestUrl));
    Logger.e("NetUtil里面的post的URL", url);
    HttpPost post = new HttpPost(url);
    post.setHeader(
        "Authorization",
        "Basic " + Base64.encodeToString((Loggerin + ":" + password).getBytes(), Base64.NO_WRAP));
    HttpParams params = new BasicHttpParams();
    params = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(params, 8000);
    HttpConnectionParams.setSoTimeout(params, 8000);
    post.setParams(params);

    Object obj = null;
    try {
      if (model.requestDataMap != null) {
        HashMap<String, String> map = model.requestDataMap;
        List<BasicNameValuePair> pairList = new ArrayList<BasicNameValuePair>();
        for (Map.Entry<String, String> entry : map.entrySet()) {
          BasicNameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
          pairList.add(pair);
        }
        HttpEntity entity = new UrlEncodedFormEntity(pairList, "UTF-8");
        post.setEntity(entity);
      }

      HttpResponse response = client.execute(post);
      if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        String result = EntityUtils.toString(response.getEntity(), "UTF-8");
        Logger.e(NetUtil.class.getSimpleName() + "1", result);
        try {
          obj = model.jsonParser.parseJSON(result);
        } catch (Exception e) {
          Log.e(NetUtil.class.getSimpleName() + "2", e.getLocalizedMessage(), e);
        }
        return obj;
      }
    } catch (ClientProtocolException e) {
      Log.e(NetUtil.class.getSimpleName() + "5", e.getLocalizedMessage(), e);
    } catch (IOException e) {
      Log.e(NetUtil.class.getSimpleName() + "6", e.getLocalizedMessage(), e);
    }
    return null;
  }
  public static void initImageLoaderConfig(Context context) {
    try {
      File cacheDir =
          StorageUtils.getOwnCacheDirectory(
              context, CommonUtil.getSavePath(SysConstant.FILE_SAVE_TYPE_IMAGE));
      File reserveCacheDir = StorageUtils.getCacheDirectory(context);

      int maxMemory = (int) (Runtime.getRuntime().maxMemory());
      // 使用最大可用内存值的1/8作为缓存的大小。
      int cacheSize = maxMemory / 8;
      DisplayMetrics metrics = new DisplayMetrics();
      WindowManager mWm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      mWm.getDefaultDisplay().getMetrics(metrics);

      IMImageLoaderConfig =
          new ImageLoaderConfiguration.Builder(context)
              .memoryCacheExtraOptions(metrics.widthPixels, metrics.heightPixels)
              .threadPriority(Thread.NORM_PRIORITY - 2)
              //                    .denyCacheImageMultipleSizesInMemory()
              .memoryCache(new UsingFreqLimitedMemoryCache(cacheSize))
              .diskCacheFileNameGenerator(new Md5FileNameGenerator())
              .tasksProcessingOrder(QueueProcessingType.LIFO)
              .diskCacheExtraOptions(metrics.widthPixels, metrics.heightPixels, null)
              .diskCache(
                  new UnlimitedDiscCache(cacheDir, reserveCacheDir, new Md5FileNameGenerator()))
              .diskCacheSize(1024 * 1024 * 1024)
              .diskCacheFileCount(1000)
              .build();

      IMImageLoadInstance = ImageLoader.getInstance();
      IMImageLoadInstance.init(IMImageLoaderConfig);
    } catch (Exception e) {
      logger.e(e.toString());
    }
  }
  private boolean verifyAccount(Account[] accountList, String username, String uniqueId) {
    if (!StringExtensions.IsNullOrBlank(username)) {
      return username.equalsIgnoreCase(accountList[0].name);
    }

    if (!StringExtensions.IsNullOrBlank(uniqueId)) {
      // Uniqueid for account at authenticator is not available with
      // Account
      UserInfo[] users;
      try {
        users = getBrokerUsers();
        UserInfo matchingUser = findUserInfo(uniqueId, users);
        return matchingUser != null;
      } catch (Exception e) {
        Logger.e(
            TAG,
            "VerifyAccount:" + e.getMessage(),
            "",
            ADALError.BROKER_AUTHENTICATOR_EXCEPTION,
            e);
      }

      Logger.v(TAG, "It could not check the uniqueid from broker. It is not using broker");
      return false;
    }

    // if username or uniqueid not specified, it should use the broker
    // account.
    return true;
  }
  private void updateFromPreference() {
    Logger.d("Service updateFromPreference called");
    SharedPreferences prefs =
        PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
    try {
      powerManager.setBatteryThresh(
          Integer.parseInt(
              prefs.getString(
                  getString(R.string.batteryMinThresPrefKey),
                  String.valueOf(Config.DEFAULT_BATTERY_THRESH_PRECENT))));

      this.setCheckinInterval(
          Integer.parseInt(
                  prefs.getString(
                      getString(R.string.checkinIntervalPrefKey),
                      String.valueOf(Config.DEFAULT_CHECKIN_INTERVAL_SEC / 3600)))
              * 3600);

      updateStatus();

      Logger.i(
          "Preference set from SharedPreference: "
              + "checkinInterval="
              + checkinIntervalSec
              + ", minBatThres= "
              + powerManager.getBatteryThresh());
    } catch (ClassCastException e) {
      Logger.e("exception when casting preference values", e);
    }
  }
Beispiel #9
0
  /**
   * 调用的时候要判断是否为空
   *
   * @param model
   * @return
   */
  public static Object get(RequestModel model) {
    //		 Authenticator.setDefault(new Authenticator() {
    //		        protected PasswordAuthentication getPasswordAuthentication() {
    //		            return new PasswordAuthentication (Loggerin, password.toCharArray());
    //		        }
    //		    });
    DefaultHttpClient client = new DefaultHttpClient();
    String url = model.host.concat(model.context.getString(model.requestUrl));
    StringBuffer sb = new StringBuffer();
    sb.append(url);
    String afterSign = addGetParams(model.requestDataMap);
    sb.append(afterSign);
    Logger.e("get请求方法", "最后的请求地址是 == " + sb.toString());
    String u = sb.toString();
    u = u.replace(" ", "%20");
    HttpGet get = new HttpGet(u);
    get.setHeader(
        "Authorization",
        "Basic " + Base64.encodeToString((Loggerin + ":" + password).getBytes(), Base64.NO_WRAP));
    HttpParams params = new BasicHttpParams();
    params = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(params, 8000);
    HttpConnectionParams.setSoTimeout(params, 8000);
    get.setParams(params);
    Object obj = null;
    try {
      HttpResponse response = client.execute(get);

      if (response == null) {
        Logger.e("get", "response == null");
      }

      if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        String result = EntityUtils.toString(response.getEntity(), "UTF-8");
        Logger.i(NetUtil.class.getSimpleName() + "get3", result);
        try {
          obj = model.jsonParser.parseJSON(result);
        } catch (JSONException e) {
          Log.e(NetUtil.class.getSimpleName() + "4", e.getLocalizedMessage(), e);
        }
        return obj;
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
Beispiel #10
0
 public static JSONObject buildSensorJson(HashMap<String, BaseSensor> sensorMap, long frameNo) {
   try {
     JSONObject jsonObject = new JSONObject();
     jsonObject.put("frameNo", frameNo);
     for (Entry<String, BaseSensor> entry : sensorMap.entrySet()) {
       try {
         jsonObject.put(entry.getKey(), entry.getValue().getJsonResult());
       } catch (JSONException e) {
         Logger.e(LOGTAG, "Exception with Writing Sensor " + entry.getKey());
       }
     }
     return jsonObject;
   } catch (JSONException je) {
     Logger.e(LOGTAG, "Exception with buildSensorJson");
     return null;
   }
 }
Beispiel #11
0
 public static String encode(String url) {
   try {
     return URLEncoder.encode(url, "UTF-8");
   } catch (UnsupportedEncodingException e) {
     Logger.e(e);
   }
   return url;
 }
 public boolean isExpiried(String param, long expTime) {
   TestParam p = map.get(param);
   if (p == null) {
     Logger.e(this, "can not find param for name: " + param);
     return true;
   }
   return (p.createdTime + expTime) < System.currentTimeMillis();
 }
  @Test
  public void errorLoggedCorrectly() {
    String expectedMessage = "Hello World";

    logger.e(tag, "Hello %s", "World");

    assertLogged(ERROR, tag, expectedMessage, null);
  }
  @Test
  public void errorWithThrowableLoggedCorrectly() {
    String expectedMessage = "Hello World";
    Throwable t = new Throwable("Test Throwable");

    logger.e(t, tag, "Hello %s", "World");

    assertLogged(ERROR, tag, expectedMessage, t);
  }
Beispiel #15
0
 public byte[] loadResourceBytes(int id) {
   try {
     InputStream is = this.mActivity.getResources().openRawResource(id);
     return loadResourceBytes(is);
   } catch (Exception e) {
     log.e("cannot load resource");
     return null;
   }
 }
Beispiel #16
0
 public String loadFileUtf8(File file) {
   try {
     InputStream is = new FileInputStream(file);
     return loadResourceUtf8(is);
   } catch (Exception e) {
     log.e("cannot load resource from file " + file);
     return null;
   }
 }
Beispiel #17
0
 public static void closeStream(Closeable is) {
   try {
     if (is != null) {
       is.close();
       is = null;
     }
   } catch (Exception e) {
     Logger.e(TAG, "closeStream(" + is + ")", e);
   }
 }
  private boolean sendRequest(final URL queryUrl) throws MalformedURLException, JSONException {

    Logger.v(TAG, "Sending discovery request to:" + queryUrl);
    HashMap<String, String> headers = new HashMap<String, String>();
    headers.put(WebRequestHandler.HEADER_ACCEPT, WebRequestHandler.HEADER_ACCEPT_JSON);

    // CorrelationId is used to track the request at the Azure services
    if (mCorrelationId != null) {
      headers.put(AuthenticationConstants.AAD.CLIENT_REQUEST_ID, mCorrelationId.toString());
      headers.put(AuthenticationConstants.AAD.RETURN_CLIENT_REQUEST_ID, "true");
    }

    HttpWebResponse webResponse = null;
    String errorCodes = "";
    try {
      ClientMetrics.INSTANCE.beginClientMetricsRecord(queryUrl, mCorrelationId, headers);
      webResponse = mWebrequestHandler.sendGet(queryUrl, headers);
      if (webResponse.getResponseException() == null) {
        ClientMetrics.INSTANCE.setLastError(null);
      } else {
        ClientMetrics.INSTANCE.setLastError(String.valueOf(webResponse.getStatusCode()));
      }

      // parse discovery response to find tenant info
      HashMap<String, String> discoveryResponse = parseResponse(webResponse);
      if (discoveryResponse.containsKey(AuthenticationConstants.OAuth2.ERROR_CODES)) {
        errorCodes = discoveryResponse.get(AuthenticationConstants.OAuth2.ERROR_CODES);
        ClientMetrics.INSTANCE.setLastError(errorCodes);
      }

      return (discoveryResponse != null
          && discoveryResponse.containsKey(TENANT_DISCOVERY_ENDPOINT));
    } catch (IllegalArgumentException exc) {
      Logger.e(TAG, exc.getMessage(), "", ADALError.DEVELOPER_AUTHORITY_CAN_NOT_BE_VALIDED, exc);
      throw exc;
    } catch (JSONException e) {
      Logger.e(TAG, "Json parsing error", "", ADALError.DEVELOPER_AUTHORITY_CAN_NOT_BE_VALIDED, e);
      throw e;
    } finally {
      ClientMetrics.INSTANCE.endClientMetricsRecord(
          ClientMetricsEndpointType.INSTANCE_DISCOVERY, mCorrelationId);
    }
  }
Beispiel #19
0
 public static boolean isPermissionAllowed(String permission) {
   try {
     return A.getApp()
             .checkPermission(
                 permission, android.os.Binder.getCallingPid(), android.os.Binder.getCallingUid())
         == PackageManager.PERMISSION_GRANTED;
   } catch (Exception e) {
     Logger.e(TAG, "isPermissionAllowed(" + permission + ")", e);
     return false;
   }
 }
 @Override
 public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   addPreferencesFromResource(R.xml.preference);
   try {
     Preference prefAppVersionName = findPreference("pref_app_version_name");
     prefAppVersionName.setSummary(
         getPackageManager().getPackageInfo(getPackageName(), 0).versionName);
   } catch (Exception e) {
     Logger.e(e);
   }
 }
Beispiel #21
0
 public static byte[] loadResourceBytes(File f) {
   if (f == null || !f.isFile() || !f.exists()) return null;
   FileInputStream is = null;
   try {
     is = new FileInputStream(f);
     byte[] res = loadResourceBytes(is);
     return res;
   } catch (IOException e) {
     log.e("Cannot open file " + f);
   }
   return null;
 }
  /**
   * Submit a MeasurementTask to the scheduler. Caller of this method can broadcast an intent with
   * MEASUREMENT_ACTION to start the measurement immediately.
   */
  public boolean submitTask(MeasurementTask task) {
    try {
      // Immediately handles measurements created by user
      if (task.getDescription().priority == MeasurementTask.USER_PRIORITY) {
        return this.taskQueue.add(task);
      }

      if (taskQueue.size() >= Config.MAX_TASK_QUEUE_SIZE
          || pendingTasks.size() >= Config.MAX_TASK_QUEUE_SIZE) {
        return false;
      }
      // Automatically notifies the scheduler waiting on taskQueue.take()
      return this.taskQueue.add(task);
    } catch (NullPointerException e) {
      Logger.e("The task to be added is null");
      return false;
    } catch (ClassCastException e) {
      Logger.e("cannot compare this task against existing ones");
      return false;
    }
  }
Beispiel #23
0
 public static byte[] loadResourceBytes(InputStream is) {
   try {
     int available = is.available();
     if (available <= 0) return null;
     byte buf[] = new byte[available];
     if (is.read(buf) != available) throw new IOException("Resource not read fully");
     is.close();
     return buf;
   } catch (Exception e) {
     log.e("cannot load resource");
     return null;
   }
 }
 /** 清除缓存 */
 public static void clearCache() {
   try {
     if (IMImageLoadInstance != null) {
       IMImageLoadInstance.clearMemoryCache();
       IMImageLoadInstance.clearDiskCache();
     }
     if (null != avatarOptionsMaps) {
       avatarOptionsMaps.clear();
     }
   } catch (Exception e) {
     logger.e(e.toString());
   }
 }
  public static DisplayImageOptions getAvatarOptions(int corner, int defaultRes) {
    try {
      if (defaultRes <= 0) {
        defaultRes = R.drawable.tt_default_user_portrait_corner;
      }
      if (avatarOptionsMaps.containsKey(defaultRes)) {
        Map<Integer, DisplayImageOptions> displayOption = avatarOptionsMaps.get(defaultRes);
        if (displayOption.containsKey(corner)) {
          return displayOption.get(corner);
        }
      }
      DisplayImageOptions newDisplayOption = null;
      if (corner == CIRCLE_CORNER) {
        newDisplayOption =
            new DisplayImageOptions.Builder()
                .showImageOnFail(defaultRes)
                .showImageForEmptyUri(defaultRes)
                .cacheInMemory(true)
                .resetViewBeforeLoading(true)
                .displayer(new CircleBitmapDisplayer())
                .build();
      } else {
        if (corner < 0) {
          corner = 0;
        }
        newDisplayOption =
            new DisplayImageOptions.Builder()
                .showImageOnLoading(defaultRes)
                .showImageForEmptyUri(defaultRes)
                .showImageOnFail(defaultRes)
                .cacheInMemory(true)
                .cacheOnDisk(true)
                .considerExifParams(true)
                .imageScaleType(ImageScaleType.EXACTLY)
                .bitmapConfig(Bitmap.Config.RGB_565)
                .resetViewBeforeLoading(false)
                //                        .displayer(new FadeInBitmapDisplayer(200))
                .displayer(new RoundedBitmapDisplayer(corner))
                .build();
      }

      Map<Integer, DisplayImageOptions> cornerDisplayOptMap =
          new HashMap<Integer, DisplayImageOptions>();
      cornerDisplayOptMap.put(corner, newDisplayOption);
      avatarOptionsMaps.put(defaultRes, cornerDisplayOptMap);
      return newDisplayOption;
    } catch (Exception e) {
      logger.e(e.toString());
      return null;
    }
  }
Beispiel #26
0
  public static void displayImage(
      ImageView imageView, String resourceUri, int defaultResId, int roundPixel) {

    Logger logger = Logger.getLogger(IMUIHelper.class);

    logger.d(
        "displayimage#displayImage resourceUri:%s, defeaultResourceId:%d",
        resourceUri, defaultResId);

    if (resourceUri == null) {
      resourceUri = "";
    }

    boolean showDefaultImage = !(defaultResId <= 0);

    if (TextUtils.isEmpty(resourceUri) && !showDefaultImage) {
      logger.e("displayimage#, unable to display image");
      return;
    }

    DisplayImageOptions options;
    if (showDefaultImage) {
      options =
          new DisplayImageOptions.Builder()
              .showImageOnLoading(defaultResId)
              .showImageForEmptyUri(defaultResId)
              .showImageOnFail(defaultResId)
              .cacheInMemory(true)
              .cacheOnDisk(true)
              .considerExifParams(true)
              .displayer(new RoundedBitmapDisplayer(roundPixel))
              .imageScaleType(ImageScaleType.EXACTLY)
              . // 改善OOM
              bitmapConfig(Bitmap.Config.RGB_565)
              . // 改善OOM
              build();
    } else {
      options =
          new DisplayImageOptions.Builder()
              .cacheInMemory(true)
              .cacheOnDisk(true)
              .
              //			considerExifParams(true).
              //			displayer(new RoundedBitmapDisplayer(roundPixel)).
              //			imageScaleType(ImageScaleType.EXACTLY).// 改善OOM
              //			bitmapConfig(Bitmap.Config.RGB_565).// 改善OOM
              build();
    }

    ImageLoader.getInstance().displayImage(resourceUri, imageView, options, null);
  }
  private boolean verifySignature(final String brokerPackageName) {
    try {
      PackageInfo info =
          mContext
              .getPackageManager()
              .getPackageInfo(brokerPackageName, PackageManager.GET_SIGNATURES);

      if (info != null && info.signatures != null) {
        // Broker App can be signed with multiple certificates. It will
        // look all of them until it finds the correct one for ADAL
        // broker.
        for (Signature signature : info.signatures) {
          MessageDigest md = MessageDigest.getInstance("SHA");
          md.update(signature.toByteArray());
          String tag = Base64.encodeToString(md.digest(), Base64.NO_WRAP);

          // Company portal(Intune) app and Azure authenticator app
          // have authenticator.
          if (tag.equals(mBrokerTag)
              || tag.equals(AuthenticationConstants.Broker.AZURE_AUTHENTICATOR_APP_SIGNATURE)) {
            return true;
          }
        }
      }
    } catch (NameNotFoundException e) {
      Logger.e(
          TAG,
          "Broker related package does not exist",
          "",
          ADALError.BROKER_PACKAGE_NAME_NOT_FOUND);
    } catch (NoSuchAlgorithmException e) {
      Logger.e(TAG, "Digest SHA algorithm does not exists", "", ADALError.DEVICE_NO_SUCH_ALGORITHM);
    } catch (Exception e) {
      Logger.e(TAG, "Error in verifying signature", "", ADALError.BROKER_VERIFICATION_FAILED, e);
    }

    return false;
  }
Beispiel #28
0
 public String loadResourceUtf8(InputStream is) {
   try {
     int available = is.available();
     if (available <= 0) return null;
     byte buf[] = new byte[available];
     if (is.read(buf) != available) throw new IOException("Resource not read fully");
     is.close();
     String utf8 = new String(buf, 0, available, "UTF8");
     return utf8;
   } catch (Exception e) {
     log.e("cannot load resource");
     return null;
   }
 }
Beispiel #29
0
  public static synchronized String hashString(String data) {
    try {
      if (data == null || data.length() == 0) return "";

      if (md == null) {
        md = MessageDigest.getInstance("SHA1");
      }
      md.update(data.getBytes());
      return bytesToHex(md.digest());
    } catch (Exception e) {
      Logger.e(TAG, "hashString(" + data + ")", e);
    }
    return new String();
  }
Beispiel #30
0
 public static float getDpPixels(Context context, float pixels) {
   try {
     if (density == -1.0f) {
       DisplayMetrics metrics = context.getResources().getDisplayMetrics();
       density = metrics.density;
       densityDpi = metrics.densityDpi;
       // Logger.i(TAG, "density:" + density);
     }
     return density * pixels;
   } catch (Exception e) {
     Logger.e(TAG, "getDpPixels(" + pixels + "), e:" + e);
     e.printStackTrace();
     return pixels;
   }
 }