Example usage for android.media ExifInterface getAttributeInt

List of usage examples for android.media ExifInterface getAttributeInt

Introduction

In this page you can find the example usage for android.media ExifInterface getAttributeInt.

Prototype

public int getAttributeInt(String tag, int defaultValue) 

Source Link

Document

Returns the integer value of the specified tag.

Usage

From source file:com.netcompss.ffmpeg4android_client.BaseWizard.java

@SuppressWarnings("unused")
private String reporteds(String path) {

    ExifInterface exif = null;
    try {//  w  w w .j a va 2 s. com
        exif = new ExifInterface(path);
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
    Matrix matrix = new Matrix();
    if (orientation == 6) {
        matrix.postRotate(90);
    } else if (orientation == 3) {
        matrix.postRotate(180);
    } else if (orientation == 8) {
        matrix.postRotate(270);
    }

    if (path != null) {

        if (path.contains("http")) {
            try {
                URL url = new URL(path);
                HttpGet httpRequest = null;

                httpRequest = new HttpGet(url.toURI());

                HttpClient httpclient = new DefaultHttpClient();
                HttpResponse response = (HttpResponse) httpclient.execute(httpRequest);

                HttpEntity entity = response.getEntity();
                BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(entity);
                InputStream input = bufHttpEntity.getContent();

                Bitmap bitmap = BitmapFactory.decodeStream(input);
                input.close();
                return getPath(bitmap);
            } catch (MalformedURLException e) {
                Log.e("ImageActivity", "bad url", e);
            } catch (Exception e) {
                Log.e("ImageActivity", "io error", e);
            }
        } else {
            Options options = new Options();
            options.inSampleSize = 2;
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeResource(getApplicationContext().getResources(), srcBgId, options);
            options.inJustDecodeBounds = false;
            options.inSampleSize = calculateInSampleSize(options, w, h);
            Bitmap unbgbtmp = BitmapFactory.decodeResource(getApplicationContext().getResources(), srcBgId,
                    options);
            Bitmap unrlbtmp = ScalingUtilities.decodeFile(path, w, h, ScalingLogic.FIT);
            unrlbtmp.recycle();
            Bitmap rlbtmp = null;
            if (unrlbtmp != null) {
                rlbtmp = ScalingUtilities.createScaledBitmap(unrlbtmp, w, h, ScalingLogic.FIT);
            }
            if (unbgbtmp != null && rlbtmp != null) {
                Bitmap bgbtmp = ScalingUtilities.createScaledBitmap(unbgbtmp, w, h, ScalingLogic.FIT);
                Bitmap newscaledBitmap = ProcessingBitmapTwo(bgbtmp, rlbtmp);
                unbgbtmp.recycle();
                return getPath(newscaledBitmap);
            }
        }
    }
    return path;

}

From source file:com.klinker.android.twitter.activities.compose.Compose.java

private Bitmap getThumbnail(Uri uri) throws FileNotFoundException, IOException {
    InputStream input = getContentResolver().openInputStream(uri);
    int reqWidth = 150;
    int reqHeight = 150;

    byte[] byteArr = new byte[0];
    byte[] buffer = new byte[1024];
    int len;/*w  w  w .  j a  va  2s  .c  om*/
    int count = 0;

    try {
        while ((len = input.read(buffer)) > -1) {
            if (len != 0) {
                if (count + len > byteArr.length) {
                    byte[] newbuf = new byte[(count + len) * 2];
                    System.arraycopy(byteArr, 0, newbuf, 0, count);
                    byteArr = newbuf;
                }

                System.arraycopy(buffer, 0, byteArr, count, len);
                count += len;
            }
        }

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        options.inPurgeable = true;
        options.inInputShareable = true;
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;

        Bitmap b = BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        ExifInterface exif = new ExifInterface(IOUtils.getPath(uri, context));
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_UNDEFINED);

        b = ImageUtils.cropSquare(b);

        return rotateBitmap(b, orientation);

    } catch (Exception e) {
        e.printStackTrace();

        return null;
    }
}

From source file:com.daiv.android.twitter.ui.compose.Compose.java

private Bitmap getThumbnail(Uri uri) throws IOException {
    InputStream input = getContentResolver().openInputStream(uri);
    int reqWidth = 150;
    int reqHeight = 150;

    byte[] byteArr = new byte[0];
    byte[] buffer = new byte[1024];
    int len;//  w  ww  .j a v  a  2s .  c o m
    int count = 0;

    try {
        while ((len = input.read(buffer)) > -1) {
            if (len != 0) {
                if (count + len > byteArr.length) {
                    byte[] newbuf = new byte[(count + len) * 2];
                    System.arraycopy(byteArr, 0, newbuf, 0, count);
                    byteArr = newbuf;
                }

                System.arraycopy(buffer, 0, byteArr, count, len);
                count += len;
            }
        }

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        options.inPurgeable = true;
        options.inInputShareable = true;
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;

        Bitmap b = BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        ExifInterface exif = new ExifInterface(IOUtils.getPath(uri, context));
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_UNDEFINED);

        b = ImageUtils.cropSquare(b);

        return rotateBitmap(b, orientation);

    } catch (Exception e) {
        e.printStackTrace();

        return null;
    }
}

From source file:com.daiv.android.twitter.ui.compose.Compose.java

