Java Code Examples for android.app.Activity

@Override
public void handleMessage(Message message) {
    switch (message.what) {
        case R.id.restart_preview:
            restartPreviewAndDecode();
            break;
        case R.id.decode_succeeded:
            state = State.SUCCESS;
            Bundle bundle = message.getData();

            activity.handleDecode((Result) message.obj, bundle);
            break;
        case R.id.decode_failed:
            // We're decoding as fast as possible, so when one decode fails,
            // start another.
            state = State.PREVIEW;
            cameraManager.requestPreviewFrame(decodeThread.getHandler(), R.id.decode);
            break;
        case R.id.return_scan_result:
            activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
            activity.finish();
            break;
    }
}
 

@TargetApi(Build.VERSION_CODES.M)
private void askForPermissons() {
    Activity activity = getParentActivity();
    if (activity == null) {
        return;
    }
    ArrayList<String> permissons = new ArrayList<>();
    if (activity.checkSelfPermission(Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
        permissons.add(Manifest.permission.READ_CONTACTS);
        permissons.add(Manifest.permission.WRITE_CONTACTS);
        permissons.add(Manifest.permission.GET_ACCOUNTS);
    }
    if (activity.checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        permissons.add(Manifest.permission.READ_EXTERNAL_STORAGE);
        permissons.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
    }
    String[] items = permissons.toArray(new String[permissons.size()]);
    activity.requestPermissions(items, 1);
}
 

/**
 * Sets up view for showing completed days
 * @param ctx
 */
public static void setUpDays(Activity ctx) {
    LinearLayout daysOuter = (LinearLayout) ctx.findViewById(R.id.days_outer);
    View childdays = ctx.getLayoutInflater().inflate(R.layout.days, null);

    // Setting things

    for (int i = 0; i < 7; i++) {
        final TextView dayTextView = (TextView) childdays.findViewById(AddHabitActivity.daytags[i]);
        final int currenti = i;
        if (AddHabitActivity.days[i] == 1) {
            dayTextView.setBackground(ctx.getDrawable(R.drawable.days_border_valid));
        }

    }

    LinearLayout daysInner = (LinearLayout) childdays.findViewById(R.id.days_inner);
    daysInner.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
            ViewGroup.LayoutParams.WRAP_CONTENT));

    daysOuter.addView(childdays);

}
 

/**
 * 调用系统安装了的应用分享
 *
 * @param context
 * @param title
 * @param url
 */
public static void showSystemShareOption(Activity context,
                                         final String title, final String url) {
    Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setType("text/plain");
    intent.putExtra(Intent.EXTRA_SUBJECT, "分享：" + title);
    intent.putExtra(Intent.EXTRA_TEXT, title + " " + url);
    context.startActivity(Intent.createChooser(intent, "选择分享"));
}
 

@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
    Activity activity = getActivity();

    if (key.equals(getString(R.string.pref_location_key))) {
        // we've changed the location
        // Wipe out any potential PlacePicker latlng values so that we can use this text entry.
        SunshinePreferences.resetLocationCoordinates(activity);
    } else if (key.equals(getString(R.string.pref_units_key))) {
        // units have changed. update lists of weather entries accordingly
        activity.getContentResolver().notifyChange(WeatherContract.WeatherEntry.CONTENT_URI, null);
    }
    Preference preference = findPreference(key);
    if (null != preference) {
        if (!(preference instanceof CheckBoxPreference)) {
            setPreferenceSummary(preference, sharedPreferences.getString(key, ""));
        }
    }
}
 

@TargetApi(Build.VERSION_CODES.KITKAT)
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
    super.onActivityResult(requestCode, resultCode, intent);
    if(requestCode==READ_REQUEST_CODE) {
        if (resultCode == Activity.RESULT_OK) {

            //Set directory as default in preferences
            Uri treeUri = intent.getData();
            //grant write permissions
            getActivity().getContentResolver().takePersistableUriPermission(treeUri, Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
            mCurrentDirectory = treeUri;
            listFiles(false);
            getLoaderManager().restartLoader(0, null, this);

        } else displayFailPage();
    }
}
 

/**
 * 获取图片成功后进行处理
 *
 * @param imagePath 图片路径
 */
