| package org.wordpress.android.ui.posts; |
| |
| import android.app.Activity; |
| import android.app.AlertDialog; |
| import android.app.Fragment; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.database.Cursor; |
| import android.location.Address; |
| import android.location.Location; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.preference.PreferenceManager; |
| import android.support.v7.widget.AppCompatButton; |
| import android.text.Editable; |
| import android.text.Html; |
| import android.text.TextUtils; |
| import android.text.TextWatcher; |
| import android.text.format.DateFormat; |
| import android.text.format.DateUtils; |
| import android.view.ContextMenu; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.MenuItem; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.ViewStub; |
| import android.view.animation.Animation; |
| import android.view.animation.AnimationUtils; |
| import android.view.inputmethod.EditorInfo; |
| import android.widget.AdapterView; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.DatePicker; |
| import android.widget.EditText; |
| import android.widget.Spinner; |
| import android.widget.TextView; |
| import android.widget.TimePicker; |
| import android.widget.Toast; |
| |
| import com.android.volley.toolbox.NetworkImageView; |
| import com.google.gson.Gson; |
| import com.google.gson.reflect.TypeToken; |
| |
| import org.apache.commons.lang.StringEscapeUtils; |
| import org.json.JSONArray; |
| import org.wordpress.android.R; |
| import org.wordpress.android.WordPress; |
| import org.wordpress.android.models.Post; |
| import org.wordpress.android.models.PostLocation; |
| import org.wordpress.android.models.PostStatus; |
| import org.wordpress.android.ui.RequestCodes; |
| import org.wordpress.android.ui.media.MediaGalleryPickerActivity; |
| import org.wordpress.android.ui.media.WordPressMediaUtils; |
| import org.wordpress.android.ui.prefs.AppPrefs; |
| import org.wordpress.android.ui.prefs.SiteSettingsInterface; |
| import org.wordpress.android.ui.suggestion.adapters.TagSuggestionAdapter; |
| import org.wordpress.android.ui.suggestion.util.SuggestionServiceConnectionManager; |
| import org.wordpress.android.ui.suggestion.util.SuggestionUtils; |
| import org.wordpress.android.util.AppLog; |
| import org.wordpress.android.util.AppLog.T; |
| import org.wordpress.android.util.DisplayUtils; |
| import org.wordpress.android.util.EditTextUtils; |
| import org.wordpress.android.util.GeocoderUtils; |
| import org.wordpress.android.util.JSONUtils; |
| import org.wordpress.android.util.PermissionUtils; |
| import org.wordpress.android.util.StringUtils; |
| import org.wordpress.android.util.ToastUtils; |
| import org.wordpress.android.util.helpers.LocationHelper; |
| import org.wordpress.android.widgets.SuggestionAutoCompleteText; |
| import org.xmlrpc.android.ApiHelper; |
| |
| import java.lang.reflect.Type; |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| |
| public class EditPostSettingsFragment extends Fragment |
| implements View.OnClickListener, TextView.OnEditorActionListener { |
| private static final int ACTIVITY_REQUEST_CODE_SELECT_CATEGORIES = 5; |
| private static final String CATEGORY_PREFIX_TAG = "category-"; |
| |
| private static final int SELECT_LIBRARY_MENU_POSITION = 100; |
| private static final int CLEAR_FEATURED_IMAGE_MENU_POSITION = 101; |
| |
| private Post mPost; |
| |
| private Spinner mStatusSpinner, mPostFormatSpinner; |
| private EditText mPasswordEditText, mExcerptEditText; |
| private TextView mPubDateText; |
| private ViewGroup mSectionCategories; |
| private ViewGroup mRootView; |
| private TextView mFeaturedImageLabel; |
| private NetworkImageView mFeaturedImageView; |
| private Button mFeaturedImageButton; |
| private SuggestionAutoCompleteText mTagsEditText; |
| |
| private SuggestionServiceConnectionManager mSuggestionServiceConnectionManager; |
| |
| private long mFeaturedImageId; |
| |
| private ArrayList<String> mCategories; |
| |
| private PostLocation mPostLocation; |
| private LocationHelper mLocationHelper; |
| |
| private int mYear, mMonth, mDay, mHour, mMinute; |
| private long mCustomPubDate = 0; |
| private boolean mIsCustomPubDate; |
| |
| private String[] mPostFormats; |
| private String[] mPostFormatTitles; |
| |
| private enum LocationStatus {NONE, FOUND, NOT_FOUND, SEARCHING} |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| if (getActivity() != null) { |
| PreferenceManager.setDefaultValues(getActivity(), R.xml.account_settings, false); |
| } |
| } |
| |
| @Override |
| public void onDestroy() { |
| if (mSuggestionServiceConnectionManager != null) { |
| mSuggestionServiceConnectionManager.unbindFromService(); |
| } |
| super.onDestroy(); |
| } |
| |
| @Override |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| Bundle savedInstanceState) { |
| mPost = ((EditPostActivity) getActivity()).getPost(); |
| mRootView = (ViewGroup) inflater.inflate(R.layout.edit_post_settings_fragment, container, false); |
| |
| if (mRootView == null || mPost == null) { |
| return null; |
| } |
| |
| Calendar c = Calendar.getInstance(); |
| mYear = c.get(Calendar.YEAR); |
| mMonth = c.get(Calendar.MONTH); |
| mDay = c.get(Calendar.DAY_OF_MONTH); |
| mHour = c.get(Calendar.HOUR_OF_DAY); |
| mMinute = c.get(Calendar.MINUTE); |
| mCategories = new ArrayList<String>(); |
| |
| mExcerptEditText = (EditText) mRootView.findViewById(R.id.postExcerpt); |
| mPasswordEditText = (EditText) mRootView.findViewById(R.id.post_password); |
| mPubDateText = (TextView) mRootView.findViewById(R.id.pubDate); |
| mPubDateText.setOnClickListener(this); |
| mStatusSpinner = (Spinner) mRootView.findViewById(R.id.status); |
| mStatusSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { |
| updatePostSettingsAndSaveButton(); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }); |
| mSectionCategories = ((ViewGroup) mRootView.findViewById(R.id.sectionCategories)); |
| |
| mFeaturedImageLabel = (TextView) mRootView.findViewById(R.id.featuredImageLabel); |
| mFeaturedImageView = (NetworkImageView) mRootView.findViewById(R.id.featuredImage); |
| mFeaturedImageButton = (Button) mRootView.findViewById(R.id.addFeaturedImage); |
| |
| if (AppPrefs.isVisualEditorEnabled()) { |
| registerForContextMenu(mFeaturedImageView); |
| mFeaturedImageView.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| view.showContextMenu(); |
| } |
| }); |
| |
| mFeaturedImageButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| launchMediaGalleryActivity(); |
| } |
| }); |
| } else { |
| mFeaturedImageLabel.setVisibility(View.GONE); |
| mFeaturedImageView.setVisibility(View.GONE); |
| mFeaturedImageButton.setVisibility(View.GONE); |
| } |
| |
| if (mPost.isPage()) { // remove post specific views |
| mExcerptEditText.setVisibility(View.GONE); |
| mRootView.findViewById(R.id.sectionTags).setVisibility(View.GONE); |
| mRootView.findViewById(R.id.sectionCategories).setVisibility(View.GONE); |
| mRootView.findViewById(R.id.postFormatLabel).setVisibility(View.GONE); |
| mRootView.findViewById(R.id.postFormat).setVisibility(View.GONE); |
| } else { |
| mPostFormatTitles = getResources().getStringArray(R.array.post_formats_array); |
| mPostFormats = |
| new String[]{"aside", "audio", "chat", "gallery", "image", "link", "quote", "standard", "status", |
| "video"}; |
| if (WordPress.getCurrentBlog().getPostFormats().equals("")) { |
| new ApiHelper.GetPostFormatsTask().execute(WordPress.getCurrentBlog()); |
| } else { |
| try { |
| Gson gson = new Gson(); |
| Type type = new TypeToken<Map<String, String>>() {}.getType(); |
| Map<String, String> jsonPostFormats = gson.fromJson(WordPress.getCurrentBlog().getPostFormats(), |
| type); |
| mPostFormats = new String[jsonPostFormats.size()]; |
| mPostFormatTitles = new String[jsonPostFormats.size()]; |
| int i = 0; |
| for (Map.Entry<String, String> entry : jsonPostFormats.entrySet()) { |
| String key = entry.getKey(); |
| String val = entry.getValue(); |
| mPostFormats[i] = key; |
| mPostFormatTitles[i] = StringEscapeUtils.unescapeHtml(val); |
| i++; |
| } |
| } catch (RuntimeException e) { |
| AppLog.e(T.POSTS, e); |
| } |
| } |
| mPostFormatSpinner = (Spinner) mRootView.findViewById(R.id.postFormat); |
| ArrayAdapter<String> pfAdapter = new ArrayAdapter<>(getActivity(), R.layout.simple_spinner_item, |
| mPostFormatTitles); |
| pfAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| mPostFormatSpinner.setAdapter(pfAdapter); |
| String activePostFormat = "standard"; |
| |
| if (!TextUtils.isEmpty(mPost.getPostFormat())) { |
| activePostFormat = mPost.getPostFormat(); |
| } |
| |
| for (int i = 0; i < mPostFormats.length; i++) { |
| if (mPostFormats[i].equals(activePostFormat)) |
| mPostFormatSpinner.setSelection(i); |
| } |
| |
| mPostFormatSpinner.setOnTouchListener( |
| new View.OnTouchListener() { |
| @Override |
| public boolean onTouch(View view, MotionEvent motionEvent) { |
| return false; |
| } |
| } |
| ); |
| |
| mTagsEditText = (SuggestionAutoCompleteText) mRootView.findViewById(R.id.tags); |
| if (mTagsEditText != null) { |
| mTagsEditText.setTokenizer(new SuggestionAutoCompleteText.CommaTokenizer()); |
| |
| setupSuggestionServiceAndAdapter(); |
| } |
| } |
| |
| initSettingsFields(); |
| populateSelectedCategories(); |
| initLocation(mRootView); |
| return mRootView; |
| } |
| |
| @Override |
| public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) { |
| menu.add(0, SELECT_LIBRARY_MENU_POSITION, 0, getResources().getText(R.string.select_from_media_library)); |
| menu.add(0, CLEAR_FEATURED_IMAGE_MENU_POSITION, 0, "Remove featured image"); |
| } |
| |
| @Override |
| public boolean onContextItemSelected(MenuItem item) { |
| switch (item.getItemId()) { |
| case SELECT_LIBRARY_MENU_POSITION: |
| launchMediaGalleryActivity(); |
| return true; |
| case CLEAR_FEATURED_IMAGE_MENU_POSITION: |
| mFeaturedImageId = -1; |
| mFeaturedImageView.setVisibility(View.GONE); |
| mFeaturedImageButton.setVisibility(View.VISIBLE); |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| private void setupSuggestionServiceAndAdapter() { |
| if (!isAdded()) return; |
| |
| int remoteBlogId = -1; |
| String blogID = WordPress.getCurrentRemoteBlogId(); |
| remoteBlogId = StringUtils.stringToInt(blogID, -1); |
| |
| mSuggestionServiceConnectionManager = new SuggestionServiceConnectionManager(getActivity(), remoteBlogId); |
| TagSuggestionAdapter tagSuggestionAdapter = SuggestionUtils.setupTagSuggestions(remoteBlogId, getActivity(), mSuggestionServiceConnectionManager); |
| if (tagSuggestionAdapter != null) { |
| mTagsEditText.setAdapter(tagSuggestionAdapter); |
| } |
| } |
| |
| private void initSettingsFields() { |
| mExcerptEditText.setText(mPost.getPostExcerpt()); |
| |
| String[] items = new String[]{ getResources().getString(R.string.publish_post), |
| getResources().getString(R.string.draft), |
| getResources().getString(R.string.pending_review), |
| getResources().getString(R.string.post_private) }; |
| |
| ArrayAdapter<String> adapter = new ArrayAdapter<>(getActivity(), android.R.layout.simple_spinner_item, items); |
| adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| mStatusSpinner.setAdapter(adapter); |
| mStatusSpinner.setOnTouchListener( |
| new View.OnTouchListener() { |
| @Override |
| public boolean onTouch(View view, MotionEvent motionEvent) { |
| return false; |
| } |
| } |
| ); |
| |
| long pubDate = mPost.getDate_created_gmt(); |
| if (pubDate != 0) { |
| try { |
| int flags = 0; |
| flags |= android.text.format.DateUtils.FORMAT_SHOW_DATE; |
| flags |= android.text.format.DateUtils.FORMAT_ABBREV_MONTH; |
| flags |= android.text.format.DateUtils.FORMAT_SHOW_YEAR; |
| flags |= android.text.format.DateUtils.FORMAT_SHOW_TIME; |
| String formattedDate = DateUtils.formatDateTime(getActivity(), pubDate, |
| flags); |
| mPubDateText.setText(formattedDate); |
| } catch (RuntimeException e) { |
| AppLog.e(T.POSTS, e); |
| } |
| } |
| |
| if (!TextUtils.isEmpty(mPost.getPassword())) { |
| mPasswordEditText.setText(mPost.getPassword()); |
| } |
| |
| switch (mPost.getStatusEnum()) { |
| case PUBLISHED: |
| case SCHEDULED: |
| case UNKNOWN: |
| mStatusSpinner.setSelection(0, true); |
| break; |
| case DRAFT: |
| mStatusSpinner.setSelection(1, true); |
| break; |
| case PENDING: |
| mStatusSpinner.setSelection(2, true); |
| break; |
| case PRIVATE: |
| mStatusSpinner.setSelection(3, true); |
| break; |
| } |
| |
| if (!mPost.isPage()) { |
| if (mPost.getJSONCategories() != null) { |
| mCategories = JSONUtils.fromJSONArrayToStringList(mPost.getJSONCategories()); |
| } |
| } |
| String tags = mPost.getKeywords(); |
| if (!tags.equals("")) { |
| mTagsEditText.setText(tags); |
| } |
| |
| if (AppPrefs.isVisualEditorEnabled()) { |
| updateFeaturedImage(mPost.getFeaturedImageId()); |
| } |
| } |
| |
| public long getFeaturedImageId() { |
| return mFeaturedImageId; |
| } |
| |
| public void updateFeaturedImage(long id) { |
| if (mFeaturedImageId != id) { |
| mFeaturedImageId = id; |
| if (mFeaturedImageId > 0) { |
| int blogId = WordPress.getCurrentBlog().getLocalTableBlogId(); |
| Cursor cursor = WordPress.wpDB.getMediaFile(String.valueOf(blogId), String.valueOf(mFeaturedImageId)); |
| if (cursor != null && cursor.moveToFirst()) { |
| mFeaturedImageView.setVisibility(View.VISIBLE); |
| mFeaturedImageButton.setVisibility(View.GONE); |
| |
| // Get max width for photon thumbnail |
| int maxWidth = getResources().getDisplayMetrics().widthPixels; |
| int padding = DisplayUtils.dpToPx(getActivity(), 16); |
| int imageWidth = (maxWidth - padding); |
| |
| String thumbUrl = WordPressMediaUtils.getNetworkThumbnailUrl(cursor, imageWidth); |
| WordPressMediaUtils.loadNetworkImage(thumbUrl, mFeaturedImageView); |
| } |
| |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } else { |
| mFeaturedImageView.setVisibility(View.GONE); |
| mFeaturedImageButton.setVisibility(View.VISIBLE); |
| } |
| } |
| } |
| |
| private void launchMediaGalleryActivity() { |
| Intent intent = new Intent(getActivity(), MediaGalleryPickerActivity.class); |
| intent.putExtra(MediaGalleryPickerActivity.PARAM_SELECT_ONE_ITEM, true); |
| startActivityForResult(intent, MediaGalleryPickerActivity.REQUEST_CODE); |
| } |
| |
| private String getPostStatusForSpinnerPosition(int position) { |
| switch (position) { |
| case 0: |
| return PostStatus.toString(PostStatus.PUBLISHED); |
| case 1: |
| return PostStatus.toString(PostStatus.DRAFT); |
| case 2: |
| return PostStatus.toString(PostStatus.PENDING); |
| case 3: |
| return PostStatus.toString(PostStatus.PRIVATE); |
| default: |
| return PostStatus.toString(PostStatus.UNKNOWN); |
| } |
| } |
| |
| @Override |
| public void onActivityResult(int requestCode, int resultCode, Intent data) { |
| super.onActivityResult(requestCode, resultCode, data); |
| |
| if (data != null || ((requestCode == RequestCodes.TAKE_PHOTO || |
| requestCode == RequestCodes.TAKE_VIDEO))) { |
| Bundle extras; |
| |
| switch (requestCode) { |
| case ACTIVITY_REQUEST_CODE_SELECT_CATEGORIES: |
| extras = data.getExtras(); |
| if (extras != null && extras.containsKey("selectedCategories")) { |
| mCategories = (ArrayList<String>) extras.getSerializable("selectedCategories"); |
| populateSelectedCategories(); |
| } |
| break; |
| case MediaGalleryPickerActivity.REQUEST_CODE: |
| if (resultCode == Activity.RESULT_OK) { |
| ArrayList<String> ids = data.getStringArrayListExtra(MediaGalleryPickerActivity.RESULT_IDS); |
| if (ids == null || ids.size() == 0) { |
| return; |
| } |
| |
| updateFeaturedImage(Long.parseLong(ids.get(0))); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void onClick(View v) { |
| int id = v.getId(); |
| if (id == R.id.pubDate) { |
| showPostDateSelectionDialog(); |
| } else if (id == R.id.selectCategories) { |
| Bundle bundle = new Bundle(); |
| bundle.putInt("id", WordPress.getCurrentBlog().getLocalTableBlogId()); |
| if (mCategories != null && mCategories.size() > 0) { |
| bundle.putSerializable("categories", new HashSet<String>(mCategories)); |
| } |
| Intent categoriesIntent = new Intent(getActivity(), SelectCategoriesActivity.class); |
| categoriesIntent.putExtras(bundle); |
| startActivityForResult(categoriesIntent, ACTIVITY_REQUEST_CODE_SELECT_CATEGORIES); |
| } else if (id == R.id.categoryButton) { |
| onCategoryButtonClick(v); |
| } else if (id == R.id.locationText) { |
| viewLocation(); |
| } else if (id == R.id.updateLocation) { |
| showLocationSearch(); |
| } else if (id == R.id.removeLocation) { |
| removeLocation(); |
| showLocationAdd(); |
| } else if (id == R.id.addLocation) { |
| // Init Location settings when we switch to the fragment, that could trigger the opening of |
| // a dialog asking the user to enable the Geolocation permission (starting Android 6.+). |
| if (checkForLocationPermission()) { |
| showLocationSearch(); |
| } |
| } else if (id == R.id.searchLocation) { |
| if (checkForLocationPermission()) { |
| searchLocation(); |
| } |
| } |
| } |
| |
| @Override |
| public boolean onEditorAction(TextView view, int actionId, KeyEvent event) { |
| boolean handled = false; |
| int id = view.getId(); |
| if (id == R.id.searchLocationText && actionId == EditorInfo.IME_ACTION_SEARCH && checkForLocationPermission()) { |
| searchLocation(); |
| handled = true; |
| } |
| return handled; |
| } |
| |
| private void showPostDateSelectionDialog() { |
| final DatePicker datePicker = new DatePicker(getActivity()); |
| datePicker.init(mYear, mMonth, mDay, null); |
| datePicker.setCalendarViewShown(false); |
| |
| new AlertDialog.Builder(getActivity()) |
| .setTitle(R.string.select_date) |
| .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| mYear = datePicker.getYear(); |
| mMonth = datePicker.getMonth(); |
| mDay = datePicker.getDayOfMonth(); |
| showPostTimeSelectionDialog(); |
| } |
| }) |
| .setNeutralButton(getResources().getText(R.string.immediately), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialogInterface, |
| int i) { |
| mIsCustomPubDate = true; |
| mPubDateText.setText(R.string.immediately); |
| updatePostSettingsAndSaveButton(); |
| } |
| }) |
| .setNegativeButton(android.R.string.cancel, |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, |
| int which) { |
| } |
| } |
| ).setView(datePicker).show(); |
| |
| } |
| |
| private void showPostTimeSelectionDialog() { |
| final TimePicker timePicker = new TimePicker(getActivity()); |
| timePicker.setIs24HourView(DateFormat.is24HourFormat(getActivity())); |
| timePicker.setCurrentHour(mHour); |
| timePicker.setCurrentMinute(mMinute); |
| |
| new AlertDialog.Builder(getActivity()) |
| .setTitle(R.string.select_time) |
| .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| mHour = timePicker.getCurrentHour(); |
| mMinute = timePicker.getCurrentMinute(); |
| |
| Date d = new Date(mYear - 1900, mMonth, mDay, mHour, mMinute); |
| long timestamp = d.getTime(); |
| |
| try { |
| int flags = 0; |
| flags |= DateUtils.FORMAT_SHOW_DATE; |
| flags |= DateUtils.FORMAT_ABBREV_MONTH; |
| flags |= DateUtils.FORMAT_SHOW_YEAR; |
| flags |= DateUtils.FORMAT_SHOW_TIME; |
| String formattedDate = DateUtils.formatDateTime(getActivity(), timestamp, flags); |
| mCustomPubDate = timestamp; |
| mPubDateText.setText(formattedDate); |
| mIsCustomPubDate = true; |
| |
| updatePostSettingsAndSaveButton(); |
| } catch (RuntimeException e) { |
| AppLog.e(T.POSTS, e); |
| } |
| } |
| }) |
| .setNegativeButton(android.R.string.cancel, |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, |
| int which) { |
| } |
| }).setView(timePicker).show(); |
| } |
| |
| /** |
| * Updates post object with content of this fragment |
| */ |
| public void updatePostSettings() { |
| if (!isAdded() || mPost == null) { |
| return; |
| } |
| |
| String password = EditTextUtils.getText(mPasswordEditText); |
| String pubDate = EditTextUtils.getText(mPubDateText); |
| String excerpt = EditTextUtils.getText(mExcerptEditText); |
| |
| long pubDateTimestamp = 0; |
| if (mIsCustomPubDate && pubDate.equals(getText(R.string.immediately)) && !mPost.isLocalDraft()) { |
| Date d = new Date(); |
| pubDateTimestamp = d.getTime(); |
| } else if (!pubDate.equals(getText(R.string.immediately))) { |
| if (mIsCustomPubDate) |
| pubDateTimestamp = mCustomPubDate; |
| else if (mPost.getDate_created_gmt() > 0) |
| pubDateTimestamp = mPost.getDate_created_gmt(); |
| } else if (pubDate.equals(getText(R.string.immediately)) && mPost.isLocalDraft()) { |
| mPost.setDate_created_gmt(0); |
| mPost.setDateCreated(0); |
| } |
| |
| String tags = "", postFormat = ""; |
| if (!mPost.isPage()) { |
| tags = EditTextUtils.getText(mTagsEditText); |
| |
| // post format |
| if (mPostFormats != null && mPostFormatSpinner != null && |
| mPostFormatSpinner.getSelectedItemPosition() < mPostFormats.length) { |
| postFormat = mPostFormats[mPostFormatSpinner.getSelectedItemPosition()]; |
| } |
| } |
| |
| String status; |
| if (mStatusSpinner != null) { |
| status = getPostStatusForSpinnerPosition(mStatusSpinner.getSelectedItemPosition()); |
| } else { |
| status = mPost.getPostStatus(); |
| } |
| |
| // We want to flag this post as having changed statuses from draft to published so that we |
| // properly track stats we care about for when users first publish posts. |
| if (!mPost.isLocalDraft() && mPost.getPostStatus().equals(PostStatus.toString(PostStatus.DRAFT)) |
| && status.equals(PostStatus.toString(PostStatus.PUBLISHED))) { |
| mPost.setChangedFromDraftToPublished(true); |
| } |
| |
| if (mPost.supportsLocation()) { |
| mPost.setLocation(mPostLocation); |
| } |
| |
| if (mCategories != null) { |
| mPost.setJSONCategories(new JSONArray(mCategories)); |
| } |
| |
| if (AppPrefs.isVisualEditorEnabled()) { |
| mPost.setFeaturedImageId(mFeaturedImageId); |
| } |
| |
| mPost.setPostExcerpt(excerpt); |
| mPost.setDate_created_gmt(pubDateTimestamp); |
| mPost.setKeywords(tags); |
| mPost.setPostStatus(status); |
| mPost.setPassword(password); |
| mPost.setPostFormat(postFormat); |
| } |
| |
| /* |
| * Saves settings to post object and updates save button text in the ActionBar |
| */ |
| private void updatePostSettingsAndSaveButton() { |
| if (isAdded()) { |
| updatePostSettings(); |
| getActivity().invalidateOptionsMenu(); |
| } |
| } |
| |
| /** |
| * Location methods |
| */ |
| |
| /* |
| * retrieves and displays the friendly address for a lat/long location |
| */ |
| private class GetAddressTask extends AsyncTask<Double, Void, Address> { |
| double latitude; |
| double longitude; |
| |
| @Override |
| protected void onPreExecute() { |
| setLocationStatus(LocationStatus.SEARCHING); |
| showLocationView(); |
| } |
| |
| @Override |
| protected Address doInBackground(Double... args) { |
| // args will be the latitude, longitude to look up |
| latitude = args[0]; |
| longitude = args[1]; |
| |
| return GeocoderUtils.getAddressFromCoords(getActivity(), latitude, longitude); |
| } |
| |
| protected void onPostExecute(Address address) { |
| setLocationStatus(LocationStatus.FOUND); |
| if (address == null) { |
| // show lat/long when Geocoder fails (ugly, but better than not showing anything |
| // or showing an error since the location has been assigned to the post already) |
| updateLocationText(Double.toString(latitude) + ", " + Double.toString(longitude)); |
| } else { |
| String locationName = GeocoderUtils.getLocationNameFromAddress(address); |
| updateLocationText(locationName); |
| } |
| } |
| } |
| |
| private class GetCoordsTask extends AsyncTask<String, Void, Address> { |
| @Override |
| protected void onPreExecute() { |
| setLocationStatus(LocationStatus.SEARCHING); |
| showLocationView(); |
| } |
| |
| @Override |
| protected Address doInBackground(String... args) { |
| String locationName = args[0]; |
| |
| return GeocoderUtils.getAddressFromLocationName(getActivity(), locationName); |
| } |
| |
| @Override |
| protected void onPostExecute(Address address) { |
| setLocationStatus(LocationStatus.FOUND); |
| showLocationView(); |
| |
| if (address != null) { |
| double[] coordinates = GeocoderUtils.getCoordsFromAddress(address); |
| setLocation(coordinates[0], coordinates[1]); |
| |
| String locationName = GeocoderUtils.getLocationNameFromAddress(address); |
| updateLocationText(locationName); |
| } else { |
| showLocationNotAvailableError(); |
| showLocationSearch(); |
| } |
| } |
| } |
| |
| private LocationHelper.LocationResult locationResult = new LocationHelper.LocationResult() { |
| @Override |
| public void gotLocation(final Location location) { |
| if (getActivity() == null) |
| return; |
| // note that location will be null when requesting location fails |
| getActivity().runOnUiThread(new Runnable() { |
| public void run() { |
| setLocation(location); |
| } |
| }); |
| } |
| }; |
| |
| private View mLocationAddSection; |
| private View mLocationSearchSection; |
| private View mLocationViewSection; |
| private TextView mLocationText; |
| private EditText mLocationEditText; |
| private Button mButtonSearchLocation; |
| |
| private TextWatcher mLocationEditTextWatcher = new TextWatcher() { |
| @Override |
| public void beforeTextChanged(CharSequence s, int start, int count, int after) { } |
| |
| @Override |
| public void onTextChanged(CharSequence s, int start, int before, int count) { } |
| |
| @Override |
| public void afterTextChanged(Editable s) { |
| String buttonText; |
| if (s.length() > 0) { |
| buttonText = getResources().getString(R.string.search_location); |
| } else { |
| buttonText = getResources().getString(R.string.search_current_location); |
| } |
| mButtonSearchLocation.setText(buttonText); |
| } |
| }; |
| |
| /* |
| * called when activity is created to initialize the location provider, show views related |
| * to location if enabled for this blog, and retrieve the current location if necessary |
| */ |
| private void initLocation(ViewGroup rootView) { |
| if (!mPost.supportsLocation()) return; |
| |
| // show the location views if a provider was found and this is a post on a blog that has location enabled |
| View locationRootView = ((ViewStub) rootView.findViewById(R.id.stub_post_location_settings)).inflate(); |
| |
| TextView locationLabel = ((TextView) locationRootView.findViewById(R.id.locationLabel)); |
| locationLabel.setText(getResources().getString(R.string.location).toUpperCase()); |
| |
| mLocationText = (TextView) locationRootView.findViewById(R.id.locationText); |
| mLocationText.setOnClickListener(this); |
| |
| mLocationAddSection = locationRootView.findViewById(R.id.sectionLocationAdd); |
| mLocationSearchSection = locationRootView.findViewById(R.id.sectionLocationSearch); |
| mLocationViewSection = locationRootView.findViewById(R.id.sectionLocationView); |
| |
| Button addLocation = (Button) locationRootView.findViewById(R.id.addLocation); |
| addLocation.setOnClickListener(this); |
| |
| mButtonSearchLocation = (Button) locationRootView.findViewById(R.id.searchLocation); |
| mButtonSearchLocation.setOnClickListener(this); |
| |
| mLocationEditText = (EditText) locationRootView.findViewById(R.id.searchLocationText); |
| mLocationEditText.setOnEditorActionListener(this); |
| mLocationEditText.addTextChangedListener(mLocationEditTextWatcher); |
| |
| Button updateLocation = (Button) locationRootView.findViewById(R.id.updateLocation); |
| Button removeLocation = (Button) locationRootView.findViewById(R.id.removeLocation); |
| updateLocation.setOnClickListener(this); |
| removeLocation.setOnClickListener(this); |
| |
| // this is where we ask for location permission when EditPostActivity is oppened |
| if (SiteSettingsInterface.getGeotagging(getActivity()) && !checkForLocationPermission()) return; |
| |
| // if this post has location attached to it, look up the location address |
| if (mPost.hasLocation()) { |
| showLocationView(); |
| PostLocation location = mPost.getLocation(); |
| setLocation(location.getLatitude(), location.getLongitude()); |
| } else { |
| // Search for current location to geotag post if preferences allow |
| EditPostActivity activity = (EditPostActivity) getActivity(); |
| if (SiteSettingsInterface.getGeotagging(activity) && activity.isNewPost()) { |
| searchLocation(); |
| } else { |
| showLocationAdd(); |
| } |
| } |
| } |
| |
| private boolean checkForLocationPermission() { |
| return isAdded() && PermissionUtils.checkLocationPermissions(getActivity(), |
| EditPostActivity.LOCATION_PERMISSION_REQUEST_CODE); |
| } |
| |
| public void showLocationSearch() { |
| mLocationAddSection.setVisibility(View.GONE); |
| mLocationSearchSection.setVisibility(View.VISIBLE); |
| mLocationViewSection.setVisibility(View.GONE); |
| |
| EditTextUtils.showSoftInput(mLocationEditText); |
| } |
| |
| private void showLocationAdd() { |
| mLocationAddSection.setVisibility(View.VISIBLE); |
| mLocationSearchSection.setVisibility(View.GONE); |
| mLocationViewSection.setVisibility(View.GONE); |
| } |
| |
| private void showLocationView() { |
| mLocationAddSection.setVisibility(View.GONE); |
| mLocationSearchSection.setVisibility(View.GONE); |
| mLocationViewSection.setVisibility(View.VISIBLE); |
| } |
| |
| public void searchLocation() { |
| if(!isAdded() || mLocationEditText == null) return; |
| |
| EditTextUtils.hideSoftInput(mLocationEditText); |
| String location = EditTextUtils.getText(mLocationEditText); |
| |
| removeLocation(); |
| |
| if (location.isEmpty()) { |
| fetchCurrentLocation(); |
| } else { |
| new GetCoordsTask().execute(location); |
| } |
| } |
| |
| /* |
| * get the current location |
| */ |
| private void fetchCurrentLocation() { |
| if (!isAdded()) { |
| return; |
| } |
| if (mLocationHelper == null) { |
| mLocationHelper = new LocationHelper(); |
| } |
| boolean canGetLocation = mLocationHelper.getLocation(getActivity(), locationResult); |
| |
| if (canGetLocation) { |
| setLocationStatus(LocationStatus.SEARCHING); |
| showLocationView(); |
| } else { |
| setLocation(null); |
| showLocationNotAvailableError(); |
| showLocationAdd(); |
| } |
| } |
| |
| /* |
| * called when location is retrieved/updated for this post - looks up the address to |
| * display for the lat/long |
| */ |
| private void setLocation(Location location) { |
| if (location != null) { |
| setLocation(location.getLatitude(), location.getLongitude()); |
| } else { |
| updateLocationText(getString(R.string.location_not_found)); |
| setLocationStatus(LocationStatus.NOT_FOUND); |
| } |
| } |
| |
| private void setLocation(double latitude, double longitude) { |
| mPostLocation = new PostLocation(latitude, longitude); |
| new GetAddressTask().execute(mPostLocation.getLatitude(), mPostLocation.getLongitude()); |
| } |
| |
| private void removeLocation() { |
| mPostLocation = null; |
| mPost.unsetLocation(); |
| |
| updateLocationText(""); |
| setLocationStatus(LocationStatus.NONE); |
| } |
| |
| private void viewLocation() { |
| if (mPostLocation != null && mPostLocation.isValid()) { |
| String uri = "geo:" + mPostLocation.getLatitude() + "," + mPostLocation.getLongitude(); |
| startActivity(new Intent(android.content.Intent.ACTION_VIEW, Uri.parse(uri))); |
| } else { |
| showLocationNotAvailableError(); |
| showLocationAdd(); |
| } |
| } |
| |
| private void showLocationNotAvailableError() { |
| if (!isAdded()) { |
| return; |
| } |
| Toast.makeText(getActivity(), getResources().getText(R.string.location_not_found), Toast.LENGTH_SHORT).show(); |
| } |
| |
| private void updateLocationText(String locationName) { |
| mLocationText.setText(locationName); |
| } |
| |
| /* |
| * changes the left drawable on the location text to match the passed status |
| */ |
| private void setLocationStatus(LocationStatus status) { |
| if (!isAdded()) { |
| return; |
| } |
| |
| // animate location text when searching |
| if (status == LocationStatus.SEARCHING) { |
| updateLocationText(getString(R.string.loading)); |
| |
| Animation aniBlink = AnimationUtils.loadAnimation(getActivity(), R.anim.blink); |
| if (aniBlink != null) { |
| mLocationText.startAnimation(aniBlink); |
| } |
| } else { |
| mLocationText.clearAnimation(); |
| } |
| |
| final int drawableId; |
| switch (status) { |
| case FOUND: |
| drawableId = R.drawable.ic_action_location_found; |
| break; |
| case NOT_FOUND: |
| drawableId = R.drawable.ic_action_location_off; |
| break; |
| case SEARCHING: |
| drawableId = R.drawable.ic_action_location_searching; |
| break; |
| case NONE: |
| drawableId = 0; |
| break; |
| default: |
| return; |
| } |
| |
| mLocationText.setCompoundDrawablesWithIntrinsicBounds(drawableId, 0, 0, 0); |
| } |
| |
| /** |
| * Categories |
| */ |
| |
| private void onCategoryButtonClick(View v) { |
| if (mCategories == null) { |
| ToastUtils.showToast(getActivity(), R.string.error_generic); |
| return; |
| } |
| |
| // Get category name by removing prefix from the tag |
| boolean listChanged = false; |
| String categoryName = (String) v.getTag(); |
| categoryName = categoryName.replaceFirst(CATEGORY_PREFIX_TAG, ""); |
| |
| // Remove clicked category from list |
| for (int i = 0; i < mCategories.size(); i++) { |
| if (mCategories.get(i).equals(categoryName)) { |
| mCategories.remove(i); |
| listChanged = true; |
| break; |
| } |
| } |
| |
| // Recreate category views |
| if (listChanged) { |
| populateSelectedCategories(); |
| } |
| } |
| |
| private void populateSelectedCategories() { |
| // Remove previous category buttons if any + select category button |
| List<View> viewsToRemove = new ArrayList<View>(); |
| for (int i = 0; i < mSectionCategories.getChildCount(); i++) { |
| View v = mSectionCategories.getChildAt(i); |
| if (v == null) |
| return; |
| Object tag = v.getTag(); |
| if (tag != null && tag.getClass() == String.class && |
| (((String) tag).startsWith(CATEGORY_PREFIX_TAG) || tag.equals("select-category"))) { |
| viewsToRemove.add(v); |
| } |
| } |
| for (View viewToRemove : viewsToRemove) { |
| mSectionCategories.removeView(viewToRemove); |
| } |
| viewsToRemove.clear(); |
| |
| // New category buttons |
| LayoutInflater layoutInflater = getActivity().getLayoutInflater(); |
| |
| if (mCategories != null) { |
| for (String categoryName : mCategories) { |
| AppCompatButton buttonCategory = (AppCompatButton) layoutInflater.inflate(R.layout.category_button, null); |
| if (categoryName != null && buttonCategory != null) { |
| buttonCategory.setText(Html.fromHtml(categoryName)); |
| buttonCategory.setTag(CATEGORY_PREFIX_TAG + categoryName); |
| buttonCategory.setOnClickListener(this); |
| mSectionCategories.addView(buttonCategory); |
| } |
| } |
| } |
| |
| // Add select category button |
| Button selectCategory = (Button) layoutInflater.inflate(R.layout.category_select_button, null); |
| if (selectCategory != null) { |
| selectCategory.setOnClickListener(this); |
| mSectionCategories.addView(selectCategory); |
| } |
| } |
| } |