public Bitmap getBitmapToSend(Uri uri) throws IOException {
    InputStream input = getContentResolver().openInputStream(uri);
    int reqWidth = 750;
    int reqHeight = 750;

    byte[] byteArr = new byte[0];
    byte[] buffer = new byte[1024];
    int len;/* w  ww . j a va 2s  . co  m*/
    int count = 0;

    try {
        while ((len = input.read(buffer)) > -1) {
            if (len != 0) {
                if (count + len > byteArr.length) {
                    byte[] newbuf = new byte[(count + len) * 2];
                    System.arraycopy(byteArr, 0, newbuf, 0, count);
                    byteArr = newbuf;
                }

                System.arraycopy(buffer, 0, byteArr, count, len);
                count += len;
            }
        }

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        options.inPurgeable = true;
        options.inInputShareable = true;
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;

        Bitmap b = BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        ExifInterface exif = new ExifInterface(IOUtils.getPath(uri, context));
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_UNDEFINED);

        input.close();

        return rotateBitmap(b, orientation);

    } catch (Exception e) {
        e.printStackTrace();

        return null;
    }
}

From source file:es.javocsoft.android.lib.toolbox.ToolBox.java

/**
 * Corrects the orientation of a Bitmap. Orientation, depending of the device
 * , is not correctly set in the EXIF data of the taken image when it is saved
 * into disk.//from   w  w  w  .ja v  a 2 s . c om
 * 
 * Explanation:
 *    Camera orientation is not working ok (as is when capturing an image) because 
 *  OEMs do not adhere to the standard. So, each company does this following their 
 *  own way.
 * 
 * @param imagePath   path to the file
 * @return
 */
public static Bitmap media_correctImageOrientation(String imagePath) {
    Bitmap res = null;

    try {
        File f = new File(imagePath);
        ExifInterface exif = new ExifInterface(f.getPath());
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);

        int angle = 0;

        if (orientation == ExifInterface.ORIENTATION_ROTATE_90) {
            angle = 90;
        } else if (orientation == ExifInterface.ORIENTATION_ROTATE_180) {
            angle = 180;
        } else if (orientation == ExifInterface.ORIENTATION_ROTATE_270) {
            angle = 270;
        }

        Matrix mat = new Matrix();
        mat.postRotate(angle);
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 2;

        Bitmap bmp = BitmapFactory.decodeStream(new FileInputStream(f), null, options);
        res = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), mat, true);

    } catch (OutOfMemoryError e) {
        if (LOG_ENABLE)
            Log.e(TAG, "media_correctImageOrientation() [OutOfMemory!]: " + e.getMessage(), e);
    } catch (Exception e) {
        if (LOG_ENABLE)
            Log.e(TAG, "media_correctImageOrientation(): " + e.getMessage(), e);
    } catch (Throwable e) {
        if (LOG_ENABLE)
            Log.e(TAG, "media_correctImageOrientation(): " + e.getMessage(), e);
    }

    return res;
}

From source file:org.telegram.ui.Components.ChatAttachAlert.java