private void resultImage(String imagePath) {
    Bitmap bitmap;
    if (!TextUtils.isEmpty(imagePath)) {
        bitmap = ImageUtil.getImageThumbnail(imagePath, IMAGE_MAX_SIZE, IMAGE_MAX_SIZE);
        String filePath = new File(SDUtil.getFileDir(), "temp2.jpg").getAbsolutePath();

        ImageUtil.saveImage(bitmap, filePath, 50);
        // deleteTempPicture();
        Logger.d("处理图片" + filePath);

        Intent resultIntent = new Intent();
        resultIntent.putExtra(IMAGE_PATH, filePath);
        setResult(Activity.RESULT_OK, resultIntent);
        GetPictureActivity.this.finish();

    } else {
        //没有获取到文件的路径
        ToastUtil.showShort("图片获取失败");

        setResult(Activity.RESULT_CANCELED);
        finish();
    }
}
 

@Override
public void onJumpToNavigator() {
	/*
	 * 设置途径点以及resetEndNode会回调该接口
	 */

	for (Activity ac : activityList) {

		if (ac.getClass().getName().endsWith("BNDemoGuideActivity")) {

			return;
		}
	}
	Intent intent = new Intent(MainActivity.this,
			BNDemoGuideActivity.class);
	Bundle bundle = new Bundle();
	bundle.putSerializable(ROUTE_PLAN_NODE, mBNRoutePlanNode);
	intent.putExtras(bundle);
	startActivity(intent);

}
 

@Override public void onActivityDestroyed(Activity activity) {
  if (!activity.isChangingConfigurations()) {
    // Activity will be destroyed permanently, so reset the cache
    String activityId = activityIdMap.get(activity);
    if (activityId != null) {
      ActivityScopedCache scopedCache = activityScopedCacheMap.get(activityId);
      if (scopedCache != null) {
        scopedCache.clear();
        activityScopedCacheMap.remove(activityId);
      }

      // No Activity Scoped cache available, so unregister
      if (activityScopedCacheMap.isEmpty()) {
        // All Mosby related activities are destroyed, so we can remove the activity lifecylce listener
        activity.getApplication()
            .unregisterActivityLifecycleCallbacks(activityLifecycleCallbacks);
        if (DEBUG) {
          Log.d(DEBUG_TAG, "Unregistering ActivityLifecycleCallbacks");
        }
      }
    }
  }
  activityIdMap.remove(activity);
}
 

public static StorageRoot[] loadRoots(Activity context) {
    ArrayList<StorageRoot> temp = new ArrayList<>();

    StorageRoot externalStorage = new StorageRoot(
            Environment.getExternalStorageDirectory().getPath());
    externalStorage.setName(context.getString(R.string.storage));
    temp.add(externalStorage);

    File[] removableStorageRoots = getRemovableStorageRoots(context);
    for (int i = 0; i < removableStorageRoots.length; i++) {
        temp.add(new StorageRoot(removableStorageRoots[i].getPath()));
    }

    StorageRoot[] roots = new StorageRoot[temp.size()];
    return temp.toArray(roots);
}
 

public void onClick(View v) {
    new Builder(CustomSportListAdapter.this.context).setMessage("确定要删除吗？")
            .setPositiveButton("删除", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            if (CustomSportListAdapter.this.data != null) {
                FoodApi.deleteCustomActivities(((CustomSport) CustomSportListAdapter.this
                        .data.get(DelListener.this.position)).id, CustomSportListAdapter
                        .this.context, new JsonCallback((Activity) CustomSportListAdapter
                        .this.context) {
                    public void onFinish() {
                        super.onFinish();
                    }

                    public void ok(JSONObject object) {
                        super.ok(object);
                        CustomSportListAdapter.this.remove(DelListener.this.position);
                        CustomSportListAdapter.this.notifyDataSetChanged();
                    }
                });
            }
        }
    }).setNegativeButton("取消", null).show();
}
 

