import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@TaskResult(id = "personal")
public void onFindNotebooks(List<Notebook> notebooks) {
    mSwipeRefreshLayout.setRefreshing(false);

    if (notebooks == null || notebooks.isEmpty()) {
        getChildFragmentManager().beginTransaction()
                .replace(R.id.fragment_container, EmptyFragment.create("notebooks"))
                .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
                .commit();
    } else {
        getChildFragmentManager().beginTransaction()
                .replace(R.id.fragment_container, NotebookListFragment.create(notebooks))
                .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
                .commit();
    }
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@Override
public View getView(int position, View convertView, ViewGroup parent) {
    ViewHolder viewHolder;
    if (convertView == null) {
        convertView = LayoutInflater.from(getActivity()).inflate(android.R.layout.simple_list_item_1, parent, false);
        viewHolder = new ViewHolder(convertView);
        convertView.setTag(viewHolder);
    } else {
        viewHolder = (ViewHolder) convertView.getTag();
    }

    Notebook notebook = getItem(position);
    viewHolder.mTextView1.setText(notebook.getName());

    return convertView;
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
/**
 * @param notebook The new business notebook.
 * @param defaultClient The note store client, which references the user's note store.
 * @return The new created {@link LinkedNotebook}, which has an business ID.
 */
public LinkedNotebook createBusinessNotebook(@NonNull Notebook notebook, @NonNull EvernoteNoteStoreClient defaultClient)
        throws TException, EDAMUserException, EDAMSystemException, EDAMNotFoundException {

    Notebook originalNotebook = mClient.createNotebook(notebook);

    List<SharedNotebook> sharedNotebooks = originalNotebook.getSharedNotebooks();
    SharedNotebook sharedNotebook = sharedNotebooks.get(0);

    LinkedNotebook linkedNotebook = new LinkedNotebook();
    linkedNotebook.setShareKey(sharedNotebook.getShareKey());
    linkedNotebook.setShareName(originalNotebook.getName());
    linkedNotebook.setUsername(mBusinessUserName);
    linkedNotebook.setShardId(mBusinessUserShardId);

    return defaultClient.createLinkedNotebook(linkedNotebook);
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
/**
 * If this note is linked, then it loads the corresponding notebook for the linked notebook. Use
 * {@link #loadLinkedNotebook()} to get the linked notebook.
 *
 * @return The note's notebook from server.
 * @see #isLinked()
 * @see EvernoteLinkedNotebookHelper#getCorrespondingNotebook()
 */
public Notebook loadNotebook() throws EDAMUserException, EDAMSystemException, TException, EDAMNotFoundException {
    if (mNotebookGuid == null) {
        return null;
    }

    if (mLinked) {
        LinkedNotebook linkedNotebook = NoteRefHelper.getLinkedNotebook(mNotebookGuid);
        return NoteRefHelper.getSession().getEvernoteClientFactory().getLinkedNotebookHelper(linkedNotebook).getCorrespondingNotebook();
    }

    EvernoteNoteStoreClient noteStore = NoteRefHelper.getNoteStore(this);
    if (noteStore == null) {
        return null;
    }

    return noteStore.getNotebook(mNotebookGuid);
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
private void makeSureNotebookExists(String NotebookName) throws Exception {
    try {
        if (mSharedPreferences.contains(EVERNOTE_NOTEBOOK_GUID)) {
            if (!isNotebookExsist(mSharedPreferences.getString(EVERNOTE_NOTEBOOK_GUID, ""),
                    NOTEBOOK_NAME)) {
                createNotebook(NOTEBOOK_NAME);
            }
        } else {
            List<Notebook> books = mEvernoteSession.getClientFactory().createNoteStore()
                    .listNotebooks(mEvernoteSession.getAuthToken());
            int count = books.size();
            for (int i = 0; i < count; i++) {
                Notebook book = books.get(i);
                if (book.getName().equals(NotebookName)) {
                    mSharedPreferences.edit().putString(EVERNOTE_NOTEBOOK_GUID, book.getGuid()).apply();
                    return;
                }
            }
            createNotebook(NOTEBOOK_NAME);
        }

    } catch (Exception e) {
        LogUtil.e(TAG, "检查笔记本是否存和创建笔记本的时候出现异常");
        throw e;
    }
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
/**
 * return a user's all notebooks(including linked notebooks).
 *
 * @return The user's notebooks.
 */
@Override
public Map<String, ENObject> listNotebooks() throws EDAMUserException, EDAMSystemException, TException, EDAMNotFoundException {
    List<Notebook> notebooks = factory.getNoteStoreClient().listNotebooks();
    List<LinkedNotebook> linkedNotebooks = factory.getNoteStoreClient().listLinkedNotebooks();

    Map<String, ENObject> map = MapUtil.map();
    for (Notebook n : notebooks) {
        map.put(n.getName(), ENObjectImpl.forNameAndGuid(n.getName(), n.getGuid()));
    }

    for (LinkedNotebook linkedNotebook : linkedNotebooks) { // LinkedNotebook must be serializable
        NoteStoreClient linkedNoteStore = factory.getLinkedNoteStoreClient(linkedNotebook);
        SharedNotebook sharedNotebook = linkedNoteStore.getSharedNotebookByAuth();

        if (map.containsKey(linkedNotebook.getShareName())) {
            map.put(linkedNotebook.getShareName() + ConstantsUtil.LEFT_PARENTHESIS + linkedNotebook.getUsername() + ConstantsUtil.COLON + sharedNotebook.getNotebookGuid() + ConstantsUtil.RIGHT_PARENTHESIS, ENObjectImpl.forValues(linkedNotebook.getShareName(), sharedNotebook.getNotebookGuid(), ENObjectType.LINKED, linkedNotebook));
        } else {
            map.put(linkedNotebook.getShareName(), ENObjectImpl.forValues(linkedNotebook.getShareName(), sharedNotebook.getNotebookGuid(), ENObjectType.LINKED, linkedNotebook));
        }
    }

    return map;
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
public List<Notebook> listNoteBooks() throws Exception {
	List<Notebook> notebooks = noteStore.listNotebooks();

	for (Notebook notebook : notebooks) {
		NoteFilter filter = new NoteFilter();
		filter.setNotebookGuid(notebook.getGuid());
		filter.setOrder(NoteSortOrder.CREATED.getValue());
		filter.setAscending(true);

		NoteList noteList = noteStore.findNotes(filter, 0, 100);
		List<Note> notes = noteList.getNotes();
		for (Note note : notes) {
			System.out.println(" * " + note.getTitle());
		}
	}
	return notebooks;
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
/**
 * Retrieve and display a list of the user's notes.
 */
private void listNotes() throws Exception {
	// List the notes in the user's account
	System.out.println("Listing notes:");

	// First, get a list of all notebooks
	List<Notebook> notebooks = noteStore.listNotebooks();

	for (Notebook notebook : notebooks) {
		System.out.println("Notebook: " + notebook.getName());

		// Next, search for the first 100 notes in this notebook, ordering
		// by creation date
		NoteFilter filter = new NoteFilter();
		filter.setNotebookGuid(notebook.getGuid());
		filter.setOrder(NoteSortOrder.CREATED.getValue());
		filter.setAscending(true);

		NoteList noteList = noteStore.findNotes(filter, 0, 100);
		List<Note> notes = noteList.getNotes();
		for (Note note : notes) {
			System.out.println(" * " + note.getTitle());
		}
	}
	System.out.println();
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
private SSLabel getNotebookLabel(
  final Notebook notebook) throws SSErr{
  
  try{
    final SSLabel tmpLabel = SSLabel.get(notebook.getName());
    
    if(tmpLabel == null){
      return getDefaultLabel();
    }else{
      return tmpLabel;
    }
  }catch(Exception error){
    SSLogU.warn(error);
    
    return getDefaultLabel();
  }
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@Override
public Notebook evernoteNotebookGet(final SSEvernoteNotebookGetPar par) throws SSErr {
  
  try{
    return par.noteStore.getNotebook(par.notebookGUID);
  }catch(EDAMSystemException edamError){
    
    if(gotToSleep(edamError, SSStrU.empty)){
      return evernoteNotebookGet (par);
    }else{
      SSServErrReg.regErrThrow(edamError);
      return null;
    }
    
  }catch(Exception error){
    SSServErrReg.regErrThrow(error);
    return null;
  }
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
public static NoteContainerFragment create(@Nullable Notebook notebook, @Nullable LinkedNotebook linkedNotebook, @Nullable String mReceivedString) {
    Bundle args = new Bundle();
    args.putSerializable(KEY_NOTEBOOK, notebook);
    args.putSerializable(KEY_LINKED_NOTEBOOK, linkedNotebook);
    args.putSerializable(KEY_RECEIVED_STRING, mReceivedString);

    NoteContainerFragment fragment = new NoteContainerFragment();
    fragment.setArguments(args);
    return fragment;
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setHasOptionsMenu(true);

    mNotebook = (Notebook) getArguments().getSerializable(KEY_NOTEBOOK);
    mLinkedNotebook = (LinkedNotebook) getArguments().getSerializable(KEY_LINKED_NOTEBOOK);
    mReceivedString = (String) getArguments().getSerializable(KEY_RECEIVED_STRING);
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@TaskResult
public void onCreateNewNotebook(Notebook notebook) {
    // called from CreateNoteDialogFragment
    if (notebook != null) {
        refresh();
    } else {
        ViewUtil.showSnackbar(mSwipeRefreshLayout, "Create notebook failed");
    }
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
public static NotebookListFragment create(List<Notebook> notebooks) {
    Bundle args = new Bundle();
    ParcelableUtil.putSerializableList(args, new ArrayList<Serializable>(notebooks), KEY_NOTEBOOK_LIST);

    NotebookListFragment fragment = new NotebookListFragment();
    fragment.setArguments(args);
    return fragment;
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@Override
protected Notebook checkedExecute() throws Exception {
    EvernoteNoteStoreClient noteStoreClient = EvernoteSession.getInstance().getEvernoteClientFactory().getNoteStoreClient();

    Notebook notebook = new Notebook();
    notebook.setName(mName);

    return noteStoreClient.createNotebook(notebook);
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
public CreateNewNoteTask(String title, String content, ImageData imageData, Notebook notebook, LinkedNotebook linkedNotebook) {
    super(Note.class);

    mTitle = title;
    mContent = content;
    mImageData = imageData;
    mNotebook = notebook;
    mLinkedNotebook = linkedNotebook;
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public FindNotesTask(int offset, int maxNotes, @Nullable Notebook notebook, @Nullable LinkedNotebook linkedNotebook, @Nullable String query) {
    super((Class) List.class);

    NoteFilter noteFilter = new NoteFilter();
    noteFilter.setOrder(NoteSortOrder.UPDATED.getValue());

    if (!TextUtils.isEmpty(query)) {
        noteFilter.setWords(query);
    }else{
        //TODO: let the user choose a tag he wants here we just use favorit as tag to filter by
        List<String> list = new ArrayList();
        list.add("03750a45-c107-4e8b-afbf-29fa22777244");
        noteFilter.setTagGuids(list);
    }

    if (notebook != null) {
        noteFilter.setNotebookGuid(notebook.getGuid());
    }

    mSearch = new EvernoteSearchHelper.Search()
            .setOffset(offset)
            .setMaxNotes(maxNotes)
            .setNoteFilter(noteFilter);

    if (linkedNotebook != null) {
        mSearch.addLinkedNotebook(linkedNotebook);
    } else {
        mSearch.addScope(EvernoteSearchHelper.Scope.PERSONAL_NOTES);
    }

}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
/**
 * @see #getCorrespondingNotebook()
 */
public Future<Notebook> getCorrespondingNotebookAsync(@Nullable EvernoteCallback<Notebook> callback) {
    return submitTask(new Callable<Notebook>() {
        @Override
        public Notebook call() throws Exception {
            return getCorrespondingNotebook();
        }
    }, callback);
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
/**
 * @see #createBusinessNotebook(Notebook, EvernoteNoteStoreClient)
 */
public Future<LinkedNotebook> createBusinessNotebookAsync(@NonNull final Notebook notebook, @NonNull final EvernoteNoteStoreClient defaultClient,
                                                          @Nullable EvernoteCallback<LinkedNotebook> callback) {

    return submitTask(new Callable<LinkedNotebook>() {
        @Override
        public LinkedNotebook call() throws Exception {
            return createBusinessNotebook(notebook, defaultClient);
        }
    }, callback);
}
 

import com.evernote.edam.type.Notebook; //导入依赖的package包/类
public Future<List<Notebook>> listNotebooksAsync(EvernoteCallback<List<Notebook>> callback) {
    return submitTask(new Callable<List<Notebook>>() {
        @Override
        public List<Notebook> call() throws Exception {
            return listNotebooks();
        }
    }, callback);
}