public ChatAttachAlert(Context context, final ChatActivity parentFragment) {
    super(context, false);
    baseFragment = parentFragment;/*from www.jav  a 2 s .  co m*/
    setDelegate(this);
    setUseRevealAnimation(true);
    checkCamera(false);
    if (deviceHasGoodCamera) {
        CameraController.getInstance().initCamera();
    }
    NotificationCenter.getInstance().addObserver(this, NotificationCenter.albumsDidLoaded);
    NotificationCenter.getInstance().addObserver(this, NotificationCenter.reloadInlineHints);
    NotificationCenter.getInstance().addObserver(this, NotificationCenter.cameraInitied);
    shadowDrawable = context.getResources().getDrawable(R.drawable.sheet_shadow);

    containerView = listView = new RecyclerListView(context) {

        private int lastWidth;
        private int lastHeight;

        @Override
        public void requestLayout() {
            if (ignoreLayout) {
                return;
            }
            super.requestLayout();
        }

        @Override
        public boolean onInterceptTouchEvent(MotionEvent ev) {
            if (cameraAnimationInProgress) {
                return true;
            } else if (cameraOpened) {
                return processTouchEvent(ev);
            } else if (ev.getAction() == MotionEvent.ACTION_DOWN && scrollOffsetY != 0
                    && ev.getY() < scrollOffsetY) {
                dismiss();
                return true;
            }
            return super.onInterceptTouchEvent(ev);
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            if (cameraAnimationInProgress) {
                return true;
            } else if (cameraOpened) {
                return processTouchEvent(event);
            }
            return !isDismissed() && super.onTouchEvent(event);
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            int height = MeasureSpec.getSize(heightMeasureSpec);
            if (Build.VERSION.SDK_INT >= 21) {
                height -= AndroidUtilities.statusBarHeight;
            }
            int contentSize = backgroundPaddingTop + AndroidUtilities.dp(294)
                    + (SearchQuery.inlineBots.isEmpty() ? 0
                            : ((int) Math.ceil(SearchQuery.inlineBots.size() / 4.0f) * AndroidUtilities.dp(100)
                                    + AndroidUtilities.dp(12)));
            int padding = contentSize == AndroidUtilities.dp(294) ? 0
                    : Math.max(0, (height - AndroidUtilities.dp(294)));
            if (padding != 0 && contentSize < height) {
                padding -= (height - contentSize);
            }
            if (padding == 0) {
                padding = backgroundPaddingTop;
            }
            if (getPaddingTop() != padding) {
                ignoreLayout = true;
                setPadding(backgroundPaddingLeft, padding, backgroundPaddingLeft, 0);
                ignoreLayout = false;
            }
            super.onMeasure(widthMeasureSpec,
                    MeasureSpec.makeMeasureSpec(Math.min(contentSize, height), MeasureSpec.EXACTLY));
        }

        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            int width = right - left;
            int height = bottom - top;

            int newPosition = -1;
            int newTop = 0;

            int count = listView.getChildCount();
            int lastVisibleItemPosition = -1;
            int lastVisibleItemPositionTop = 0;
            if (count > 0) {
                View child = listView.getChildAt(listView.getChildCount() - 1);
                Holder holder = (Holder) listView.findContainingViewHolder(child);
                if (holder != null) {
                    lastVisibleItemPosition = holder.getAdapterPosition();
                    lastVisibleItemPositionTop = child.getTop();
                }
            }

            if (lastVisibleItemPosition >= 0 && height - lastHeight != 0) {
                newPosition = lastVisibleItemPosition;
                newTop = lastVisibleItemPositionTop + height - lastHeight - getPaddingTop();
            }

            super.onLayout(changed, left, top, right, bottom);

            if (newPosition != -1) {
                ignoreLayout = true;
                layoutManager.scrollToPositionWithOffset(newPosition, newTop);
                super.onLayout(false, left, top, right, bottom);
                ignoreLayout = false;
            }

            lastHeight = height;
            lastWidth = width;

            updateLayout();
            checkCameraViewPosition();
        }

        @Override
        public void onDraw(Canvas canvas) {
            if (useRevealAnimation && Build.VERSION.SDK_INT <= 19) {
                canvas.save();
                canvas.clipRect(backgroundPaddingLeft, scrollOffsetY,
                        getMeasuredWidth() - backgroundPaddingLeft, getMeasuredHeight());
                if (revealAnimationInProgress) {
                    canvas.drawCircle(revealX, revealY, revealRadius, ciclePaint);
                } else {
                    canvas.drawRect(backgroundPaddingLeft, scrollOffsetY,
                            getMeasuredWidth() - backgroundPaddingLeft, getMeasuredHeight(), ciclePaint);
                }
                canvas.restore();
            } else {
                shadowDrawable.setBounds(0, scrollOffsetY - backgroundPaddingTop, getMeasuredWidth(),
                        getMeasuredHeight());
                shadowDrawable.draw(canvas);
            }
        }

        @Override
        public void setTranslationY(float translationY) {
            super.setTranslationY(translationY);
            checkCameraViewPosition();
        }
    };

    listView.setWillNotDraw(false);
    listView.setClipToPadding(false);
    listView.setLayoutManager(layoutManager = new LinearLayoutManager(getContext()));
    layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
    listView.setAdapter(adapter = new ListAdapter(context));
    listView.setVerticalScrollBarEnabled(false);
    listView.setEnabled(true);
    listView.setGlowColor(0xfff5f6f7);
    listView.addItemDecoration(new RecyclerView.ItemDecoration() {
        @Override
        public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
            outRect.left = 0;
            outRect.right = 0;
            outRect.top = 0;
            outRect.bottom = 0;
        }
    });

    listView.setOnScrollListener(new RecyclerView.OnScrollListener() {
        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            if (listView.getChildCount() <= 0) {
                return;
            }
            if (hintShowed) {
                if (layoutManager.findLastVisibleItemPosition() > 1) {
                    hideHint();
                    hintShowed = false;
                    ApplicationLoader.applicationContext
                            .getSharedPreferences("mainconfig", Activity.MODE_PRIVATE).edit()
                            .putBoolean("bothint", true).commit();
                }
            }
            updateLayout();
            checkCameraViewPosition();
        }
    });
    containerView.setPadding(backgroundPaddingLeft, 0, backgroundPaddingLeft, 0);

    attachView = new FrameLayout(context) {
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec,
                    MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(294), MeasureSpec.EXACTLY));
        }

        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            int width = right - left;
            int height = bottom - top;
            int t = AndroidUtilities.dp(8);
            attachPhotoRecyclerView.layout(0, t, width, t + attachPhotoRecyclerView.getMeasuredHeight());
            progressView.layout(0, t, width, t + progressView.getMeasuredHeight());
            lineView.layout(0, AndroidUtilities.dp(96), width,
                    AndroidUtilities.dp(96) + lineView.getMeasuredHeight());
            hintTextView.layout(width - hintTextView.getMeasuredWidth() - AndroidUtilities.dp(5),
                    height - hintTextView.getMeasuredHeight() - AndroidUtilities.dp(5),
                    width - AndroidUtilities.dp(5), height - AndroidUtilities.dp(5));

            int diff = (width - AndroidUtilities.dp(85 * 4 + 20)) / 3;
            for (int a = 0; a < 8; a++) {
                int y = AndroidUtilities.dp(105 + 95 * (a / 4));
                int x = AndroidUtilities.dp(10) + (a % 4) * (AndroidUtilities.dp(85) + diff);
                views[a].layout(x, y, x + views[a].getMeasuredWidth(), y + views[a].getMeasuredHeight());
            }
        }
    };

    views[8] = attachPhotoRecyclerView = new RecyclerListView(context);
    attachPhotoRecyclerView.setVerticalScrollBarEnabled(true);
    attachPhotoRecyclerView.setAdapter(photoAttachAdapter = new PhotoAttachAdapter(context));
    attachPhotoRecyclerView.setClipToPadding(false);
    attachPhotoRecyclerView.setPadding(AndroidUtilities.dp(8), 0, AndroidUtilities.dp(8), 0);
    attachPhotoRecyclerView.setItemAnimator(null);
    attachPhotoRecyclerView.setLayoutAnimation(null);
    attachPhotoRecyclerView.setOverScrollMode(RecyclerListView.OVER_SCROLL_NEVER);
    attachView.addView(attachPhotoRecyclerView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 80));
    attachPhotoLayoutManager = new LinearLayoutManager(context) {
        @Override
        public boolean supportsPredictiveItemAnimations() {
            return false;
        }
    };
    attachPhotoLayoutManager.setOrientation(LinearLayoutManager.HORIZONTAL);
    attachPhotoRecyclerView.setLayoutManager(attachPhotoLayoutManager);
    attachPhotoRecyclerView.setOnItemClickListener(new RecyclerListView.OnItemClickListener() {
        @SuppressWarnings("unchecked")
        @Override
        public void onItemClick(View view, int position) {
            if (baseFragment == null || baseFragment.getParentActivity() == null) {
                return;
            }
            if (!deviceHasGoodCamera || position != 0) {
                if (deviceHasGoodCamera) {
                    position--;
                }
                if (MediaController.allPhotosAlbumEntry == null) {
                    return;
                }
                ArrayList<Object> arrayList = (ArrayList) MediaController.allPhotosAlbumEntry.photos;
                if (position < 0 || position >= arrayList.size()) {
                    return;
                }
                PhotoViewer.getInstance().setParentActivity(baseFragment.getParentActivity());
                PhotoViewer.getInstance().openPhotoForSelect(arrayList, position, 0, ChatAttachAlert.this,
                        baseFragment);
                AndroidUtilities.hideKeyboard(baseFragment.getFragmentView().findFocus());
            } else {
                openCamera();
            }
        }
    });
    attachPhotoRecyclerView.setOnScrollListener(new RecyclerView.OnScrollListener() {
        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            checkCameraViewPosition();
        }
    });

    views[9] = progressView = new EmptyTextProgressView(context);
    if (Build.VERSION.SDK_INT >= 23 && getContext().checkSelfPermission(
            Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        progressView.setText(LocaleController.getString("PermissionStorage", R.string.PermissionStorage));
        progressView.setTextSize(16);
    } else {
        progressView.setText(LocaleController.getString("NoPhotos", R.string.NoPhotos));
        progressView.setTextSize(20);
    }
    attachView.addView(progressView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 80));
    attachPhotoRecyclerView.setEmptyView(progressView);

    views[10] = lineView = new View(getContext()) {
        @Override
        public boolean hasOverlappingRendering() {
            return false;
        }
    };
    lineView.setBackgroundColor(ContextCompat.getColor(context, R.color.divider));
    attachView.addView(lineView,
            new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 1, Gravity.TOP | Gravity.LEFT));
    CharSequence[] items = new CharSequence[] { LocaleController.getString("ChatCamera", R.string.ChatCamera),
            LocaleController.getString("ChatGallery", R.string.ChatGallery),
            LocaleController.getString("ChatVideo", R.string.ChatVideo),
            LocaleController.getString("AttachMusic", R.string.AttachMusic),
            LocaleController.getString("ChatDocument", R.string.ChatDocument),
            LocaleController.getString("AttachContact", R.string.AttachContact),
            LocaleController.getString("ChatLocation", R.string.ChatLocation), "" };
    for (int a = 0; a < 8; a++) {
        AttachButton attachButton = new AttachButton(context);
        attachButton.setTextAndIcon(items[a], Theme.attachButtonDrawables[a]);
        attachView.addView(attachButton, LayoutHelper.createFrame(85, 90, Gravity.LEFT | Gravity.TOP));
        attachButton.setTag(a);
        views[a] = attachButton;
        if (a == 7) {
            sendPhotosButton = attachButton;
            sendPhotosButton.imageView.setPadding(0, AndroidUtilities.dp(4), 0, 0);
        }
        attachButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                delegate.didPressedButton((Integer) v.getTag());
            }
        });
    }

    hintTextView = new TextView(context);
    hintTextView.setBackgroundResource(R.drawable.tooltip);
    hintTextView.setTextColor(Theme.CHAT_GIF_HINT_TEXT_COLOR);
    hintTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
    hintTextView.setPadding(AndroidUtilities.dp(10), 0, AndroidUtilities.dp(10), 0);
    hintTextView.setText(LocaleController.getString("AttachBotsHelp", R.string.AttachBotsHelp));
    hintTextView.setGravity(Gravity.CENTER_VERTICAL);
    hintTextView.setVisibility(View.INVISIBLE);
    hintTextView.setCompoundDrawablesWithIntrinsicBounds(R.drawable.scroll_tip, 0, 0, 0);
    hintTextView.setCompoundDrawablePadding(AndroidUtilities.dp(8));
    attachView.addView(hintTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, 32,
            Gravity.RIGHT | Gravity.BOTTOM, 5, 0, 5, 5));

    for (int a = 0; a < 8; a++) {
        viewsCache.add(photoAttachAdapter.createHolder());
    }

    if (loading) {
        progressView.showProgress();
    } else {
        progressView.showTextView();
    }

    if (Build.VERSION.SDK_INT >= 16) {
        recordTime = new TextView(context);
        recordTime.setBackgroundResource(R.drawable.system);
        recordTime.getBackground()
                .setColorFilter(new PorterDuffColorFilter(0x66000000, PorterDuff.Mode.MULTIPLY));
        recordTime.setText("00:00");
        recordTime.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
        recordTime.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
        recordTime.setAlpha(0.0f);
        recordTime.setTextColor(0xffffffff);
        recordTime.setPadding(AndroidUtilities.dp(10), AndroidUtilities.dp(5), AndroidUtilities.dp(10),
                AndroidUtilities.dp(5));
        container.addView(recordTime, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT,
                LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, 16, 0, 0));

        cameraPanel = new FrameLayout(context) {
            @Override
            protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
                int cx = getMeasuredWidth() / 2;
                int cy = getMeasuredHeight() / 2;
                int cx2;
                int cy2;
                shutterButton.layout(cx - shutterButton.getMeasuredWidth() / 2,
                        cy - shutterButton.getMeasuredHeight() / 2, cx + shutterButton.getMeasuredWidth() / 2,
                        cy + shutterButton.getMeasuredHeight() / 2);
                if (getMeasuredWidth() == AndroidUtilities.dp(100)) {
                    cx = cx2 = getMeasuredWidth() / 2;
                    cy2 = cy + cy / 2 + AndroidUtilities.dp(17);
                    cy = cy / 2 - AndroidUtilities.dp(17);
                } else {
                    cx2 = cx + cx / 2 + AndroidUtilities.dp(17);
                    cx = cx / 2 - AndroidUtilities.dp(17);
                    cy = cy2 = getMeasuredHeight() / 2;
                }
                switchCameraButton.layout(cx2 - switchCameraButton.getMeasuredWidth() / 2,
                        cy2 - switchCameraButton.getMeasuredHeight() / 2,
                        cx2 + switchCameraButton.getMeasuredWidth() / 2,
                        cy2 + switchCameraButton.getMeasuredHeight() / 2);
                for (int a = 0; a < 2; a++) {
                    flashModeButton[a].layout(cx - flashModeButton[a].getMeasuredWidth() / 2,
                            cy - flashModeButton[a].getMeasuredHeight() / 2,
                            cx + flashModeButton[a].getMeasuredWidth() / 2,
                            cy + flashModeButton[a].getMeasuredHeight() / 2);
                }
            }
        };
        cameraPanel.setVisibility(View.GONE);
        cameraPanel.setAlpha(0.0f);
        container.addView(cameraPanel,
                LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 100, Gravity.LEFT | Gravity.BOTTOM));

        shutterButton = new ShutterButton(context);
        cameraPanel.addView(shutterButton, LayoutHelper.createFrame(84, 84, Gravity.CENTER));
        shutterButton.setDelegate(new ShutterButton.ShutterButtonDelegate() {
            @Override
            public void shutterLongPressed() {
                if (takingPhoto || baseFragment == null || baseFragment.getParentActivity() == null) {
                    return;
                }
                if (Build.VERSION.SDK_INT >= 23) {
                    if (baseFragment.getParentActivity().checkSelfPermission(
                            Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
                        baseFragment.getParentActivity()
                                .requestPermissions(new String[] { Manifest.permission.RECORD_AUDIO }, 21);
                        return;
                    }
                }
                for (int a = 0; a < 2; a++) {
                    flashModeButton[a].setAlpha(0.0f);
                }
                switchCameraButton.setAlpha(0.0f);
                cameraFile = AndroidUtilities.generateVideoPath();
                recordTime.setAlpha(1.0f);
                recordTime.setText("00:00");
                videoRecordTime = 0;
                videoRecordRunnable = new Runnable() {
                    @Override
                    public void run() {
                        if (videoRecordRunnable == null) {
                            return;
                        }
                        videoRecordTime++;
                        recordTime.setText(
                                String.format("%02d:%02d", videoRecordTime / 60, videoRecordTime % 60));
                        AndroidUtilities.runOnUIThread(videoRecordRunnable, 1000);
                    }
                };
                AndroidUtilities.lockOrientation(parentFragment.getParentActivity());
                CameraController.getInstance().recordVideo(cameraView.getCameraSession(), cameraFile,
                        new CameraController.VideoTakeCallback() {
                            @Override
                            public void onFinishVideoRecording(final Bitmap thumb) {
                                if (cameraFile == null || baseFragment == null) {
                                    return;
                                }
                                PhotoViewer.getInstance().setParentActivity(baseFragment.getParentActivity());
                                cameraPhoto = new ArrayList<>();
                                cameraPhoto.add(new MediaController.PhotoEntry(0, 0, 0,
                                        cameraFile.getAbsolutePath(), 0, true));
                                PhotoViewer.getInstance().openPhotoForSelect(cameraPhoto, 0, 2,
                                        new PhotoViewer.EmptyPhotoViewerProvider() {
                                            @Override
                                            public Bitmap getThumbForPhoto(MessageObject messageObject,
                                                    TLRPC.FileLocation fileLocation, int index) {
                                                return thumb;
                                            }

                                            @TargetApi(16)
                                            @Override
                                            public boolean cancelButtonPressed() {
                                                if (cameraOpened && cameraView != null && cameraFile != null) {
                                                    cameraFile.delete();
                                                    AndroidUtilities.runOnUIThread(new Runnable() {
                                                        @Override
                                                        public void run() {
                                                            if (cameraView != null && !isDismissed()
                                                                    && Build.VERSION.SDK_INT >= 21) {
                                                                cameraView.setSystemUiVisibility(
                                                                        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                                                                                | View.SYSTEM_UI_FLAG_FULLSCREEN);
                                                            }
                                                        }
                                                    }, 1000);
                                                    CameraController.getInstance()
                                                            .startPreview(cameraView.getCameraSession());
                                                    cameraFile = null;
                                                }
                                                return true;
                                            }

                                            @Override
                                            public void sendButtonPressed(int index) {
                                                if (cameraFile == null) {
                                                    return;
                                                }
                                                AndroidUtilities
                                                        .addMediaToGallery(cameraFile.getAbsolutePath());
                                                baseFragment.sendMedia(
                                                        (MediaController.PhotoEntry) cameraPhoto.get(0),
                                                        PhotoViewer.getInstance().isMuteVideo());
                                                closeCamera(false);
                                                dismiss();
                                                cameraFile = null;
                                            }
                                        }, baseFragment);
                            }
                        });
                AndroidUtilities.runOnUIThread(videoRecordRunnable, 1000);
                shutterButton.setState(ShutterButton.State.RECORDING, true);
            }

            @Override
            public void shutterCancel() {
                cameraFile.delete();
                resetRecordState();
                CameraController.getInstance().stopVideoRecording(cameraView.getCameraSession(), true);
            }

            @Override
            public void shutterReleased() {
                if (takingPhoto) {
                    return;
                }
                if (shutterButton.getState() == ShutterButton.State.RECORDING) {
                    resetRecordState();
                    CameraController.getInstance().stopVideoRecording(cameraView.getCameraSession(), false);
                    shutterButton.setState(ShutterButton.State.DEFAULT, true);
                    return;
                }
                cameraFile = AndroidUtilities.generatePicturePath();
                takingPhoto = CameraController.getInstance().takePicture(cameraFile,
                        cameraView.getCameraSession(), new Runnable() {
                            @Override
                            public void run() {
                                takingPhoto = false;
                                if (cameraFile == null || baseFragment == null) {
                                    return;
                                }
                                PhotoViewer.getInstance().setParentActivity(baseFragment.getParentActivity());
                                cameraPhoto = new ArrayList<>();
                                int orientation = 0;
                                try {
                                    ExifInterface ei = new ExifInterface(cameraFile.getAbsolutePath());
                                    int exif = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                                            ExifInterface.ORIENTATION_NORMAL);
                                    switch (exif) {
                                    case ExifInterface.ORIENTATION_ROTATE_90:
                                        orientation = 90;
                                        break;
                                    case ExifInterface.ORIENTATION_ROTATE_180:
                                        orientation = 180;
                                        break;
                                    case ExifInterface.ORIENTATION_ROTATE_270:
                                        orientation = 270;
                                        break;
                                    }
                                } catch (Exception e) {
                                    FileLog.e("tmessages", e);
                                }
                                cameraPhoto.add(new MediaController.PhotoEntry(0, 0, 0,
                                        cameraFile.getAbsolutePath(), orientation, false));
                                PhotoViewer.getInstance().openPhotoForSelect(cameraPhoto, 0, 2,
                                        new PhotoViewer.EmptyPhotoViewerProvider() {
                                            @TargetApi(16)
                                            @Override
                                            public boolean cancelButtonPressed() {
                                                if (cameraOpened && cameraView != null && cameraFile != null) {
                                                    cameraFile.delete();
                                                    AndroidUtilities.runOnUIThread(new Runnable() {
                                                        @Override
                                                        public void run() {
                                                            if (cameraView != null && !isDismissed()
                                                                    && Build.VERSION.SDK_INT >= 21) {
                                                                cameraView.setSystemUiVisibility(
                                                                        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                                                                                | View.SYSTEM_UI_FLAG_FULLSCREEN);
                                                            }
                                                        }
                                                    }, 1000);
                                                    CameraController.getInstance()
                                                            .startPreview(cameraView.getCameraSession());
                                                    cameraFile = null;
                                                }
                                                return true;
                                            }

                                            @Override
                                            public void sendButtonPressed(int index) {
                                                if (cameraFile == null) {
                                                    return;
                                                }
                                                AndroidUtilities
                                                        .addMediaToGallery(cameraFile.getAbsolutePath());
                                                baseFragment.sendMedia(
                                                        (MediaController.PhotoEntry) cameraPhoto.get(0), false);
                                                closeCamera(false);
                                                dismiss();
                                                cameraFile = null;
                                            }

                                            @Override
                                            public boolean scaleToFill() {
                                                return true;
                                            }
                                        }, baseFragment);
                            }
                        });
            }
        });

        switchCameraButton = new ImageView(context);
        switchCameraButton.setScaleType(ImageView.ScaleType.CENTER);
        cameraPanel.addView(switchCameraButton,
                LayoutHelper.createFrame(48, 48, Gravity.RIGHT | Gravity.CENTER_VERTICAL));
        switchCameraButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (takingPhoto || cameraView == null || !cameraView.isInitied()) {
                    return;
                }
                cameraInitied = false;
                cameraView.switchCamera();
                ObjectAnimator animator = ObjectAnimator.ofFloat(switchCameraButton, "scaleX", 0.0f)
                        .setDuration(100);
                animator.addListener(new AnimatorListenerAdapterProxy() {
                    @Override
                    public void onAnimationEnd(Animator animator) {
                        switchCameraButton.setImageResource(cameraView.isFrontface() ? R.drawable.camera_revert1
                                : R.drawable.camera_revert2);
                        ObjectAnimator.ofFloat(switchCameraButton, "scaleX", 1.0f).setDuration(100).start();
                    }
                });
                animator.start();
            }
        });

        for (int a = 0; a < 2; a++) {
            flashModeButton[a] = new ImageView(context);
            flashModeButton[a].setScaleType(ImageView.ScaleType.CENTER);
            flashModeButton[a].setVisibility(View.INVISIBLE);
            cameraPanel.addView(flashModeButton[a],
                    LayoutHelper.createFrame(48, 48, Gravity.LEFT | Gravity.TOP));
            flashModeButton[a].setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(final View currentImage) {
                    if (flashAnimationInProgress || cameraView == null || !cameraView.isInitied()
                            || !cameraOpened) {
                        return;
                    }
                    String current = cameraView.getCameraSession().getCurrentFlashMode();
                    String next = cameraView.getCameraSession().getNextFlashMode();
                    if (current.equals(next)) {
                        return;
                    }
                    cameraView.getCameraSession().setCurrentFlashMode(next);
                    flashAnimationInProgress = true;
                    ImageView nextImage = flashModeButton[0] == currentImage ? flashModeButton[1]
                            : flashModeButton[0];
                    nextImage.setVisibility(View.VISIBLE);
                    setCameraFlashModeIcon(nextImage, next);
                    AnimatorSet animatorSet = new AnimatorSet();
                    animatorSet.playTogether(
                            ObjectAnimator.ofFloat(currentImage, "translationY", 0, AndroidUtilities.dp(48)),
                            ObjectAnimator.ofFloat(nextImage, "translationY", -AndroidUtilities.dp(48), 0),
                            ObjectAnimator.ofFloat(currentImage, "alpha", 1.0f, 0.0f),
                            ObjectAnimator.ofFloat(nextImage, "alpha", 0.0f, 1.0f));
                    animatorSet.setDuration(200);
                    animatorSet.addListener(new AnimatorListenerAdapterProxy() {
                        @Override
                        public void onAnimationEnd(Animator animator) {
                            flashAnimationInProgress = false;
                            currentImage.setVisibility(View.INVISIBLE);
                        }
                    });
                    animatorSet.start();
                }
            });
        }
    }
}