@Override
protected void onBubbleClick() {
    String filePath = fileMessageBody.getLocalUrl();
    File file = new File(filePath);
    if (file.exists()) {
        // open files if it exist
        FileUtils.openFile(file, (Activity) context);
    } else {
        // download the file
        context.startActivity(new Intent(context, EaseShowNormalFileActivity.class).putExtra("msg", message));
    }
    if (message.direct() == EMMessage.Direct.RECEIVE && !message.isAcked() && message.getChatType() == ChatType.Chat) {
        try {
            EMClient.getInstance().chatManager().ackMessageRead(message.getFrom(), message.getMsgId());
        } catch (HyphenateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}
 

private void forgotPsw() {
    SharedPreferences sp = getSharedPreferences(PREFERENCES_NAME, Activity.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.clear();
    editor.commit();
    ed_acc.setText("");
    ed_psw.setText("");
    Toast.makeText(MainActivity.this, "已清除缓存", Toast.LENGTH_SHORT).show();
}
 

public static void setLastCapturedImagePathFromOneSheeldFolder(String lastCapturedImagePathFromOneSheeldFolder,Activity activity) {
    sharedPreferences = activity.getSharedPreferences("camera",Context.MODE_PRIVATE);
    if (lastCapturedImagePathFromOneSheeldFolder != null) {
        File tmpImage = new File(lastCapturedImagePathFromOneSheeldFolder);
        if (tmpImage.exists()) {
            CameraUtils.lastCapturedImagePathFromOneSheeldFolder = lastCapturedImagePathFromOneSheeldFolder;
            editor = sharedPreferences.edit();
            editor.putString(sharedPreferencesKey,lastCapturedImagePathFromOneSheeldFolder);
            editor.commit();
        }
    }
}
 

@TargetApi(Build.VERSION_CODES.M)
private void executePermissionsRequest() {
    checkObjectsValid(mObject);
    if (mObject instanceof Activity) {
        ActivityCompat.requestPermissions((Activity) mObject, mPermissions, mRequestPermissionCode);
    } else if (mObject instanceof android.support.v4.app.Fragment) {
        ((android.support.v4.app.Fragment) mObject).requestPermissions(mPermissions, mRequestPermissionCode);
    } else if (mObject instanceof android.app.Fragment) {
        ((android.app.Fragment) mObject).requestPermissions(mPermissions, mRequestPermissionCode);
    }
}
 

@Override
public void shareMusic(int shareTarget, Activity activity, ShareObj obj) {
    if (shareTarget == Target.SHARE_QQ_FRIENDS) {
        Bundle params = buildCommonBundle(obj.getTitle(), obj.getSummary(), obj.getTargetUrl(), shareTarget);
        params.putInt(QQShare.SHARE_TO_QQ_KEY_TYPE, QQShare.SHARE_TO_QQ_TYPE_AUDIO);
        if (!TextUtils.isEmpty(obj.getThumbImagePath()))
            params.putString(QQShare.SHARE_TO_QQ_IMAGE_URL, obj.getThumbImagePath());
        params.putString(QQShare.SHARE_TO_QQ_AUDIO_URL, obj.getMediaPath());
        mTencentApi.shareToQQ(activity, params, mIUiListenerWrap);
    } else if (shareTarget == Target.SHARE_QQ_ZONE) {
        shareWeb(shareTarget, activity, obj);
    }
}
 

/**
 * Creates a new {@link android.view.ViewTreeObserver.OnGlobalLayoutListener} that attempts to calculate the keyboard size.
 * Note that this does not guarantee that a software keyboard is present, it's just a best effort detection attempt.
 * Also note that, although it's not guaranteed to work with all keyboards in all situations, this was tested against top 20 keyboards from the store and
 * had no issues detecting the changes.
 *
 * @param with    What to subscribe with (cannot be {@code null})
 * @param context The Activity context to use (cannot be {@code null})
 * @return A new instance of the layout listener. Note that this won't do anything until you attach the returned instance to the global layout by invoking
 * {@link View#getViewTreeObserver()} and then {@link ViewTreeObserver#addOnGlobalLayoutListener(ViewTreeObserver.OnGlobalLayoutListener)} on the
 * Activity's root layout, passing in the listener instance returned from this method. You also need to manually detach the listener when done listening.
 * The best practice is to do it with the {@link Activity#onStart()} and {@link Activity#onStop()} lifecycle methods.
 */
@NonNull
public static ViewTreeObserver.OnGlobalLayoutListener listenToKeyboard(@NonNull final OnKeyboardChangeListener with, @NonNull final Activity context) {
    return new ViewTreeObserver.OnGlobalLayoutListener() {
        private boolean isKeyboardVisible;

        @Override
        public void onGlobalLayout() {
            final int statusBarHeight = UI.getStatusBarHeight(context);
            final int navigationBarHeight = UI.getNavigationBarHeight(context);

            // check the display window size for the app layout
            final Rect rect = new Rect();
            context.getWindow().getDecorView().getWindowVisibleDisplayFrame(rect);

            // screen height - (user app height + status + nav) -> if non-zero, then there is a soft keyboard
            final ViewGroup layout = SillyAndroid.getContentView(context);
            if (layout == null) {
                throw new IllegalArgumentException("Passed Activity needs to have its content view set before attaching this listener");
            }
            final int keyboardHeight = layout.getRootView().getHeight() - (statusBarHeight + navigationBarHeight + rect.height());

            if (keyboardHeight <= 0) {
                if (isKeyboardVisible) {
                    with.onKeyboardHidden();
                    isKeyboardVisible = false;
                }
            } else {
                if (!isKeyboardVisible) {
                    with.onKeyboardShown(keyboardHeight);
                    isKeyboardVisible = true;
                }
            }
        }
    };
}
 

@TargetApi(23)
private static boolean shouldShowRequestPermissionRationale(Object object, String perm) {
    if (object instanceof Activity) {
        return ActivityCompat.shouldShowRequestPermissionRationale((Activity) object, perm);
    } else if (object instanceof Fragment) {
        return ((Fragment) object).shouldShowRequestPermissionRationale(perm);
    } else if (object instanceof android.app.Fragment) {
        return ((android.app.Fragment) object).shouldShowRequestPermissionRationale(perm);
    } else {
        return false;
    }
}
 

public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
	if (fromUser) {

		final AudioManager manager = (AudioManager) mActivity.getSystemService(Activity.AUDIO_SERVICE);
		final int index = (Integer) seekBar.getTag();
		final int streamType = STREAM_TYPES[index];
		
		// update view
		final TextView valueView = mValueViews[index];
		valueView.setText(progress + "/" + manager.getStreamMaxVolume(streamType));
		
		//Log.d(TAG, "onProgressChanged: index: " + index + ", value: " + progress + ", seekbar: " + seekBar);
	}
}
 

public void glideLoadImages(int image, ImageView[] iv)
{
    Activity activity = MainActivity.this;

    for (ImageView imgview : iv)
    {
        Glide.with(activity).load(image).into(imgview);
    }
    return;
}
 

public void onCreate() {
    _logger.Debug("onCreate");

    _screenEnabled = true;

    _conditionTextView = ((Activity) _context).findViewById(R.id.weatherConditionTextView);
    _temperatureTextView = ((Activity) _context).findViewById(R.id.weatherTemperatureTextView);
    _humidityTextView = ((Activity) _context).findViewById(R.id.weatherHumidityTextView);
    _pressureTextView = ((Activity) _context).findViewById(R.id.weatherPressureTextView);
    _updatedTimeTextView = ((Activity) _context).findViewById(R.id.weatherUpdateTextView);
    _conditionImageView = ((Activity) _context).findViewById(R.id.weatherConditionImageView);
}
 

public static void returnFromFragment(final Fragment fragment){
	final Activity activity=fragment.getActivity();
	if (activity!=null){
		final FragmentManager fragmentManager=activity.getFragmentManager();
		if (fragmentManager!=null) {
			fragmentManager.popBackStack();
		}
	}
}
 

public static void update(final Activity act, final MenuItem menu, IIcon icon, int badgeCount) {
    if (badgeCount == Integer.MIN_VALUE) {
        update(act, menu, new IconicsDrawable(act, icon).color(Color.WHITE).actionBar(), BadgeStyles.DARK_GREY.getStyle(), null);
    } else {
        update(act, menu, new IconicsDrawable(act, icon).color(Color.WHITE).actionBar(), BadgeStyles.DARK_GREY.getStyle(), String.valueOf(badgeCount));
    }
}
 

@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
    if (mBlurEngine != null) {
        mBlurEngine.onAttach(activity); // re attached
    }
}
 

public boolean prepareDialog() {

		// local cache
		final AudioManager manager = (AudioManager) mActivity.getSystemService(Activity.AUDIO_SERVICE);
		final SeekBar[] seekBars = mSeekBars;
		final TextView[] valueViews = mValueViews;
		final int[] volumes = mVolumes;
		final int length = seekBars.length;
		final int[] streamTypes = STREAM_TYPES;
		
		for (int i=0; i<length; i++) {
			
			// get value and max value
			int volume = manager.getStreamVolume(streamTypes[i]);
			int max = manager.getStreamMaxVolume(streamTypes[i]);
			
			// update values
			final TextView valueView = valueViews[i];
			valueView.setText(volume + "/" + max);
			
			// update seekbar
			SeekBar seekBar = seekBars[i];
			seekBar.setMax(max);
			seekBar.setProgress(volume);
			
			volumes[i] = volume; // store initial volume
			
			//Log.d(TAG, "prepare: index: " + i + ", value: " + volume + ", max: " + max + ", seekbar: " + seekBar);
		}
		return true;
	}
 

/**
 * Clear focus from the current view and hide the soft keyboard.
 * @param activity the current activity
 */
public static void defocusAndHideKeyboard(@Nullable Activity activity) {
    if (activity == null) return;
    View view = activity.getCurrentFocus();
    if (view != null) {
        view.clearFocus();
        hideKeyboard(activity, view.getWindowToken());
    }
}
 

@Override
public void handleMessage(Message message) {
    if (message.what == R.id.auto_focus) {
        //Log.d(TAG, "Got auto-focus message");
        // When one auto focus pass finishes, start another. This is the closest thing to
        // continuous AF. It does seem to hunt getUrl bit, but I'm not sure what else to do.
        if (state == State.PREVIEW) {
            CameraManager.get().requestAutoFocus(this, R.id.auto_focus);
        }
    } else if (message.what == R.id.restart_preview) {
        Log.d(TAG, "Got restart preview message");
        restartPreviewAndDecode();
    } else if (message.what == R.id.decode_succeeded) {
        Log.d(TAG, "Got decode succeeded message");
        state = State.SUCCESS;
        Bundle bundle = message.getData();

        /***********************************************************************/
        Bitmap barcode = bundle == null ? null :
                (Bitmap) bundle.getParcelable(DecodeThread.BARCODE_BITMAP);//���ñ����߳�

        activity.handleDecode((Result) message.obj, barcode);//���ؽ��
        /***********************************************************************/
    } else if (message.what == R.id.decode_failed) {
        // We're decoding as fast as possible, so when one decode fails, start another.
        state = State.PREVIEW;
        CameraManager.get().requestPreviewFrame(decodeThread.getHandler(), R.id.decode);
    } else if (message.what == R.id.return_scan_result) {
        Log.d(TAG, "Got return scan result message");
        activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
        activity.finish();
    } else if (message.what == R.id.launch_product_query) {
        Log.d(TAG, "Got product query message");
        String url = (String) message.obj;
        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
        activity.startActivity(intent);
    }
}
 

/**
 * Show dialog
 * @param context Context
 * @param title Title
 * @param layoutResource Layout resource id
 * @param iconResource Icon resource id
 * @return AlertDialog Dialog
 */
static AlertDialog showAlert(Context context, CharSequence title, int layoutResource, int iconResource) {
    @SuppressLint("InflateParams")
    View view = ((Activity) context).getLayoutInflater().inflate(layoutResource, null, false);
    AlertDialog alertDialog = new AlertDialog.Builder(context).create();
    alertDialog.setTitle(title);
    alertDialog.setView(view);
    if (iconResource > 0) {
        alertDialog.setIcon(iconResource);
    }
    alertDialog.show();
    return alertDialog;
}
 

public void setUpTest() throws Exception {
    // Mockito has a very convenient way to inject mocks by using the @Mock annotation. To
    // inject the mocks in the test the initMocks method needs to be called.
    MockitoAnnotations.initMocks(this);

    mContext = mock(Activity.class);
}
 

public static void launchLiveLunbo(Context context, int launchMode, String eName, boolean isLow, String programName, String cName, String channelId, String channelNum, boolean isFull) {
    setClickForPlayPageTime();
    Intent intent = new Intent(context, BasePlayActivity.class);
    intent.putExtra(PlayConstant.PLAY_TYPE, 1);
    intent.putExtra("launchMode", launchMode);
    intent.putExtra("code", eName);
    intent.putExtra(PlayConstant.LIVE_IS_LOW, isLow);
    intent.putExtra(PlayConstant.LIVE_PROGRAM_NAME, programName);
    intent.putExtra(PlayConstant.LIVE_CHANNEL_NAME, cName);
    intent.putExtra(PlayConstant.LIVE_CHANNEL_ID, channelId);
    intent.putExtra(PlayConstant.LIVE_CHANNEL_LUNBO_NUMBER, channelNum);
    intent.putExtra(PlayConstant.LIVE_FULL_ONLY, isFull);
    intent.putExtra("from", 18);
    intent.addFlags(536870912);
    Bundle bundle = new Bundle();
    bundle.putString(PlayConstant.LIVE_LAUCH_METHOD, "launchLiveLunbo");
    bundle.putString("code", eName);
    bundle.putString(PlayConstant.LIVE_PROGRAM_NAME, programName);
    bundle.putString(PlayConstant.LIVE_CHANNEL_NAME, cName);
    bundle.putString(PlayConstant.LIVE_CHANNEL_ID, channelId);
    bundle.putString(PlayConstant.LIVE_CHANNEL_LUNBO_NUMBER, channelNum);
    bundle.putBoolean(PlayConstant.LIVE_FULL_ONLY, isFull);
    LetvApplication.getInstance().setLiveLunboBundle(bundle);
    LetvLogApiTool.createPlayLogInfo("LiveLunboVideoClickPlayStart", NetworkUtils.DELIMITER_LINE, "ename=" + eName + " programName=" + programName + " isLow=" + isLow);
    if (!(context instanceof Activity)) {
        intent.addFlags(268435456);
    }
    context.startActivity(intent);
}
 

@Override
public void goToSuccessOrderActivity(){
    Intent i = new Intent( this, SuccessOrderActivity.class );
    startActivity( i );
    setResult( Activity.RESULT_OK );
    finish();
}
 

/**
 * 打开网络设置界面 WIFI/流量
 *
 * @param activity
 * @param i 0:WIFI/1:流量
 */
public void openSetting(Activity activity, int i) {
    if (i == ACTION_WIFI_SETTINGS) {
        //WIFI
        activity.startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
    } else if (i == ACTION_DATA_ROAMING_SETTINGS) {
        //流量
        activity.startActivity(new Intent(
                android.provider.Settings.ACTION_DATA_ROAMING_SETTINGS));
    }
}
 

private static void doShowTapTargetSequenceFor(@NonNull final Activity activity, @NonNull final List<TapTarget> targets, @Nullable final TapTargetSequence.Listener listener) {
    new Handler().postDelayed(new Runnable() {
        @Override
        public void run() {
            new TapTargetSequence(activity)
                    .targets(targets)
                    .listener(listener)
                    .start();
        }
    }, DELAY);
}
 

/**
 * get image by zoom
 */
public void pick(String path) {
    if (mDestroied) return;

    if(path != null){
        File file = new File(path);
        if(!file.exists()){
            throw new RuntimeException("file not exit, path = " + path);
        }
        mGalleryFile = file;
    }

    final Activity activity = getActivity();

    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.setType("image/*");
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {//如果大于等于7.0使用FileProvider
        intent.putExtra(MediaStore.EXTRA_OUTPUT, getUriForFile(mGalleryFile));
        intent.addFlags(FLAG_GRANT_WRITE_URI_PERMISSION);
        intent.addFlags(FLAG_GRANT_READ_URI_PERMISSION);
        activity.startActivityForResult(intent, SELECT_PIC_NOUGAT);
    } else {
        //intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mGalleryFile));
        activity.startActivityForResult(intent, IMAGE_REQUEST_CODE);
    }
}
 

public DensityTweak(Activity activity) {
    mActivity = activity;
    mPrefs = PreferenceManager.getDefaultSharedPreferences(activity);
    mIsActualLeanbackDevice = mActivity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_LEANBACK);

    DensityChoices = new CharSequence[DensityChoiceIds.length];
    for (int i=0; i<DensityChoiceIds.length; i++) {
        DensityChoices[i] = mActivity.getString(DensityChoiceIds[i]);
    }
}
 

