1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.gallery3d.filtershow; 18 19 import android.app.ActionBar; 20 import android.app.AlertDialog; 21 import android.app.ProgressDialog; 22 import android.content.ComponentName; 23 import android.content.ContentValues; 24 import android.content.Context; 25 import android.content.DialogInterface; 26 import android.content.Intent; 27 import android.content.ServiceConnection; 28 import android.content.pm.ActivityInfo; 29 import android.content.res.Configuration; 30 import android.content.res.Resources; 31 import android.graphics.Bitmap; 32 import android.graphics.Color; 33 import android.graphics.Matrix; 34 import android.graphics.Point; 35 import android.graphics.Rect; 36 import android.graphics.RectF; 37 import android.graphics.drawable.ColorDrawable; 38 import android.graphics.drawable.Drawable; 39 import android.net.Uri; 40 import android.os.AsyncTask; 41 import android.os.Bundle; 42 import android.os.CancellationSignal; 43 import android.os.Handler; 44 import android.os.IBinder; 45 import androidx.fragment.app.DialogFragment; 46 import androidx.fragment.app.Fragment; 47 import androidx.fragment.app.FragmentActivity; 48 import androidx.fragment.app.FragmentTransaction; 49 import androidx.print.PrintHelper; 50 import android.util.DisplayMetrics; 51 import android.util.Log; 52 import android.util.TypedValue; 53 import android.view.Menu; 54 import android.view.MenuItem; 55 import android.view.MotionEvent; 56 import android.view.View; 57 import android.view.View.OnClickListener; 58 import android.view.ViewPropertyAnimator; 59 import android.view.WindowManager; 60 import android.widget.AdapterView; 61 import android.widget.AdapterView.OnItemClickListener; 62 import android.widget.FrameLayout; 63 import android.widget.PopupMenu; 64 import android.widget.ShareActionProvider; 65 import android.widget.ShareActionProvider.OnShareTargetSelectedListener; 66 import android.widget.Spinner; 67 import android.widget.Toast; 68 69 import com.android.gallery3d.R; 70 import com.android.gallery3d.app.PhotoPage; 71 import com.android.gallery3d.data.LocalAlbum; 72 import com.android.gallery3d.filtershow.cache.ImageLoader; 73 import com.android.gallery3d.filtershow.category.Action; 74 import com.android.gallery3d.filtershow.category.CategoryAdapter; 75 import com.android.gallery3d.filtershow.category.CategorySelected; 76 import com.android.gallery3d.filtershow.category.CategoryView; 77 import com.android.gallery3d.filtershow.category.MainPanel; 78 import com.android.gallery3d.filtershow.category.SwipableView; 79 import com.android.gallery3d.filtershow.data.UserPresetsManager; 80 import com.android.gallery3d.filtershow.editors.BasicEditor; 81 import com.android.gallery3d.filtershow.editors.Editor; 82 import com.android.gallery3d.filtershow.editors.EditorChanSat; 83 import com.android.gallery3d.filtershow.editors.EditorColorBorder; 84 import com.android.gallery3d.filtershow.editors.EditorCrop; 85 import com.android.gallery3d.filtershow.editors.EditorDraw; 86 import com.android.gallery3d.filtershow.editors.EditorGrad; 87 import com.android.gallery3d.filtershow.editors.EditorManager; 88 import com.android.gallery3d.filtershow.editors.EditorMirror; 89 import com.android.gallery3d.filtershow.editors.EditorPanel; 90 import com.android.gallery3d.filtershow.editors.EditorRedEye; 91 import com.android.gallery3d.filtershow.editors.EditorRotate; 92 import com.android.gallery3d.filtershow.editors.EditorStraighten; 93 import com.android.gallery3d.filtershow.editors.EditorTinyPlanet; 94 import com.android.gallery3d.filtershow.editors.ImageOnlyEditor; 95 import com.android.gallery3d.filtershow.filters.FilterDrawRepresentation; 96 import com.android.gallery3d.filtershow.filters.FilterMirrorRepresentation; 97 import com.android.gallery3d.filtershow.filters.FilterRepresentation; 98 import com.android.gallery3d.filtershow.filters.FilterRotateRepresentation; 99 import com.android.gallery3d.filtershow.filters.FilterStraightenRepresentation; 100 import com.android.gallery3d.filtershow.filters.FilterUserPresetRepresentation; 101 import com.android.gallery3d.filtershow.filters.FiltersManager; 102 import com.android.gallery3d.filtershow.filters.ImageFilter; 103 import com.android.gallery3d.filtershow.history.HistoryItem; 104 import com.android.gallery3d.filtershow.history.HistoryManager; 105 import com.android.gallery3d.filtershow.imageshow.ImageShow; 106 import com.android.gallery3d.filtershow.imageshow.MasterImage; 107 import com.android.gallery3d.filtershow.imageshow.Spline; 108 import com.android.gallery3d.filtershow.info.InfoPanel; 109 import com.android.gallery3d.filtershow.pipeline.CachingPipeline; 110 import com.android.gallery3d.filtershow.pipeline.ImagePreset; 111 import com.android.gallery3d.filtershow.pipeline.ProcessingService; 112 import com.android.gallery3d.filtershow.presets.PresetManagementDialog; 113 import com.android.gallery3d.filtershow.presets.UserPresetsAdapter; 114 import com.android.gallery3d.filtershow.provider.SharedImageProvider; 115 import com.android.gallery3d.filtershow.state.StateAdapter; 116 import com.android.gallery3d.filtershow.tools.SaveImage; 117 import com.android.gallery3d.filtershow.tools.XmpPresets; 118 import com.android.gallery3d.filtershow.tools.XmpPresets.XMresults; 119 import com.android.gallery3d.filtershow.ui.ExportDialog; 120 import com.android.gallery3d.filtershow.ui.FramedTextButton; 121 import com.android.gallery3d.util.GalleryUtils; 122 import com.android.photos.data.GalleryBitmapPool; 123 124 import java.io.File; 125 import java.io.FileDescriptor; 126 import java.io.FileOutputStream; 127 import java.lang.ref.WeakReference; 128 import java.util.ArrayList; 129 import java.util.Vector; 130 131 public class FilterShowActivity extends FragmentActivity implements OnItemClickListener, 132 OnShareTargetSelectedListener, DialogInterface.OnShowListener, 133 DialogInterface.OnDismissListener, PopupMenu.OnDismissListener{ 134 135 private String mAction = ""; 136 MasterImage mMasterImage = null; 137 138 private static final long LIMIT_SUPPORTS_HIGHRES = 134217728; // 128Mb 139 140 public static final String TINY_PLANET_ACTION = "com.android.camera.action.TINY_PLANET"; 141 public static final String LAUNCH_FULLSCREEN = "launch-fullscreen"; 142 public static final boolean RESET_TO_LOADED = false; 143 private ImageShow mImageShow = null; 144 145 private View mSaveButton = null; 146 147 private EditorPlaceHolder mEditorPlaceHolder = new EditorPlaceHolder(this); 148 private Editor mCurrentEditor = null; 149 150 private static final int SELECT_PICTURE = 1; 151 private static final String LOGTAG = "FilterShowActivity"; 152 153 private boolean mShowingTinyPlanet = false; 154 private boolean mShowingImageStatePanel = false; 155 private boolean mShowingVersionsPanel = false; 156 157 private final Vector<ImageShow> mImageViews = new Vector<ImageShow>(); 158 159 private ShareActionProvider mShareActionProvider; 160 private File mSharedOutputFile = null; 161 162 private boolean mSharingImage = false; 163 164 private WeakReference<ProgressDialog> mSavingProgressDialog; 165 166 private LoadBitmapTask mLoadBitmapTask; 167 168 private Uri mOriginalImageUri = null; 169 private ImagePreset mOriginalPreset = null; 170 171 private Uri mSelectedImageUri = null; 172 173 private ArrayList<Action> mActions = new ArrayList<Action>(); 174 private UserPresetsManager mUserPresetsManager = null; 175 private UserPresetsAdapter mUserPresetsAdapter = null; 176 private CategoryAdapter mCategoryLooksAdapter = null; 177 private CategoryAdapter mCategoryBordersAdapter = null; 178 private CategoryAdapter mCategoryGeometryAdapter = null; 179 private CategoryAdapter mCategoryFiltersAdapter = null; 180 private CategoryAdapter mCategoryVersionsAdapter = null; 181 private int mCurrentPanel = MainPanel.LOOKS; 182 private Vector<FilterUserPresetRepresentation> mVersions = 183 new Vector<FilterUserPresetRepresentation>(); 184 private int mVersionsCounter = 0; 185 186 private boolean mHandlingSwipeButton = false; 187 private View mHandledSwipeView = null; 188 private float mHandledSwipeViewLastDelta = 0; 189 private float mSwipeStartX = 0; 190 private float mSwipeStartY = 0; 191 192 private ProcessingService mBoundService; 193 private boolean mIsBound = false; 194 private Menu mMenu; 195 private DialogInterface mCurrentDialog = null; 196 private PopupMenu mCurrentMenu = null; 197 private boolean mLoadingVisible = true; 198 getProcessingService()199 public ProcessingService getProcessingService() { 200 return mBoundService; 201 } 202 isSimpleEditAction()203 public boolean isSimpleEditAction() { 204 return !PhotoPage.ACTION_NEXTGEN_EDIT.equalsIgnoreCase(mAction); 205 } 206 207 private ServiceConnection mConnection = new ServiceConnection() { 208 @Override 209 public void onServiceConnected(ComponentName className, IBinder service) { 210 /* 211 * This is called when the connection with the service has been 212 * established, giving us the service object we can use to 213 * interact with the service. Because we have bound to a explicit 214 * service that we know is running in our own process, we can 215 * cast its IBinder to a concrete class and directly access it. 216 */ 217 mBoundService = ((ProcessingService.LocalBinder)service).getService(); 218 mBoundService.setFiltershowActivity(FilterShowActivity.this); 219 mBoundService.onStart(); 220 } 221 222 @Override 223 public void onServiceDisconnected(ComponentName className) { 224 /* 225 * This is called when the connection with the service has been 226 * unexpectedly disconnected -- that is, its process crashed. 227 * Because it is running in our same process, we should never 228 * see this happen. 229 */ 230 mBoundService = null; 231 } 232 }; 233 doBindService()234 void doBindService() { 235 /* 236 * Establish a connection with the service. We use an explicit 237 * class name because we want a specific service implementation that 238 * we know will be running in our own process (and thus won't be 239 * supporting component replacement by other applications). 240 */ 241 bindService(new Intent(FilterShowActivity.this, ProcessingService.class), 242 mConnection, Context.BIND_AUTO_CREATE); 243 mIsBound = true; 244 } 245 doUnbindService()246 void doUnbindService() { 247 if (mIsBound) { 248 // Detach our existing connection. 249 unbindService(mConnection); 250 mIsBound = false; 251 } 252 } 253 updateUIAfterServiceStarted()254 public void updateUIAfterServiceStarted() { 255 MasterImage.setMaster(mMasterImage); 256 ImageFilter.setActivityForMemoryToasts(this); 257 mUserPresetsManager = new UserPresetsManager(this); 258 mUserPresetsAdapter = new UserPresetsAdapter(this); 259 260 setupMasterImage(); 261 setupMenu(); 262 setDefaultValues(); 263 fillEditors(); 264 getWindow().setBackgroundDrawable(new ColorDrawable(0)); 265 loadXML(); 266 267 fillCategories(); 268 loadMainPanel(); 269 extractXMPData(); 270 processIntent(); 271 } 272 273 @Override onCreate(Bundle savedInstanceState)274 public void onCreate(Bundle savedInstanceState) { 275 super.onCreate(savedInstanceState); 276 277 boolean onlyUsePortrait = getResources().getBoolean(R.bool.only_use_portrait); 278 if (onlyUsePortrait) { 279 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 280 } 281 282 clearGalleryBitmapPool(); 283 doBindService(); 284 getWindow().setBackgroundDrawable(new ColorDrawable(Color.GRAY)); 285 setContentView(R.layout.filtershow_splashscreen); 286 } 287 isShowingImageStatePanel()288 public boolean isShowingImageStatePanel() { 289 return mShowingImageStatePanel; 290 } 291 loadMainPanel()292 public void loadMainPanel() { 293 if (findViewById(R.id.main_panel_container) == null) { 294 return; 295 } 296 MainPanel panel = new MainPanel(); 297 FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); 298 transaction.replace(R.id.main_panel_container, panel, MainPanel.FRAGMENT_TAG); 299 transaction.commitAllowingStateLoss(); 300 } 301 loadEditorPanel(FilterRepresentation representation, final Editor currentEditor)302 public void loadEditorPanel(FilterRepresentation representation, 303 final Editor currentEditor) { 304 if (representation.getEditorId() == ImageOnlyEditor.ID) { 305 currentEditor.reflectCurrentFilter(); 306 return; 307 } 308 final int currentId = currentEditor.getID(); 309 Runnable showEditor = new Runnable() { 310 @Override 311 public void run() { 312 EditorPanel panel = new EditorPanel(); 313 panel.setEditor(currentId); 314 FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); 315 transaction.remove(getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG)); 316 transaction.replace(R.id.main_panel_container, panel, MainPanel.FRAGMENT_TAG); 317 transaction.commit(); 318 } 319 }; 320 Fragment main = getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG); 321 boolean doAnimation = false; 322 if (mShowingImageStatePanel 323 && getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) { 324 doAnimation = true; 325 } 326 if (doAnimation && main != null && main instanceof MainPanel) { 327 MainPanel mainPanel = (MainPanel) main; 328 View container = mainPanel.getView().findViewById(R.id.category_panel_container); 329 View bottom = mainPanel.getView().findViewById(R.id.bottom_panel); 330 int panelHeight = container.getHeight() + bottom.getHeight(); 331 ViewPropertyAnimator anim = mainPanel.getView().animate(); 332 anim.translationY(panelHeight).start(); 333 final Handler handler = new Handler(); 334 handler.postDelayed(showEditor, anim.getDuration()); 335 } else { 336 showEditor.run(); 337 } 338 } 339 toggleInformationPanel()340 public void toggleInformationPanel() { 341 FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); 342 transaction.setCustomAnimations(R.anim.slide_in_right, R.anim.slide_out_left); 343 344 InfoPanel panel = new InfoPanel(); 345 panel.show(transaction, InfoPanel.FRAGMENT_TAG); 346 } 347 loadXML()348 private void loadXML() { 349 setContentView(R.layout.filtershow_activity); 350 351 ActionBar actionBar = getActionBar(); 352 actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM); 353 actionBar.setCustomView(R.layout.filtershow_actionbar); 354 actionBar.setBackgroundDrawable(new ColorDrawable( 355 getResources().getColor(R.color.background_screen))); 356 357 mSaveButton = actionBar.getCustomView(); 358 mSaveButton.setOnClickListener(new OnClickListener() { 359 @Override 360 public void onClick(View view) { 361 saveImage(); 362 } 363 }); 364 365 mImageShow = (ImageShow) findViewById(R.id.imageShow); 366 mImageViews.add(mImageShow); 367 368 setupEditors(); 369 370 mEditorPlaceHolder.hide(); 371 mImageShow.attach(); 372 373 setupStatePanel(); 374 } 375 fillCategories()376 public void fillCategories() { 377 fillLooks(); 378 loadUserPresets(); 379 fillBorders(); 380 fillTools(); 381 fillEffects(); 382 fillVersions(); 383 } 384 setupStatePanel()385 public void setupStatePanel() { 386 MasterImage.getImage().setHistoryManager(mMasterImage.getHistory()); 387 } 388 fillVersions()389 private void fillVersions() { 390 if (mCategoryVersionsAdapter != null) { 391 mCategoryVersionsAdapter.clear(); 392 } 393 mCategoryVersionsAdapter = new CategoryAdapter(this); 394 mCategoryVersionsAdapter.setShowAddButton(true); 395 } 396 registerAction(Action action)397 public void registerAction(Action action) { 398 if (mActions.contains(action)) { 399 return; 400 } 401 mActions.add(action); 402 } 403 loadActions()404 private void loadActions() { 405 for (int i = 0; i < mActions.size(); i++) { 406 Action action = mActions.get(i); 407 action.setImageFrame(new Rect(0, 0, 96, 96), 0); 408 } 409 } 410 updateVersions()411 public void updateVersions() { 412 mCategoryVersionsAdapter.clear(); 413 FilterUserPresetRepresentation originalRep = new FilterUserPresetRepresentation( 414 getString(R.string.filtershow_version_original), new ImagePreset(), -1); 415 mCategoryVersionsAdapter.add( 416 new Action(this, originalRep, Action.FULL_VIEW)); 417 ImagePreset current = new ImagePreset(MasterImage.getImage().getPreset()); 418 FilterUserPresetRepresentation currentRep = new FilterUserPresetRepresentation( 419 getString(R.string.filtershow_version_current), current, -1); 420 mCategoryVersionsAdapter.add( 421 new Action(this, currentRep, Action.FULL_VIEW)); 422 if (mVersions.size() > 0) { 423 mCategoryVersionsAdapter.add(new Action(this, Action.SPACER)); 424 } 425 for (FilterUserPresetRepresentation rep : mVersions) { 426 mCategoryVersionsAdapter.add( 427 new Action(this, rep, Action.FULL_VIEW, true)); 428 } 429 mCategoryVersionsAdapter.notifyDataSetInvalidated(); 430 } 431 addCurrentVersion()432 public void addCurrentVersion() { 433 ImagePreset current = new ImagePreset(MasterImage.getImage().getPreset()); 434 mVersionsCounter++; 435 FilterUserPresetRepresentation rep = new FilterUserPresetRepresentation( 436 "" + mVersionsCounter, current, -1); 437 mVersions.add(rep); 438 updateVersions(); 439 } 440 removeVersion(Action action)441 public void removeVersion(Action action) { 442 mVersions.remove(action.getRepresentation()); 443 updateVersions(); 444 } 445 removeLook(Action action)446 public void removeLook(Action action) { 447 FilterUserPresetRepresentation rep = 448 (FilterUserPresetRepresentation) action.getRepresentation(); 449 if (rep == null) { 450 return; 451 } 452 mUserPresetsManager.delete(rep.getId()); 453 updateUserPresetsFromManager(); 454 } 455 fillEffects()456 private void fillEffects() { 457 FiltersManager filtersManager = FiltersManager.getManager(); 458 ArrayList<FilterRepresentation> filtersRepresentations = filtersManager.getEffects(); 459 if (mCategoryFiltersAdapter != null) { 460 mCategoryFiltersAdapter.clear(); 461 } 462 mCategoryFiltersAdapter = new CategoryAdapter(this); 463 for (FilterRepresentation representation : filtersRepresentations) { 464 if (representation.getTextId() != 0) { 465 representation.setName(getString(representation.getTextId())); 466 } 467 mCategoryFiltersAdapter.add(new Action(this, representation)); 468 } 469 } 470 fillTools()471 private void fillTools() { 472 FiltersManager filtersManager = FiltersManager.getManager(); 473 ArrayList<FilterRepresentation> filtersRepresentations = filtersManager.getTools(); 474 if (mCategoryGeometryAdapter != null) { 475 mCategoryGeometryAdapter.clear(); 476 } 477 mCategoryGeometryAdapter = new CategoryAdapter(this); 478 boolean found = false; 479 for (FilterRepresentation representation : filtersRepresentations) { 480 mCategoryGeometryAdapter.add(new Action(this, representation)); 481 if (representation instanceof FilterDrawRepresentation) { 482 found = true; 483 } 484 } 485 if (!found) { 486 FilterRepresentation representation = new FilterDrawRepresentation(); 487 Action action = new Action(this, representation); 488 action.setIsDoubleAction(true); 489 mCategoryGeometryAdapter.add(action); 490 } 491 } 492 processIntent()493 private void processIntent() { 494 Intent intent = getIntent(); 495 if (intent.getBooleanExtra(LAUNCH_FULLSCREEN, false)) { 496 getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN); 497 } 498 499 mAction = intent.getAction(); 500 mSelectedImageUri = intent.getData(); 501 Uri loadUri = mSelectedImageUri; 502 if (mOriginalImageUri != null) { 503 loadUri = mOriginalImageUri; 504 } 505 if (loadUri != null) { 506 startLoadBitmap(loadUri); 507 } else { 508 pickImage(); 509 } 510 } 511 setupEditors()512 private void setupEditors() { 513 mEditorPlaceHolder.setContainer((FrameLayout) findViewById(R.id.editorContainer)); 514 EditorManager.addEditors(mEditorPlaceHolder); 515 mEditorPlaceHolder.setOldViews(mImageViews); 516 } 517 fillEditors()518 private void fillEditors() { 519 mEditorPlaceHolder.addEditor(new EditorChanSat()); 520 mEditorPlaceHolder.addEditor(new EditorGrad()); 521 mEditorPlaceHolder.addEditor(new EditorDraw()); 522 mEditorPlaceHolder.addEditor(new EditorColorBorder()); 523 mEditorPlaceHolder.addEditor(new BasicEditor()); 524 mEditorPlaceHolder.addEditor(new ImageOnlyEditor()); 525 mEditorPlaceHolder.addEditor(new EditorTinyPlanet()); 526 mEditorPlaceHolder.addEditor(new EditorRedEye()); 527 mEditorPlaceHolder.addEditor(new EditorCrop()); 528 mEditorPlaceHolder.addEditor(new EditorMirror()); 529 mEditorPlaceHolder.addEditor(new EditorRotate()); 530 mEditorPlaceHolder.addEditor(new EditorStraighten()); 531 } 532 setDefaultValues()533 private void setDefaultValues() { 534 Resources res = getResources(); 535 536 // TODO: get those values from XML. 537 FramedTextButton.setTextSize((int) getPixelsFromDip(14)); 538 FramedTextButton.setTrianglePadding((int) getPixelsFromDip(4)); 539 FramedTextButton.setTriangleSize((int) getPixelsFromDip(10)); 540 541 Drawable curveHandle = res.getDrawable(R.drawable.camera_crop); 542 int curveHandleSize = (int) res.getDimension(R.dimen.crop_indicator_size); 543 Spline.setCurveHandle(curveHandle, curveHandleSize); 544 Spline.setCurveWidth((int) getPixelsFromDip(3)); 545 546 mOriginalImageUri = null; 547 } 548 startLoadBitmap(Uri uri)549 private void startLoadBitmap(Uri uri) { 550 final View imageShow = findViewById(R.id.imageShow); 551 imageShow.setVisibility(View.INVISIBLE); 552 startLoadingIndicator(); 553 mShowingTinyPlanet = false; 554 mLoadBitmapTask = new LoadBitmapTask(); 555 mLoadBitmapTask.execute(uri); 556 } 557 fillBorders()558 private void fillBorders() { 559 FiltersManager filtersManager = FiltersManager.getManager(); 560 ArrayList<FilterRepresentation> borders = filtersManager.getBorders(); 561 562 for (int i = 0; i < borders.size(); i++) { 563 FilterRepresentation filter = borders.get(i); 564 filter.setName(getString(R.string.borders)); 565 if (i == 0) { 566 filter.setName(getString(R.string.none)); 567 } 568 } 569 570 if (mCategoryBordersAdapter != null) { 571 mCategoryBordersAdapter.clear(); 572 } 573 mCategoryBordersAdapter = new CategoryAdapter(this); 574 for (FilterRepresentation representation : borders) { 575 if (representation.getTextId() != 0) { 576 representation.setName(getString(representation.getTextId())); 577 } 578 mCategoryBordersAdapter.add(new Action(this, representation, Action.FULL_VIEW)); 579 } 580 } 581 getUserPresetsAdapter()582 public UserPresetsAdapter getUserPresetsAdapter() { 583 return mUserPresetsAdapter; 584 } 585 getCategoryLooksAdapter()586 public CategoryAdapter getCategoryLooksAdapter() { 587 return mCategoryLooksAdapter; 588 } 589 getCategoryBordersAdapter()590 public CategoryAdapter getCategoryBordersAdapter() { 591 return mCategoryBordersAdapter; 592 } 593 getCategoryGeometryAdapter()594 public CategoryAdapter getCategoryGeometryAdapter() { 595 return mCategoryGeometryAdapter; 596 } 597 getCategoryFiltersAdapter()598 public CategoryAdapter getCategoryFiltersAdapter() { 599 return mCategoryFiltersAdapter; 600 } 601 getCategoryVersionsAdapter()602 public CategoryAdapter getCategoryVersionsAdapter() { 603 return mCategoryVersionsAdapter; 604 } 605 removeFilterRepresentation(FilterRepresentation filterRepresentation)606 public void removeFilterRepresentation(FilterRepresentation filterRepresentation) { 607 if (filterRepresentation == null) { 608 return; 609 } 610 ImagePreset oldPreset = MasterImage.getImage().getPreset(); 611 ImagePreset copy = new ImagePreset(oldPreset); 612 copy.removeFilter(filterRepresentation); 613 MasterImage.getImage().setPreset(copy, copy.getLastRepresentation(), true); 614 if (MasterImage.getImage().getCurrentFilterRepresentation() == filterRepresentation) { 615 FilterRepresentation lastRepresentation = copy.getLastRepresentation(); 616 MasterImage.getImage().setCurrentFilterRepresentation(lastRepresentation); 617 } 618 } 619 useFilterRepresentation(FilterRepresentation filterRepresentation)620 public void useFilterRepresentation(FilterRepresentation filterRepresentation) { 621 if (filterRepresentation == null) { 622 return; 623 } 624 if (!(filterRepresentation instanceof FilterRotateRepresentation) 625 && !(filterRepresentation instanceof FilterMirrorRepresentation) 626 && MasterImage.getImage().getCurrentFilterRepresentation() == filterRepresentation) { 627 return; 628 } 629 if (filterRepresentation instanceof FilterUserPresetRepresentation 630 || filterRepresentation instanceof FilterRotateRepresentation 631 || filterRepresentation instanceof FilterMirrorRepresentation) { 632 MasterImage.getImage().onNewLook(filterRepresentation); 633 } 634 ImagePreset oldPreset = MasterImage.getImage().getPreset(); 635 ImagePreset copy = new ImagePreset(oldPreset); 636 FilterRepresentation representation = copy.getRepresentation(filterRepresentation); 637 if (representation == null) { 638 filterRepresentation = filterRepresentation.copy(); 639 copy.addFilter(filterRepresentation); 640 } else { 641 if (filterRepresentation.allowsSingleInstanceOnly()) { 642 // Don't just update the filter representation. Centralize the 643 // logic in the addFilter(), such that we can keep "None" as 644 // null. 645 if (!representation.equals(filterRepresentation)) { 646 // Only do this if the filter isn't the same 647 // (state panel clicks can lead us here) 648 copy.removeFilter(representation); 649 copy.addFilter(filterRepresentation); 650 } 651 } 652 } 653 MasterImage.getImage().setPreset(copy, filterRepresentation, true); 654 MasterImage.getImage().setCurrentFilterRepresentation(filterRepresentation); 655 } 656 showRepresentation(FilterRepresentation representation)657 public void showRepresentation(FilterRepresentation representation) { 658 if (representation == null) { 659 return; 660 } 661 662 if (representation instanceof FilterRotateRepresentation) { 663 FilterRotateRepresentation r = (FilterRotateRepresentation) representation; 664 r.rotateCW(); 665 } 666 if (representation instanceof FilterMirrorRepresentation) { 667 FilterMirrorRepresentation r = (FilterMirrorRepresentation) representation; 668 r.cycle(); 669 } 670 if (representation.isBooleanFilter()) { 671 ImagePreset preset = MasterImage.getImage().getPreset(); 672 if (preset.getRepresentation(representation) != null) { 673 // remove 674 ImagePreset copy = new ImagePreset(preset); 675 copy.removeFilter(representation); 676 FilterRepresentation filterRepresentation = representation.copy(); 677 MasterImage.getImage().setPreset(copy, filterRepresentation, true); 678 MasterImage.getImage().setCurrentFilterRepresentation(null); 679 return; 680 } 681 } 682 useFilterRepresentation(representation); 683 684 // show representation 685 if (mCurrentEditor != null) { 686 mCurrentEditor.detach(); 687 } 688 mCurrentEditor = mEditorPlaceHolder.showEditor(representation.getEditorId()); 689 loadEditorPanel(representation, mCurrentEditor); 690 } 691 getEditor(int editorID)692 public Editor getEditor(int editorID) { 693 return mEditorPlaceHolder.getEditor(editorID); 694 } 695 setCurrentPanel(int currentPanel)696 public void setCurrentPanel(int currentPanel) { 697 mCurrentPanel = currentPanel; 698 } 699 getCurrentPanel()700 public int getCurrentPanel() { 701 return mCurrentPanel; 702 } 703 updateCategories()704 public void updateCategories() { 705 if (mMasterImage == null) { 706 return; 707 } 708 ImagePreset preset = mMasterImage.getPreset(); 709 mCategoryLooksAdapter.reflectImagePreset(preset); 710 mCategoryBordersAdapter.reflectImagePreset(preset); 711 } 712 getMainStatePanelContainer(int id)713 public View getMainStatePanelContainer(int id) { 714 return findViewById(id); 715 } 716 onShowMenu(PopupMenu menu)717 public void onShowMenu(PopupMenu menu) { 718 mCurrentMenu = menu; 719 menu.setOnDismissListener(this); 720 } 721 722 @Override onDismiss(PopupMenu popupMenu)723 public void onDismiss(PopupMenu popupMenu){ 724 if (mCurrentMenu == null) { 725 return; 726 } 727 mCurrentMenu.setOnDismissListener(null); 728 mCurrentMenu = null; 729 } 730 731 @Override onShow(DialogInterface dialog)732 public void onShow(DialogInterface dialog) { 733 mCurrentDialog = dialog; 734 } 735 736 @Override onDismiss(DialogInterface dialogInterface)737 public void onDismiss(DialogInterface dialogInterface) { 738 mCurrentDialog = null; 739 } 740 741 private class LoadHighresBitmapTask extends AsyncTask<Void, Void, Boolean> { 742 @Override doInBackground(Void... params)743 protected Boolean doInBackground(Void... params) { 744 MasterImage master = MasterImage.getImage(); 745 Rect originalBounds = master.getOriginalBounds(); 746 if (master.supportsHighRes()) { 747 int highresPreviewSize = master.getOriginalBitmapLarge().getWidth() * 2; 748 if (highresPreviewSize > originalBounds.width()) { 749 highresPreviewSize = originalBounds.width(); 750 } 751 Rect bounds = new Rect(); 752 Bitmap originalHires = ImageLoader.loadOrientedConstrainedBitmap(master.getUri(), 753 master.getActivity(), highresPreviewSize, 754 master.getOrientation(), bounds); 755 master.setOriginalBounds(bounds); 756 master.setOriginalBitmapHighres(originalHires); 757 mBoundService.setOriginalBitmapHighres(originalHires); 758 master.warnListeners(); 759 } 760 return true; 761 } 762 763 @Override onPostExecute(Boolean result)764 protected void onPostExecute(Boolean result) { 765 Bitmap highresBitmap = MasterImage.getImage().getOriginalBitmapHighres(); 766 if (highresBitmap != null) { 767 float highResPreviewScale = (float) highresBitmap.getWidth() 768 / (float) MasterImage.getImage().getOriginalBounds().width(); 769 mBoundService.setHighresPreviewScaleFactor(highResPreviewScale); 770 } 771 MasterImage.getImage().warnListeners(); 772 } 773 } 774 isLoadingVisible()775 public boolean isLoadingVisible() { 776 return mLoadingVisible; 777 } 778 startLoadingIndicator()779 public void startLoadingIndicator() { 780 final View loading = findViewById(R.id.loading); 781 mLoadingVisible = true; 782 loading.setVisibility(View.VISIBLE); 783 } 784 stopLoadingIndicator()785 public void stopLoadingIndicator() { 786 final View loading = findViewById(R.id.loading); 787 loading.setVisibility(View.GONE); 788 mLoadingVisible = false; 789 } 790 791 private class LoadBitmapTask extends AsyncTask<Uri, Boolean, Boolean> { 792 int mBitmapSize; 793 LoadBitmapTask()794 public LoadBitmapTask() { 795 mBitmapSize = getScreenImageSize(); 796 } 797 798 @Override doInBackground(Uri... params)799 protected Boolean doInBackground(Uri... params) { 800 if (!MasterImage.getImage().loadBitmap(params[0], mBitmapSize)) { 801 return false; 802 } 803 publishProgress(ImageLoader.queryLightCycle360(MasterImage.getImage().getActivity())); 804 return true; 805 } 806 807 @Override onProgressUpdate(Boolean... values)808 protected void onProgressUpdate(Boolean... values) { 809 super.onProgressUpdate(values); 810 if (isCancelled()) { 811 return; 812 } 813 if (values[0]) { 814 mShowingTinyPlanet = true; 815 } 816 } 817 818 @Override onPostExecute(Boolean result)819 protected void onPostExecute(Boolean result) { 820 MasterImage.setMaster(mMasterImage); 821 if (isCancelled()) { 822 return; 823 } 824 825 if (!result) { 826 if (mOriginalImageUri != null 827 && !mOriginalImageUri.equals(mSelectedImageUri)) { 828 mOriginalImageUri = mSelectedImageUri; 829 mOriginalPreset = null; 830 Toast.makeText(FilterShowActivity.this, 831 R.string.cannot_edit_original, Toast.LENGTH_SHORT).show(); 832 startLoadBitmap(mOriginalImageUri); 833 } else { 834 cannotLoadImage(); 835 } 836 return; 837 } 838 839 if (null == CachingPipeline.getRenderScriptContext()){ 840 Log.v(LOGTAG,"RenderScript context destroyed during load"); 841 return; 842 } 843 final View imageShow = findViewById(R.id.imageShow); 844 imageShow.setVisibility(View.VISIBLE); 845 846 847 Bitmap largeBitmap = MasterImage.getImage().getOriginalBitmapLarge(); 848 mBoundService.setOriginalBitmap(largeBitmap); 849 850 float previewScale = (float) largeBitmap.getWidth() 851 / (float) MasterImage.getImage().getOriginalBounds().width(); 852 mBoundService.setPreviewScaleFactor(previewScale); 853 if (!mShowingTinyPlanet) { 854 mCategoryFiltersAdapter.removeTinyPlanet(); 855 } 856 mCategoryLooksAdapter.imageLoaded(); 857 mCategoryBordersAdapter.imageLoaded(); 858 mCategoryGeometryAdapter.imageLoaded(); 859 mCategoryFiltersAdapter.imageLoaded(); 860 mLoadBitmapTask = null; 861 862 MasterImage.getImage().warnListeners(); 863 loadActions(); 864 865 if (mOriginalPreset != null) { 866 MasterImage.getImage().setLoadedPreset(mOriginalPreset); 867 MasterImage.getImage().setPreset(mOriginalPreset, 868 mOriginalPreset.getLastRepresentation(), true); 869 mOriginalPreset = null; 870 } else { 871 setDefaultPreset(); 872 } 873 874 MasterImage.getImage().resetGeometryImages(true); 875 876 if (mAction == TINY_PLANET_ACTION) { 877 showRepresentation(mCategoryFiltersAdapter.getTinyPlanet()); 878 } 879 LoadHighresBitmapTask highresLoad = new LoadHighresBitmapTask(); 880 highresLoad.execute(); 881 MasterImage.getImage().warnListeners(); 882 super.onPostExecute(result); 883 } 884 885 } 886 clearGalleryBitmapPool()887 private void clearGalleryBitmapPool() { 888 (new AsyncTask<Void, Void, Void>() { 889 @Override 890 protected Void doInBackground(Void... params) { 891 // Free memory held in Gallery's Bitmap pool. May be O(n) for n bitmaps. 892 GalleryBitmapPool.getInstance().clear(); 893 return null; 894 } 895 }).execute(); 896 } 897 898 @Override onDestroy()899 protected void onDestroy() { 900 if (mLoadBitmapTask != null) { 901 mLoadBitmapTask.cancel(false); 902 } 903 mUserPresetsManager.close(); 904 doUnbindService(); 905 super.onDestroy(); 906 } 907 908 // TODO: find a more robust way of handling image size selection 909 // for high screen densities. getScreenImageSize()910 private int getScreenImageSize() { 911 DisplayMetrics outMetrics = new DisplayMetrics(); 912 getWindowManager().getDefaultDisplay().getMetrics(outMetrics); 913 return Math.max(outMetrics.heightPixels, outMetrics.widthPixels); 914 } 915 showSavingProgress(String albumName)916 private void showSavingProgress(String albumName) { 917 ProgressDialog progress; 918 if (mSavingProgressDialog != null) { 919 progress = mSavingProgressDialog.get(); 920 if (progress != null) { 921 progress.show(); 922 return; 923 } 924 } 925 // TODO: Allow cancellation of the saving process 926 String progressText; 927 if (albumName == null) { 928 progressText = getString(R.string.saving_image); 929 } else { 930 progressText = getString(R.string.filtershow_saving_image, albumName); 931 } 932 progress = ProgressDialog.show(this, "", progressText, true, false); 933 mSavingProgressDialog = new WeakReference<ProgressDialog>(progress); 934 } 935 hideSavingProgress()936 private void hideSavingProgress() { 937 if (mSavingProgressDialog != null) { 938 ProgressDialog progress = mSavingProgressDialog.get(); 939 if (progress != null) 940 progress.dismiss(); 941 } 942 } 943 completeSaveImage(Uri saveUri)944 public void completeSaveImage(Uri saveUri) { 945 if (mSharingImage && mSharedOutputFile != null) { 946 // Image saved, we unblock the content provider 947 Uri uri = Uri.withAppendedPath(SharedImageProvider.CONTENT_URI, 948 Uri.encode(mSharedOutputFile.getAbsolutePath())); 949 ContentValues values = new ContentValues(); 950 values.put(SharedImageProvider.PREPARE, false); 951 getContentResolver().insert(uri, values); 952 } 953 setResult(RESULT_OK, new Intent().setData(saveUri)); 954 hideSavingProgress(); 955 finish(); 956 } 957 958 @Override onShareTargetSelected(ShareActionProvider arg0, Intent arg1)959 public boolean onShareTargetSelected(ShareActionProvider arg0, Intent arg1) { 960 // First, let's tell the SharedImageProvider that it will need to wait 961 // for the image 962 Uri uri = Uri.withAppendedPath(SharedImageProvider.CONTENT_URI, 963 Uri.encode(mSharedOutputFile.getAbsolutePath())); 964 ContentValues values = new ContentValues(); 965 values.put(SharedImageProvider.PREPARE, true); 966 getContentResolver().insert(uri, values); 967 mSharingImage = true; 968 969 // Process and save the image in the background. 970 showSavingProgress(null); 971 mImageShow.saveImage(this, mSharedOutputFile); 972 return true; 973 } 974 getDefaultShareIntent()975 private Intent getDefaultShareIntent() { 976 Intent intent = new Intent(Intent.ACTION_SEND); 977 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); 978 intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 979 intent.setType(SharedImageProvider.MIME_TYPE); 980 mSharedOutputFile = SaveImage.getNewFile(this, MasterImage.getImage().getUri()); 981 Uri uri = Uri.withAppendedPath(SharedImageProvider.CONTENT_URI, 982 Uri.encode(mSharedOutputFile.getAbsolutePath())); 983 intent.putExtra(Intent.EXTRA_STREAM, uri); 984 return intent; 985 } 986 987 @Override onCreateOptionsMenu(Menu menu)988 public boolean onCreateOptionsMenu(Menu menu) { 989 getMenuInflater().inflate(R.menu.filtershow_activity_menu, menu); 990 MenuItem showState = menu.findItem(R.id.showImageStateButton); 991 if (mShowingImageStatePanel) { 992 showState.setTitle(R.string.hide_imagestate_panel); 993 } else { 994 showState.setTitle(R.string.show_imagestate_panel); 995 } 996 mShareActionProvider = (ShareActionProvider) menu.findItem(R.id.menu_share) 997 .getActionProvider(); 998 mShareActionProvider.setShareIntent(getDefaultShareIntent()); 999 mShareActionProvider.setOnShareTargetSelectedListener(this); 1000 mMenu = menu; 1001 setupMenu(); 1002 return true; 1003 } 1004 setupMenu()1005 private void setupMenu(){ 1006 if (mMenu == null || mMasterImage == null) { 1007 return; 1008 } 1009 MenuItem undoItem = mMenu.findItem(R.id.undoButton); 1010 MenuItem redoItem = mMenu.findItem(R.id.redoButton); 1011 MenuItem resetItem = mMenu.findItem(R.id.resetHistoryButton); 1012 MenuItem printItem = mMenu.findItem(R.id.printButton); 1013 if (!PrintHelper.systemSupportsPrint()) { 1014 printItem.setVisible(false); 1015 } 1016 mMasterImage.getHistory().setMenuItems(undoItem, redoItem, resetItem); 1017 } 1018 1019 @Override onPause()1020 public void onPause() { 1021 super.onPause(); 1022 if (mShareActionProvider != null) { 1023 mShareActionProvider.setOnShareTargetSelectedListener(null); 1024 } 1025 } 1026 1027 @Override onResume()1028 public void onResume() { 1029 super.onResume(); 1030 if (mShareActionProvider != null) { 1031 mShareActionProvider.setOnShareTargetSelectedListener(this); 1032 } 1033 } 1034 1035 @Override onOptionsItemSelected(MenuItem item)1036 public boolean onOptionsItemSelected(MenuItem item) { 1037 switch (item.getItemId()) { 1038 case R.id.undoButton: { 1039 HistoryManager adapter = mMasterImage.getHistory(); 1040 int position = adapter.undo(); 1041 mMasterImage.onHistoryItemClick(position); 1042 backToMain(); 1043 invalidateViews(); 1044 return true; 1045 } 1046 case R.id.redoButton: { 1047 HistoryManager adapter = mMasterImage.getHistory(); 1048 int position = adapter.redo(); 1049 mMasterImage.onHistoryItemClick(position); 1050 invalidateViews(); 1051 return true; 1052 } 1053 case R.id.resetHistoryButton: { 1054 resetHistory(); 1055 return true; 1056 } 1057 case R.id.showImageStateButton: { 1058 toggleImageStatePanel(); 1059 return true; 1060 } 1061 case R.id.exportFlattenButton: { 1062 showExportOptionsDialog(); 1063 return true; 1064 } 1065 case android.R.id.home: { 1066 saveImage(); 1067 return true; 1068 } 1069 case R.id.manageUserPresets: { 1070 manageUserPresets(); 1071 return true; 1072 } 1073 case R.id.showInfoPanel: { 1074 toggleInformationPanel(); 1075 return true; 1076 } 1077 case R.id.printButton: { 1078 print(); 1079 return true; 1080 } 1081 } 1082 return false; 1083 } 1084 print()1085 public void print() { 1086 Bitmap bitmap = MasterImage.getImage().getHighresImage(); 1087 PrintHelper printer = new PrintHelper(this); 1088 printer.printBitmap("ImagePrint", bitmap); 1089 } 1090 addNewPreset()1091 public void addNewPreset() { 1092 DialogFragment dialog = new PresetManagementDialog(); 1093 dialog.show(getSupportFragmentManager(), "NoticeDialogFragment"); 1094 } 1095 manageUserPresets()1096 private void manageUserPresets() { 1097 DialogFragment dialog = new PresetManagementDialog(); 1098 dialog.show(getSupportFragmentManager(), "NoticeDialogFragment"); 1099 } 1100 showExportOptionsDialog()1101 private void showExportOptionsDialog() { 1102 DialogFragment dialog = new ExportDialog(); 1103 dialog.show(getSupportFragmentManager(), "ExportDialogFragment"); 1104 } 1105 updateUserPresetsFromAdapter(UserPresetsAdapter adapter)1106 public void updateUserPresetsFromAdapter(UserPresetsAdapter adapter) { 1107 ArrayList<FilterUserPresetRepresentation> representations = 1108 adapter.getDeletedRepresentations(); 1109 for (FilterUserPresetRepresentation representation : representations) { 1110 deletePreset(representation.getId()); 1111 } 1112 ArrayList<FilterUserPresetRepresentation> changedRepresentations = 1113 adapter.getChangedRepresentations(); 1114 for (FilterUserPresetRepresentation representation : changedRepresentations) { 1115 updatePreset(representation); 1116 } 1117 adapter.clearDeletedRepresentations(); 1118 adapter.clearChangedRepresentations(); 1119 loadUserPresets(); 1120 } 1121 loadUserPresets()1122 public void loadUserPresets() { 1123 mUserPresetsManager.load(); 1124 updateUserPresetsFromManager(); 1125 } 1126 updateUserPresetsFromManager()1127 public void updateUserPresetsFromManager() { 1128 ArrayList<FilterUserPresetRepresentation> presets = mUserPresetsManager.getRepresentations(); 1129 if (presets == null) { 1130 return; 1131 } 1132 if (mCategoryLooksAdapter != null) { 1133 fillLooks(); 1134 } 1135 if (presets.size() > 0) { 1136 mCategoryLooksAdapter.add(new Action(this, Action.SPACER)); 1137 } 1138 mUserPresetsAdapter.clear(); 1139 for (int i = 0; i < presets.size(); i++) { 1140 FilterUserPresetRepresentation representation = presets.get(i); 1141 mCategoryLooksAdapter.add( 1142 new Action(this, representation, Action.FULL_VIEW, true)); 1143 mUserPresetsAdapter.add(new Action(this, representation, Action.FULL_VIEW)); 1144 } 1145 if (presets.size() > 0) { 1146 mCategoryLooksAdapter.add(new Action(this, Action.ADD_ACTION)); 1147 } 1148 mCategoryLooksAdapter.notifyDataSetChanged(); 1149 mCategoryLooksAdapter.notifyDataSetInvalidated(); 1150 } 1151 saveCurrentImagePreset(String name)1152 public void saveCurrentImagePreset(String name) { 1153 mUserPresetsManager.save(MasterImage.getImage().getPreset(), name); 1154 } 1155 deletePreset(int id)1156 private void deletePreset(int id) { 1157 mUserPresetsManager.delete(id); 1158 } 1159 updatePreset(FilterUserPresetRepresentation representation)1160 private void updatePreset(FilterUserPresetRepresentation representation) { 1161 mUserPresetsManager.update(representation); 1162 } 1163 enableSave(boolean enable)1164 public void enableSave(boolean enable) { 1165 if (mSaveButton != null) { 1166 mSaveButton.setEnabled(enable); 1167 } 1168 } 1169 fillLooks()1170 private void fillLooks() { 1171 FiltersManager filtersManager = FiltersManager.getManager(); 1172 ArrayList<FilterRepresentation> filtersRepresentations = filtersManager.getLooks(); 1173 1174 if (mCategoryLooksAdapter != null) { 1175 mCategoryLooksAdapter.clear(); 1176 } 1177 mCategoryLooksAdapter = new CategoryAdapter(this); 1178 int verticalItemHeight = (int) getResources().getDimension(R.dimen.action_item_height); 1179 mCategoryLooksAdapter.setItemHeight(verticalItemHeight); 1180 for (FilterRepresentation representation : filtersRepresentations) { 1181 mCategoryLooksAdapter.add(new Action(this, representation, Action.FULL_VIEW)); 1182 } 1183 if (mUserPresetsManager.getRepresentations() == null 1184 || mUserPresetsManager.getRepresentations().size() == 0) { 1185 mCategoryLooksAdapter.add(new Action(this, Action.ADD_ACTION)); 1186 } 1187 1188 Fragment panel = getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG); 1189 if (panel != null) { 1190 if (panel instanceof MainPanel) { 1191 MainPanel mainPanel = (MainPanel) panel; 1192 mainPanel.loadCategoryLookPanel(true); 1193 } 1194 } 1195 } 1196 setDefaultPreset()1197 public void setDefaultPreset() { 1198 // Default preset (original) 1199 ImagePreset preset = new ImagePreset(); // empty 1200 mMasterImage.setPreset(preset, preset.getLastRepresentation(), true); 1201 } 1202 1203 // ////////////////////////////////////////////////////////////////////////////// 1204 // Some utility functions 1205 // TODO: finish the cleanup. 1206 invalidateViews()1207 public void invalidateViews() { 1208 for (ImageShow views : mImageViews) { 1209 views.updateImage(); 1210 } 1211 } 1212 hideImageViews()1213 public void hideImageViews() { 1214 for (View view : mImageViews) { 1215 view.setVisibility(View.GONE); 1216 } 1217 mEditorPlaceHolder.hide(); 1218 } 1219 1220 // ////////////////////////////////////////////////////////////////////////////// 1221 // imageState panel... 1222 toggleImageStatePanel()1223 public void toggleImageStatePanel() { 1224 invalidateOptionsMenu(); 1225 mShowingImageStatePanel = !mShowingImageStatePanel; 1226 Fragment panel = getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG); 1227 if (panel != null) { 1228 if (panel instanceof EditorPanel) { 1229 EditorPanel editorPanel = (EditorPanel) panel; 1230 editorPanel.showImageStatePanel(mShowingImageStatePanel); 1231 } else if (panel instanceof MainPanel) { 1232 MainPanel mainPanel = (MainPanel) panel; 1233 mainPanel.showImageStatePanel(mShowingImageStatePanel); 1234 } 1235 } 1236 } 1237 toggleVersionsPanel()1238 public void toggleVersionsPanel() { 1239 mShowingVersionsPanel = !mShowingVersionsPanel; 1240 Fragment panel = getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG); 1241 if (panel != null && panel instanceof MainPanel) { 1242 MainPanel mainPanel = (MainPanel) panel; 1243 mainPanel.loadCategoryVersionsPanel(); 1244 } 1245 } 1246 1247 @Override onConfigurationChanged(Configuration newConfig)1248 public void onConfigurationChanged(Configuration newConfig) 1249 { 1250 super.onConfigurationChanged(newConfig); 1251 1252 setDefaultValues(); 1253 if (mMasterImage == null) { 1254 return; 1255 } 1256 loadXML(); 1257 fillCategories(); 1258 loadMainPanel(); 1259 1260 if (mCurrentMenu != null) { 1261 mCurrentMenu.dismiss(); 1262 mCurrentMenu = null; 1263 } 1264 if (mCurrentDialog != null) { 1265 mCurrentDialog.dismiss(); 1266 mCurrentDialog = null; 1267 } 1268 // mLoadBitmapTask==null implies you have looked at the intent 1269 if (!mShowingTinyPlanet && (mLoadBitmapTask == null)) { 1270 mCategoryFiltersAdapter.removeTinyPlanet(); 1271 } 1272 stopLoadingIndicator(); 1273 } 1274 setupMasterImage()1275 public void setupMasterImage() { 1276 1277 HistoryManager historyManager = new HistoryManager(); 1278 StateAdapter imageStateAdapter = new StateAdapter(this, 0); 1279 MasterImage.reset(); 1280 mMasterImage = MasterImage.getImage(); 1281 mMasterImage.setHistoryManager(historyManager); 1282 mMasterImage.setStateAdapter(imageStateAdapter); 1283 mMasterImage.setActivity(this); 1284 1285 if (Runtime.getRuntime().maxMemory() > LIMIT_SUPPORTS_HIGHRES) { 1286 mMasterImage.setSupportsHighRes(true); 1287 } else { 1288 mMasterImage.setSupportsHighRes(false); 1289 } 1290 } 1291 resetHistory()1292 void resetHistory() { 1293 HistoryManager adapter = mMasterImage.getHistory(); 1294 adapter.reset(); 1295 HistoryItem historyItem = adapter.getItem(0); 1296 ImagePreset original = null; 1297 if (RESET_TO_LOADED) { 1298 original = new ImagePreset(historyItem.getImagePreset()); 1299 } else { 1300 original = new ImagePreset(); 1301 } 1302 FilterRepresentation rep = null; 1303 if (historyItem != null) { 1304 rep = historyItem.getFilterRepresentation(); 1305 } 1306 mMasterImage.setPreset(original, rep, true); 1307 invalidateViews(); 1308 backToMain(); 1309 } 1310 showDefaultImageView()1311 public void showDefaultImageView() { 1312 mEditorPlaceHolder.hide(); 1313 mImageShow.setVisibility(View.VISIBLE); 1314 MasterImage.getImage().setCurrentFilter(null); 1315 MasterImage.getImage().setCurrentFilterRepresentation(null); 1316 } 1317 backToMain()1318 public void backToMain() { 1319 Fragment currentPanel = getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG); 1320 if (currentPanel instanceof MainPanel) { 1321 return; 1322 } 1323 loadMainPanel(); 1324 showDefaultImageView(); 1325 } 1326 1327 @Override onBackPressed()1328 public void onBackPressed() { 1329 Fragment currentPanel = getSupportFragmentManager().findFragmentByTag(MainPanel.FRAGMENT_TAG); 1330 if (currentPanel instanceof MainPanel) { 1331 if (!mImageShow.hasModifications()) { 1332 done(); 1333 } else { 1334 AlertDialog.Builder builder = new AlertDialog.Builder(this); 1335 builder.setMessage(R.string.unsaved).setTitle(R.string.save_before_exit); 1336 builder.setPositiveButton(R.string.save_and_exit, new DialogInterface.OnClickListener() { 1337 @Override 1338 public void onClick(DialogInterface dialog, int id) { 1339 saveImage(); 1340 } 1341 }); 1342 builder.setNegativeButton(R.string.exit, new DialogInterface.OnClickListener() { 1343 @Override 1344 public void onClick(DialogInterface dialog, int id) { 1345 done(); 1346 } 1347 }); 1348 builder.show(); 1349 } 1350 } else { 1351 backToMain(); 1352 } 1353 } 1354 cannotLoadImage()1355 public void cannotLoadImage() { 1356 Toast.makeText(this, R.string.cannot_load_image, Toast.LENGTH_SHORT).show(); 1357 finish(); 1358 } 1359 1360 // ////////////////////////////////////////////////////////////////////////////// 1361 getPixelsFromDip(float value)1362 public float getPixelsFromDip(float value) { 1363 Resources r = getResources(); 1364 return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value, 1365 r.getDisplayMetrics()); 1366 } 1367 1368 @Override onItemClick(AdapterView<?> parent, View view, int position, long id)1369 public void onItemClick(AdapterView<?> parent, View view, int position, 1370 long id) { 1371 mMasterImage.onHistoryItemClick(position); 1372 invalidateViews(); 1373 } 1374 pickImage()1375 public void pickImage() { 1376 Intent intent = new Intent(); 1377 intent.setType("image/*"); 1378 intent.setAction(Intent.ACTION_GET_CONTENT); 1379 startActivityForResult(Intent.createChooser(intent, getString(R.string.select_image)), 1380 SELECT_PICTURE); 1381 } 1382 1383 @Override onActivityResult(int requestCode, int resultCode, Intent data)1384 public void onActivityResult(int requestCode, int resultCode, Intent data) { 1385 if (resultCode == RESULT_OK) { 1386 if (requestCode == SELECT_PICTURE) { 1387 Uri selectedImageUri = data.getData(); 1388 startLoadBitmap(selectedImageUri); 1389 } 1390 } 1391 } 1392 1393 saveImage()1394 public void saveImage() { 1395 if (mImageShow.hasModifications()) { 1396 // Get the name of the album, to which the image will be saved 1397 File saveDir = SaveImage.getFinalSaveDirectory(this, mSelectedImageUri); 1398 int bucketId = GalleryUtils.getBucketId(saveDir.getPath()); 1399 String albumName = LocalAlbum.getLocalizedName(getResources(), bucketId, null); 1400 showSavingProgress(albumName); 1401 mImageShow.saveImage(this, null); 1402 } else { 1403 done(); 1404 } 1405 } 1406 1407 done()1408 public void done() { 1409 hideSavingProgress(); 1410 if (mLoadBitmapTask != null) { 1411 mLoadBitmapTask.cancel(false); 1412 } 1413 finish(); 1414 } 1415 extractXMPData()1416 private void extractXMPData() { 1417 XMresults res = XmpPresets.extractXMPData( 1418 getBaseContext(), mMasterImage, getIntent().getData()); 1419 if (res == null) 1420 return; 1421 1422 mOriginalImageUri = res.originalimage; 1423 mOriginalPreset = res.preset; 1424 } 1425 getSelectedImageUri()1426 public Uri getSelectedImageUri() { 1427 return mSelectedImageUri; 1428 } 1429 setHandlesSwipeForView(View view, float startX, float startY)1430 public void setHandlesSwipeForView(View view, float startX, float startY) { 1431 if (view != null) { 1432 mHandlingSwipeButton = true; 1433 } else { 1434 mHandlingSwipeButton = false; 1435 } 1436 mHandledSwipeView = view; 1437 int[] location = new int[2]; 1438 view.getLocationInWindow(location); 1439 mSwipeStartX = location[0] + startX; 1440 mSwipeStartY = location[1] + startY; 1441 } 1442 dispatchTouchEvent(MotionEvent ev)1443 public boolean dispatchTouchEvent (MotionEvent ev) { 1444 if (mHandlingSwipeButton) { 1445 int direction = CategoryView.HORIZONTAL; 1446 if (mHandledSwipeView instanceof CategoryView) { 1447 direction = ((CategoryView) mHandledSwipeView).getOrientation(); 1448 } 1449 if (ev.getActionMasked() == MotionEvent.ACTION_MOVE) { 1450 float delta = ev.getY() - mSwipeStartY; 1451 float distance = mHandledSwipeView.getHeight(); 1452 if (direction == CategoryView.VERTICAL) { 1453 delta = ev.getX() - mSwipeStartX; 1454 mHandledSwipeView.setTranslationX(delta); 1455 distance = mHandledSwipeView.getWidth(); 1456 } else { 1457 mHandledSwipeView.setTranslationY(delta); 1458 } 1459 delta = Math.abs(delta); 1460 float transparency = Math.min(1, delta / distance); 1461 mHandledSwipeView.setAlpha(1.f - transparency); 1462 mHandledSwipeViewLastDelta = delta; 1463 } 1464 if (ev.getActionMasked() == MotionEvent.ACTION_CANCEL 1465 || ev.getActionMasked() == MotionEvent.ACTION_UP) { 1466 mHandledSwipeView.setTranslationX(0); 1467 mHandledSwipeView.setTranslationY(0); 1468 mHandledSwipeView.setAlpha(1.f); 1469 mHandlingSwipeButton = false; 1470 float distance = mHandledSwipeView.getHeight(); 1471 if (direction == CategoryView.VERTICAL) { 1472 distance = mHandledSwipeView.getWidth(); 1473 } 1474 if (mHandledSwipeViewLastDelta > distance) { 1475 ((SwipableView) mHandledSwipeView).delete(); 1476 } 1477 } 1478 return true; 1479 } 1480 return super.dispatchTouchEvent(ev); 1481 } 1482 1483 public Point mHintTouchPoint = new Point(); 1484 hintTouchPoint(View view)1485 public Point hintTouchPoint(View view) { 1486 int location[] = new int[2]; 1487 view.getLocationOnScreen(location); 1488 int x = mHintTouchPoint.x - location[0]; 1489 int y = mHintTouchPoint.y - location[1]; 1490 return new Point(x, y); 1491 } 1492 startTouchAnimation(View target, float x, float y)1493 public void startTouchAnimation(View target, float x, float y) { 1494 final CategorySelected hint = 1495 (CategorySelected) findViewById(R.id.categorySelectedIndicator); 1496 int location[] = new int[2]; 1497 target.getLocationOnScreen(location); 1498 mHintTouchPoint.x = (int) (location[0] + x); 1499 mHintTouchPoint.y = (int) (location[1] + y); 1500 int locationHint[] = new int[2]; 1501 ((View)hint.getParent()).getLocationOnScreen(locationHint); 1502 int dx = (int) (x - (hint.getWidth())/2); 1503 int dy = (int) (y - (hint.getHeight())/2); 1504 hint.setTranslationX(location[0] - locationHint[0] + dx); 1505 hint.setTranslationY(location[1] - locationHint[1] + dy); 1506 hint.setVisibility(View.VISIBLE); 1507 hint.animate().scaleX(2).scaleY(2).alpha(0).withEndAction(new Runnable() { 1508 @Override 1509 public void run() { 1510 hint.setVisibility(View.INVISIBLE); 1511 hint.setScaleX(1); 1512 hint.setScaleY(1); 1513 hint.setAlpha(1); 1514 } 1515 }); 1516 } 1517 } 1518