From source file:me.ccrama.redditslide.Views.SubsamplingScaleImageView.java

/**
 * Helper method for load tasks. Examines the EXIF info on the image file to determine the orientation.
 * This will only work for external files, not assets, resources or other URIs.
 *//*from w ww.j av  a 2  s  . c o  m*/
private int getExifOrientation(String sourceUri) {
    int exifOrientation = ORIENTATION_0;
    if (sourceUri.startsWith(ContentResolver.SCHEME_CONTENT)) {
        try {
            final String[] columns = { MediaStore.Images.Media.ORIENTATION };
            final Cursor cursor = getContext().getContentResolver().query(Uri.parse(sourceUri), columns, null,
                    null, null);
            if (cursor != null) {
                if (cursor.moveToFirst()) {
                    int orientation = cursor.getInt(0);
                    if (VALID_ORIENTATIONS.contains(orientation) && orientation != ORIENTATION_USE_EXIF) {
                        exifOrientation = orientation;
                    } else {
                        Log.w(TAG, "Unsupported orientation: " + orientation);
                    }
                }
                cursor.close();
            }
        } catch (Exception e) {
            Log.w(TAG, "Could not get orientation of image from media store");
        }
    } else if (sourceUri.startsWith(ImageSource.FILE_SCHEME)
            && !sourceUri.startsWith(ImageSource.ASSET_SCHEME)) {
        try {
            ExifInterface exifInterface = new ExifInterface(
                    sourceUri.substring(ImageSource.FILE_SCHEME.length() - 1));
            int orientationAttr = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            if (orientationAttr == ExifInterface.ORIENTATION_NORMAL
                    || orientationAttr == ExifInterface.ORIENTATION_UNDEFINED) {
                exifOrientation = ORIENTATION_0;
            } else if (orientationAttr == ExifInterface.ORIENTATION_ROTATE_90) {
                exifOrientation = ORIENTATION_90;
            } else if (orientationAttr == ExifInterface.ORIENTATION_ROTATE_180) {
                exifOrientation = ORIENTATION_180;
            } else if (orientationAttr == ExifInterface.ORIENTATION_ROTATE_270) {
                exifOrientation = ORIENTATION_270;
            } else {
                Log.w(TAG, "Unsupported EXIF orientation: " + orientationAttr);
            }
        } catch (Exception e) {
            Log.w(TAG, "Could not get EXIF orientation of image");
        }
    }
    return exifOrientation;
}