public static void rotateOrientation(Activity activity) {
    int currentOrientation = activity.getResources().getConfiguration().orientation;

    switch (currentOrientation) {
        case Configuration.ORIENTATION_LANDSCAPE:
            rotateToPortrait(activity);
            break;
        case Configuration.ORIENTATION_PORTRAIT:
            rotateToLandscape(activity);
            break;
        default:
            rotateToLandscape(activity);
    }
}
 

@TargetApi(Build.VERSION_CODES.KITKAT)
public static boolean isTranslucentStatus(final Activity activity) {
    //noinspection SimplifiableIfStatement
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        return (activity.getWindow().getAttributes().flags &
                WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS) != 0;
    }
    return false;
}
 

public static void makeAllProgressBarsIdle(Instrumentation instrumentation, final Activity activity) {
    instrumentation.runOnMainSync(new Runnable() {
        public void run() {
            makeAllProgressBarsIdle(activity.findViewById(android.R.id.content).getRootView());
        }
    });
}
 

public static void hideSoftkeyboard(Activity mActivity) {
    if (mActivity != null && mActivity.getCurrentFocus() != null) {
        InputMethodManager mInputMethodManager = (InputMethodManager) mActivity.getSystemService("input_method");
        if (mInputMethodManager != null) {
            mInputMethodManager.hideSoftInputFromWindow(mActivity.getCurrentFocus().getWindowToken(), 2);
        }
    }
}
 

