import com.evernote.edam.type.LinkedNotebook; //导入依赖的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();
    }

    LinkedNotebook notebook = getItem(position);
    viewHolder.mTextView1.setText(notebook.getShareName());

    return convertView;
}
 

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

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

import com.evernote.edam.type.LinkedNotebook; //导入依赖的package包/类
/**
 * Use this method, if you want to download a linked note as HTML.
 *
 * @param linkedNotebook The referenced {@link LinkedNotebook}. Its GUID and share key must not be
 *                       {@code null}.
 * @return An async wrapper to load a note as HTML from the Evernote service.
 */
public EvernoteHtmlHelper getLinkedHtmlHelper(@NonNull LinkedNotebook linkedNotebook) throws EDAMUserException, EDAMSystemException, EDAMNotFoundException, TException {
    String key = linkedNotebook.getGuid();

    EvernoteHtmlHelper htmlHelper = mLinkedHtmlHelper.get(key);
    if (htmlHelper == null) {
        String url = linkedNotebook.getNoteStoreUrl();

        EvernoteNoteStoreClient client = getNoteStoreClient(url, EvernotePreconditions.checkNotEmpty(mEvernoteSession.getAuthToken()));
        AuthenticationResult authenticationResult = client.authenticateToSharedNotebook(linkedNotebook.getShareKey());

        htmlHelper = createHtmlHelper(authenticationResult.getAuthenticationToken());

        mLinkedHtmlHelper.put(key, htmlHelper);
    }

    return htmlHelper;
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的package包/类
/**
 * @return The linked notebook if this is a linked note.
 * @see #isLinked()
 */
public LinkedNotebook loadLinkedNotebook() throws EDAMUserException, EDAMSystemException, TException, EDAMNotFoundException {
    if (!mLinked) {
        return null;
    }

    EvernoteNoteStoreClient noteStore = NoteRefHelper.getSession().getEvernoteClientFactory().getNoteStoreClient();
    if (noteStore == null) {
        return null;
    }

    List<LinkedNotebook> linkedNotebooks = noteStore.listLinkedNotebooks();
    for (LinkedNotebook linkedNotebook : linkedNotebooks) {
        if (linkedNotebook.getGuid().equals(mNotebookGuid)) {
            return linkedNotebook;
        }
    }

    return null;
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的package包/类
private SSLabel getSharedWithMeOrPublicNotebookLabel(
  final LinkedNotebook sharedWithMeOrPublicNotebook) throws SSErr{
  
  try{
    final SSLabel tmpLabel = SSLabel.get(sharedWithMeOrPublicNotebook.getShareName());
    
    if(tmpLabel == null){
      return getDefaultLabel();
    }else{
      return tmpLabel;
    }
  }catch(Exception error){
     SSLogU.warn(error);
    return getDefaultLabel();
  }
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的package包/类
@Test
public void testLinkedNoteStoreClientWithException() throws Exception {
	EDAMUserException exception = new EDAMUserException();
	ClientFactory clientFactory = mock(ClientFactory.class);
	when(clientFactory.createLinkedNoteStoreClient(argThat(any(LinkedNotebook.class)))).thenThrow(exception);

	EvernoteTemplate template = new EvernoteTemplate(EvernoteService.SANDBOX, "token");
	replaceClientFactory(template, clientFactory);

	try {
		template.linkedNoteStoreClient(mock(LinkedNotebook.class));
		fail("didn't thrown exception");
	} catch (EvernoteException e) {
		Throwable cause = e.getCause();
		assertThat(cause, is(instanceOf(EDAMUserException.class)));
		assertThat((EDAMUserException) cause, is(sameInstance(exception)));
	}
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的package包/类
public static LinkedNotebookListFragment create(List<LinkedNotebook> notebooks) {
    Bundle args = new Bundle();
    ParcelableUtil.putSerializableList(args, new ArrayList<Serializable>(notebooks), KEY_LINKED_NOTEBOOK_LIST);

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

import com.evernote.edam.type.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的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.LinkedNotebook; //导入依赖的package包/类
/**
 * Returns an async wrapper providing several helper methods for this {@link LinkedNotebook}. With
 * {@link EvernoteLinkedNotebookHelper#getClient()} you can get access to the underlying {@link EvernoteNoteStoreClient},
 * which references the {@link LinkedNotebook}'s note store URL.
 *
 * @param linkedNotebook The referenced {@link LinkedNotebook}. Its GUID and share key must not be
 *                       {@code null}.
 * @return An async wrapper providing several helper methods.
 */
public synchronized EvernoteLinkedNotebookHelper getLinkedNotebookHelper(@NonNull LinkedNotebook linkedNotebook)
        throws EDAMUserException, EDAMSystemException, EDAMNotFoundException, TException {

    String key = linkedNotebook.getGuid();
    EvernoteLinkedNotebookHelper notebookHelper = mLinkedNotebookHelpers.get(key);
    if (notebookHelper == null) {
        notebookHelper = createLinkedNotebookHelper(linkedNotebook);
        mLinkedNotebookHelpers.put(key, notebookHelper);
    }

    return notebookHelper;
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的package包/类
/**
 * @see #getLinkedNotebookHelper(LinkedNotebook)
 */
public Future<EvernoteLinkedNotebookHelper> getLinkedNotebookHelperAsync(@NonNull final LinkedNotebook linkedNotebook,
                                                                         @Nullable EvernoteCallback<EvernoteLinkedNotebookHelper> callback) {

    return mCreateHelperClient.submitTask(new Callable<EvernoteLinkedNotebookHelper>() {
        @Override
        public EvernoteLinkedNotebookHelper call() throws Exception {
            return getLinkedNotebookHelper(linkedNotebook);
        }
    }, callback);
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的package包/类
/**
 * @see #getLinkedNotebookHelper(LinkedNotebook)
 */
public Future<EvernoteHtmlHelper> getLinkedHtmlHelperAsync(@NonNull final LinkedNotebook linkedNotebook, @Nullable EvernoteCallback<EvernoteHtmlHelper> callback) {
    return mCreateHelperClient.submitTask(new Callable<EvernoteHtmlHelper>() {
        @Override
        public EvernoteHtmlHelper call() throws Exception {
            return getLinkedHtmlHelper(linkedNotebook);
        }
    }, callback);
}
 

import com.evernote.edam.type.LinkedNotebook; //导入依赖的package包/类
/**
 * @param defaultClient The note store client, which references the user's note store.
 * @return A list of {@link LinkedNotebook}s, which all have a business ID.
 */
public List<LinkedNotebook> listBusinessNotebooks(@NonNull EvernoteNoteStoreClient defaultClient) throws EDAMUserException,
        EDAMSystemException, TException, EDAMNotFoundException {

    List<LinkedNotebook> businessNotebooks = new ArrayList<>(defaultClient.listLinkedNotebooks());

    Iterator<LinkedNotebook> iterator = businessNotebooks.iterator();
    while (iterator.hasNext()) {
        if (!isBusinessNotebook(iterator.next())) {
            iterator.remove();
        }
    }

    return businessNotebooks;
}
 

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

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

import com.evernote.edam.type.LinkedNotebook; //导入依赖的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);
}