From source file:com.irccloud.android.activity.MainActivity.java

private Uri resize(Uri in) {
    Uri out = null;/*from ww  w.ja  v a 2s .  com*/
    try {
        int MAX_IMAGE_SIZE = Integer
                .parseInt(PreferenceManager.getDefaultSharedPreferences(this).getString("photo_size", "1024"));
        File imageDir = new File(Environment.getExternalStorageDirectory(), "IRCCloud");
        imageDir.mkdirs();
        new File(imageDir, ".nomedia").createNewFile();

        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(IRCCloudApplication.getInstance().getApplicationContext()
                .getContentResolver().openInputStream(in), null, o);
        int scale = 1;

        if (o.outWidth < MAX_IMAGE_SIZE && o.outHeight < MAX_IMAGE_SIZE)
            return in;

        if (o.outWidth > o.outHeight) {
            if (o.outWidth > MAX_IMAGE_SIZE)
                scale = o.outWidth / MAX_IMAGE_SIZE;
        } else {
            if (o.outHeight > MAX_IMAGE_SIZE)
                scale = o.outHeight / MAX_IMAGE_SIZE;
        }

        o = new BitmapFactory.Options();
        o.inSampleSize = scale;
        Bitmap bmp = BitmapFactory.decodeStream(IRCCloudApplication.getInstance().getApplicationContext()
                .getContentResolver().openInputStream(in), null, o);

        //ExifInterface can only work on local files, so make a temporary copy on the SD card
        out = Uri.fromFile(File.createTempFile("irccloudcapture-original", ".jpg", imageDir));
        InputStream is = IRCCloudApplication.getInstance().getApplicationContext().getContentResolver()
                .openInputStream(in);
        OutputStream os = IRCCloudApplication.getInstance().getApplicationContext().getContentResolver()
                .openOutputStream(out);
        byte[] buffer = new byte[8192];
        int len;
        while ((len = is.read(buffer)) != -1) {
            os.write(buffer, 0, len);
        }
        is.close();
        os.close();

        ExifInterface exif = new ExifInterface(out.getPath());
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);
        new File(new URI(out.toString())).delete();

        out = Uri.fromFile(File.createTempFile("irccloudcapture-resized", ".jpg", imageDir));
        if (orientation > 1) {
            Matrix matrix = new Matrix();
            switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90:
                matrix.postRotate(90);
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                matrix.postRotate(180);
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                matrix.postRotate(270);
                break;
            }
            try {
                Bitmap oldbmp = bmp;
                bmp = Bitmap.createBitmap(oldbmp, 0, 0, oldbmp.getWidth(), oldbmp.getHeight(), matrix, true);
                oldbmp.recycle();
            } catch (OutOfMemoryError e) {
                Log.e("IRCCloud", "Out of memory rotating the photo, it may look wrong on imgur");
            }
        }

        if (bmp == null || !bmp.compress(android.graphics.Bitmap.CompressFormat.JPEG, 90, IRCCloudApplication
                .getInstance().getApplicationContext().getContentResolver().openOutputStream(out))) {
            out = null;
        }
        if (bmp != null)
            bmp.recycle();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        Crashlytics.logException(e);
    } catch (OutOfMemoryError e) {
        Log.e("IRCCloud", "Out of memory rotating the photo, it may look wrong on imgur");
    }
    if (!PreferenceManager.getDefaultSharedPreferences(this).getBoolean("keep_photos", false)
            && in.toString().contains("irccloudcapture")) {
        try {
            new File(new URI(in.toString())).delete();
        } catch (Exception e) {
        }
    }
    if (out != null)
        return out;
    else
        return in;
}