public void removeCurrentView(final Context context) {
    final Activity activity = (Activity) context;
    activity.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            activity.setContentView(main.getRootView());
        }
    });
}
 

/**
 * Method to build the builder for sharing
 *
 * @param activity - The activity in which the share has to be triggered
 */
public void shareApp(Activity activity){
    ShareCompat.IntentBuilder
            .from(activity)
            .setType(mMimeType)
            .setChooserTitle(mShareTitle)
            .setText(mShareContent)
            .startChooser();
}
 

@Override
protected String getMessageForEnablingOsGlobalPermission(Activity activity) {
    Resources resources = activity.getResources();
    if (enabledForChrome(activity)) {
        return resources.getString(R.string.android_location_off_globally);
    }
    return resources.getString(R.string.android_location_also_off_globally);
}
 

private static void shouldShowRationale(final Activity activity, final String requestPermission) {
    showMessageOKCancel(activity, "Rationale: " + "没有此权限，无法开启这个功能，请开启权限。"+requestPermission, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            ActivityCompat.requestPermissions(activity,
                    new String[]{requestPermission},
                    0);
            Log.d(TAG, "showMessageOKCancel requestPermissions:" + requestPermission);
        }
    });
}
 

/**
 * @param activity
 * @param delegate
 */
public BGASwipeBackHelper(Activity activity, Delegate delegate) {
    mActivity = activity;
    mDelegate = delegate;

    initSwipeBackFinish();
}
 