From source file:com.codename1.impl.android.AndroidImplementation.java

@Override
public Object createImage(String path) throws IOException {
    int IMAGE_MAX_SIZE = getDisplayHeight();
    if (exists(path)) {
        Bitmap b = null;/* www.j  ava  2  s.co  m*/
        try {
            //Decode image size
            BitmapFactory.Options o = new BitmapFactory.Options();
            o.inJustDecodeBounds = true;
            o.inPreferredConfig = Bitmap.Config.ARGB_8888;

            InputStream fis = createFileInputStream(path);
            BitmapFactory.decodeStream(fis, null, o);
            fis.close();

            int scale = 1;
            if (o.outHeight > IMAGE_MAX_SIZE || o.outWidth > IMAGE_MAX_SIZE) {
                scale = (int) Math.pow(2, (int) Math.round(
                        Math.log(IMAGE_MAX_SIZE / (double) Math.max(o.outHeight, o.outWidth)) / Math.log(0.5)));
            }

            //Decode with inSampleSize
            BitmapFactory.Options o2 = new BitmapFactory.Options();
            o2.inPreferredConfig = Bitmap.Config.ARGB_8888;

            if (sampleSizeOverride != -1) {
                o2.inSampleSize = sampleSizeOverride;
            } else {
                String sampleSize = Display.getInstance().getProperty("android.sampleSize", null);
                if (sampleSize != null) {
                    o2.inSampleSize = Integer.parseInt(sampleSize);
                } else {
                    o2.inSampleSize = scale;
                }
            }
            o2.inPurgeable = true;
            o2.inInputShareable = true;
            fis = createFileInputStream(path);
            b = BitmapFactory.decodeStream(fis, null, o2);
            fis.close();

            //fix rotation
            ExifInterface exif = new ExifInterface(path);
            int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);

            int angle = 0;
            switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90:
                angle = 90;
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                angle = 180;
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                angle = 270;
                break;
            }

            if (sampleSizeOverride < 0 && angle != 0) {
                Matrix mat = new Matrix();
                mat.postRotate(angle);
                Bitmap correctBmp = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), mat, true);
                b.recycle();
                b = correctBmp;
            }
        } catch (IOException e) {
        }
        return b;
    } else {
        InputStream in = this.getResourceAsStream(getClass(), path);
        if (in == null) {
            throw new IOException("Resource not found. " + path);
        }
        try {
            return this.createImage(in);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (Exception ignored) {
                    ;
                }
            }
        }
    }
}