@Override
public void fetchFilePathFromIntent(int requestCode, int resultCode, Intent data) {

    LogUtils.i(TAG, "request:" + requestCode + "  result:" + resultCode + "  data:" + data);
    if (REQUEST_CODE != requestCode)
        return;

    if (resultCode == Activity.RESULT_CANCELED) {
        cancel();
        return;
    }

    if (resultCode == Activity.RESULT_OK) {

        if (isL)
            handleAboveL(cameraState ? new Uri[]{data.getParcelableExtra(ActionActivity.KEY_URI)} : processData(data));
        else if (jsChannel)
            convertFileAndCallBack(cameraState ? new Uri[]{data.getParcelableExtra(ActionActivity.KEY_URI)} : processData(data));
        else {
            if (cameraState && mUriValueCallback != null)
                mUriValueCallback.onReceiveValue((Uri) data.getParcelableExtra(ActionActivity.KEY_URI));
            else
                handleBelowLData(data);
        }

    }


}
 

void restoreSystemVisibility(Activity activity) {
    if (mRestoreSystemVisibility) {
        FrameLayout decor = (FrameLayout) activity.getWindow().getDecorView();
        // In some cases we come out of fullscreen before closing this dialog. In these
        // cases we don't want to restore the system UI visibility state.
        int systemVisibility = decor.getSystemUiVisibility();
        if ((systemVisibility & View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) != 0) {
            decor.setSystemUiVisibility(mSystemVisibility);
        }
    }
}
 

protected DefaultWebCreator(@NonNull Activity activity, @Nullable ViewGroup viewGroup, ViewGroup.LayoutParams lp, int index, @Nullable WebView webView,IWebLayout webLayout) {
    this.mActivity = activity;
    this.mViewGroup = viewGroup;
    this.isNeedDefaultProgress = false;
    this.index = index;
    this.mLayoutParams = lp;
    this.mWebView = webView;
    this.mIWebLayout=webLayout;
}
 

/**
 * 添加Activity到堆栈
 */
public void addActivity(Activity activity) {
    if (activityStack == null) {
        activityStack = new Stack<>();
    }

    if (!activityStack.contains(activity)) {
        activityStack.add(activity);
    }
}
 

/**
 * Generates the unique (mosby internal) viewState id and calls {@link
 * MviDelegateCallback#createPresenter()}
 * to create a new presenter instance
 *
 * @return The new created presenter instance
 */
private P createViewIdAndCreatePresenter() {

  P presenter = delegateCallback.createPresenter();
  if (presenter == null) {
    throw new NullPointerException(
        "Presenter returned from createPresenter() is null. Fragment is " + fragment);
  }
  if (keepPresenterDuringScreenOrientationChange || keepPresenterOnBackstack) {
    Activity activity = getActivity();
    mosbyViewId = UUID.randomUUID().toString();
    PresenterManager.putPresenter(activity, mosbyViewId, presenter);
  }
  return presenter;
}
 

@Override
public void completeFirstRunExperience() {
    FirstRunStatus.setLightweightFirstRunFlowComplete(true);
    Intent intent = new Intent();
    intent.putExtras(mFreProperties);
    finishAllTheActivities(getLocalClassName(), Activity.RESULT_OK, intent);

    sendPendingIntentIfNecessary(true);
}
 

/**
 * 分割短信, 并发送 权限
 * <uses-permission android:name="android.permission.SEND_SMS"/>
 * <uses-permission android:name="android.permission.READ_SMS" />
 * <uses-permission android:name="android.permission.RECEIVE_SMS" />
 */
public static void sendSMS(final Context context, final String number, final String msg) {
    SmsManager smsManager = SmsManager.getDefault();
    if (smsManager == null || !checkPermission(context, Manifest.permission.SEND_SMS)) {
        sendSMSTo(context, number, msg);
        return;
    }
    PendingIntent sentIntent = PendingIntent.getBroadcast(context, 0, new Intent("SENT_SMS_ACTION"), 0);
    ArrayList<String> texts = smsManager.divideMessage(msg);// 分割短信
    for (String text : texts) {
        smsManager.sendTextMessage(number, null, text, sentIntent, null);
    }

    context.registerReceiver(new BroadcastReceiver() {
        @Override
        public void onReceive(Context _context, Intent _intent) {
            switch (getResultCode()) {
                case Activity.RESULT_OK:
                    MessageInfo.MsgToast(context, "短信发送成功");
                    break;
                case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
                    MessageInfo.MsgToast(context, "短信发送失败,一般错误原因");
                    break;
                case SmsManager.RESULT_ERROR_RADIO_OFF:
                    MessageInfo.MsgToast(context, "短信发送失败,无线发送信号被关闭");
                    break;
                case SmsManager.RESULT_ERROR_NULL_PDU:
                    MessageInfo.MsgToast(context, "短信发送失败,没有提供数据单元");
                    break;
                case SmsManager.RESULT_ERROR_NO_SERVICE:
                    MessageInfo.MsgToast(context, "短信发送失败,当前没有获得可用的服务");
                    break;
            }
            if (getResultCode() != Activity.RESULT_OK) {
                sendSMSTo(context, number, msg);
            }
        }
    }, new IntentFilter("SENT_SMS_ACTION"));
}
 

private WindowManager.LayoutParams getActionBarLayoutParams(Context context) {
    Rect rect = new Rect();
    ((Activity) context).getWindow().getDecorView().getWindowVisibleDisplayFrame(rect);
    int statusBarHeight = rect.top;
    WindowManager.LayoutParams params = new WindowManager.LayoutParams(-1, -2, 2, 264, -3);
    params.gravity = 48;
    params.x = 0;
    params.y = statusBarHeight;
    return params;
}
 

public InactivityTimer(Activity activity) {
    this.activity = activity;
    powerStatusReceiver = new PowerStatusReceiver();
    registered = false;
    onActivity();
}
 

public void testStart() throws Exception {
    Activity activity = getActivity();
}
 

void finish()
{
    ((Activity) mAppContext).finish();
}
 

@Override
public void callActivityOnCreate(Activity activity, Bundle icicle) {
	base.callActivityOnCreate(activity, icicle);
}
 

public EditListAdapter(Activity activity, ArrayList<String[]> words) {
    this.activity = activity;
    this.ExtraWord = words;
}
 

static String selectedItem(Activity activity, String[] who, int where, ArrayList<String> column) {

        //create the notes db
        SQLiteDatabase notesDB = activity.openOrCreateDatabase("notesDB", MODE_PRIVATE, null);

        Cursor notesCursor = notesDB.rawQuery("SELECT * FROM " + who[0], null);

        String selected = "";

        if (notesCursor != null && notesCursor.moveToFirst()) {

            while (!notesCursor.isAfterLast()) {

                //get items at selected position
                selected = column.get(where);
                notesCursor.moveToNext();
            }
            notesCursor.close();
        }

        notesDB.close();

        return selected;
    }
 

protected ExtendedAsyncTask(Activity activity) {
    mActivity = activity;
    mContext = activity.getApplicationContext();
}
 

@Override
public AndroidInjector<Activity> activityInjector() {
    return activityInjector;
}