gt:         TextView tv = (TextView) getView().findViewById(R.id.fdType);
context: /**
   *   ownCloud Android client application
   *
   *   @author Bartek Przybylski
   *   @author David A. Velasco
   *   Copyright (C) 2011  Bartek Przybylski
   *   Copyright (C) 2015 ownCloud Inc.
   *
   *   This program is free software: you can redistribute it and/or modify
   *   it under the terms of the GNU General Public License version 2,
   *   as published by the Free Software Foundation.
   *
   *   This program is distributed in the hope that it will be useful,
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *   GNU General Public License for more details.
   *
   *   You should have received a copy of the GNU General Public License
   *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   *
   */
  package com.owncloud.android.ui.fragment;
  
  import java.lang.ref.WeakReference;
  
  import android.accounts.Account;
  import android.content.Intent;
  import android.os.Bundle;
  import android.view.LayoutInflater;
  import android.view.View;
  import android.view.View.OnClickListener;
  import android.view.ViewGroup;
  import android.widget.CheckBox;
  import android.widget.ImageView;
  import android.widget.ProgressBar;
  import android.widget.TextView;
  
  import com.actionbarsherlock.view.Menu;
  import com.actionbarsherlock.view.MenuInflater;
  import com.actionbarsherlock.view.MenuItem;
  import com.owncloud.android.R;
  import com.owncloud.android.datamodel.FileDataStorageManager;
  import com.owncloud.android.datamodel.OCFile;
  import com.owncloud.android.files.FileMenuFilter;
  import com.owncloud.android.files.services.FileDownloader.FileDownloaderBinder;
  import com.owncloud.android.files.services.FileUploader.FileUploaderBinder;
  import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
  import com.owncloud.android.lib.common.utils.Log_OC;
  import com.owncloud.android.services.observer.FileObserverService;
  import com.owncloud.android.ui.activity.FileActivity;
  import com.owncloud.android.ui.activity.FileDisplayActivity;
  import com.owncloud.android.ui.dialog.RemoveFileDialogFragment;
  import com.owncloud.android.ui.dialog.RenameFileDialogFragment;
  import com.owncloud.android.utils.DisplayUtils;
  
  
  /**
   * This Fragment is used to display the details about a file.
   */
  public class FileDetailFragment extends FileFragment implements OnClickListener {
  
      private int mLayout;
      private View mView;
      private Account mAccount;
      
      public ProgressListener mProgressListener;
      
      private static final String TAG = FileDetailFragment.class.getSimpleName();
      public static final String FTAG_CONFIRMATION = "REMOVE_CONFIRMATION_FRAGMENT";
      public static final String FTAG_RENAME_FILE = "RENAME_FILE_FRAGMENT";
      
  
      /**
       * Creates an empty details fragment.
       * 
       * It's necessary to keep a public constructor without parameters; the system uses it when tries to reinstantiate a fragment automatically. 
       */
      public FileDetailFragment() {
          super();
          mAccount = null;
          mLayout = R.layout.file_details_empty;
          mProgressListener = null;
      }
      
      /**
       * Creates a details fragment.
       * 
       * When 'fileToDetail' or 'ocAccount' are null, creates a dummy layout (to use when a file wasn't tapped before).
       * 
       * @param fileToDetail      An {@link OCFile} to show in the fragment
       * @param ocAccount         An ownCloud account; needed to start downloads
       */
      public FileDetailFragment(OCFile fileToDetail, Account ocAccount) {
          super(fileToDetail);
          mAccount = ocAccount;
          mLayout = R.layout.file_details_empty;
          mProgressListener = null;
      }
      
      
      @Override
      public void onActivityCreated(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setHasOptionsMenu(true);
      }
      
  
      @Override
      public View onCreateView(LayoutInflater inflater, ViewGroup container,
              Bundle savedInstanceState) {
          
          if (savedInstanceState != null) {
              setFile((OCFile)savedInstanceState.getParcelable(FileActivity.EXTRA_FILE));
              mAccount = savedInstanceState.getParcelable(FileActivity.EXTRA_ACCOUNT);
          }
          
          if(getFile() != null && mAccount != null) {
              mLayout = R.layout.file_details_fragment;
          }
          
          View view = null;
          view = inflater.inflate(mLayout, null);
          mView = view;
          
          if (mLayout == R.layout.file_details_fragment) {
              mView.findViewById(R.id.fdKeepInSync).setOnClickListener(this);
              ProgressBar progressBar = (ProgressBar)mView.findViewById(R.id.fdProgressBar);
              mProgressListener = new ProgressListener(progressBar);
              mView.findViewById(R.id.fdCancelBtn).setOnClickListener(this);
          }
          
          updateFileDetails(false, false);
          return view;
      }
  
      @Override
      public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
          outState.putParcelable(FileActivity.EXTRA_FILE, getFile());
          outState.putParcelable(FileActivity.EXTRA_ACCOUNT, mAccount);
      }
  
      @Override
      public void onStart() {
          super.onStart();
          listenForTransferProgress();
      }
      
      @Override
      public void onStop() {
          leaveTransferProgress();
          super.onStop();
      }
  
      
      @Override
      public View getView() {
          return super.getView() == null ? mView : super.getView();
      }
  
      
      /**
       * {@inheritDoc}
       */
      @Override
      public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
          super.onCreateOptionsMenu(menu, inflater);
          inflater.inflate(R.menu.file_actions_menu, menu);
     }
  
      
      /**
       * {@inheritDoc}
       */
      @Override
      public void onPrepareOptionsMenu (Menu menu) {
          super.onPrepareOptionsMenu(menu);
          
          if (mContainerActivity.getStorageManager() != null) {
              FileMenuFilter mf = new FileMenuFilter(
                  getFile(),
                  mContainerActivity.getStorageManager().getAccount(),
                  mContainerActivity,
                  getSherlockActivity()
              );
              mf.filter(menu);
          }
          
          // additional restriction for this fragment 
          MenuItem item = menu.findItem(R.id.action_see_details);
          if (item != null) {
              item.setVisible(false);
              item.setEnabled(false);
          }
  
          // additional restriction for this fragment
          item = menu.findItem(R.id.action_move);
          if (item != null) {
              item.setVisible(false);
              item.setEnabled(false);
          }
      }
  
      
      /**
       * {@inheritDoc}
       */
      @Override
      public boolean onOptionsItemSelected(MenuItem item) {
          switch (item.getItemId()) {
              case R.id.action_share_file: {
                  mContainerActivity.getFileOperationsHelper().shareFileWithLink(getFile());
                  return true;
              }
              case R.id.action_unshare_file: {
                  mContainerActivity.getFileOperationsHelper().unshareFileWithLink(getFile());
                  return true;
              }
              case R.id.action_open_file_with: {
                  mContainerActivity.getFileOperationsHelper().openFile(getFile());
                  return true;
              }
              case R.id.action_remove_file: {
                  RemoveFileDialogFragment dialog = RemoveFileDialogFragment.newInstance(getFile());
                  dialog.show(getFragmentManager(), FTAG_CONFIRMATION);
                  return true;
              }
              case R.id.action_rename_file: {
                  RenameFileDialogFragment dialog = RenameFileDialogFragment.newInstance(getFile());
                  dialog.show(getFragmentManager(), FTAG_RENAME_FILE);
                  return true;
              }
              case R.id.action_cancel_download:
              case R.id.action_cancel_upload: {
                  ((FileDisplayActivity)mContainerActivity).cancelTransference(getFile());
                  return true;
              }
              case R.id.action_download_file: 
              case R.id.action_sync_file: {
                  mContainerActivity.getFileOperationsHelper().syncFile(getFile());
                  return true;
              }
              case R.id.action_send_file: {
                  // Obtain the file
                  if (!getFile().isDown()) {  // Download the file                    
                      Log_OC.d(TAG, getFile().getRemotePath() + " : File must be downloaded");
                      ((FileDisplayActivity)mContainerActivity).startDownloadForSending(getFile());
                      
                  } else {
                      mContainerActivity.getFileOperationsHelper().sendDownloadedFile(getFile());
                  }
                  return true;
              }
              default:
                  return false;
          }
      }
  
      @Override
      public void onClick(View v) {
          switch (v.getId()) {
              case R.id.fdKeepInSync: {
                  toggleKeepInSync();
                  break;
              }
              case R.id.fdCancelBtn: {
                  ((FileDisplayActivity)mContainerActivity).cancelTransference(getFile());
                  break;
              }
              default:
                  Log_OC.e(TAG, "Incorrect view clicked!");
          }
      }
      
      
      private void toggleKeepInSync() {
          CheckBox cb = (CheckBox) getView().findViewById(R.id.fdKeepInSync);
          OCFile file = getFile();
          file.setKeepInSync(cb.isChecked());
          mContainerActivity.getStorageManager().saveFile(file);
          
          /// register the OCFile instance in the observer service to monitor local updates
          Intent observedFileIntent = FileObserverService.makeObservedFileIntent(
                  getActivity(),
                  file, 
                  mAccount,
                  cb.isChecked());
          getActivity().startService(observedFileIntent);
          
          /// immediate content synchronization
          if (file.keepInSync()) {
              mContainerActivity.getFileOperationsHelper().syncFile(getFile());
          }
      }
  
      /**
       * Check if the fragment was created with an empty layout. An empty fragment can't show file details, must be replaced.
       * 
       * @return  True when the fragment was created with the empty layout.
       */
      public boolean isEmpty() {
          return (mLayout == R.layout.file_details_empty || getFile() == null || mAccount == null);
      }
  
      
      /**
       * Use this method to signal this Activity that it shall update its view.
       * 
       * @param file : An {@link OCFile}
       */
      public void updateFileDetails(OCFile file, Account ocAccount) {
          setFile(file);
          mAccount = ocAccount;
          updateFileDetails(false, false);
      }
  
      /**
       * Updates the view with all relevant details about that file.
       *
       * TODO Remove parameter when the transferring state of files is kept in database. 
       * 
       * @param transferring      Flag signaling if the file should be considered as downloading or uploading, 
       *                          although {@link FileDownloaderBinder#isDownloading(Account, OCFile)}  and 
       *                          {@link FileUploaderBinder#isUploading(Account, OCFile)} return false.
       *                          
       * @param refresh           If 'true', try to refresh the whole file from the database
       */
      public void updateFileDetails(boolean transferring, boolean refresh) {
          if (readyToShow()) {
              FileDataStorageManager storageManager = mContainerActivity.getStorageManager();
              if (refresh && storageManager != null) {
                  setFile(storageManager.getFileByPath(getFile().getRemotePath()));
              }
              OCFile file = getFile();
              
              // set file details
              setFilename(file.getFileName());
              setFiletype(file.getMimetype(), file.getFileName());
              setFilesize(file.getFileLength());
              if(ocVersionSupportsTimeCreated()){
                  setTimeCreated(file.getCreationTimestamp());
              }
             
              setTimeModified(file.getModificationTimestamp());
              
              CheckBox cb = (CheckBox)getView().findViewById(R.id.fdKeepInSync);
              cb.setChecked(file.keepInSync());
  
              // configure UI for depending upon local state of the file
              FileDownloaderBinder downloaderBinder = mContainerActivity.getFileDownloaderBinder();
              FileUploaderBinder uploaderBinder = mContainerActivity.getFileUploaderBinder();
              if (transferring ||
                      (downloaderBinder != null && downloaderBinder.isDownloading(mAccount, file)) ||
                      (uploaderBinder != null && uploaderBinder.isUploading(mAccount, file))
                      ) {
                  setButtonsForTransferring();
                  
              } else if (file.isDown()) {
                  
                  setButtonsForDown();
                  
              } else {
                  // TODO load default preview image; when the local file is removed, the preview remains there
                  setButtonsForRemote();
              }
          }
          getView().invalidate();
      }
      
      /**
       * Checks if the fragment is ready to show details of a OCFile
       *  
       * @return  'True' when the fragment is ready to show details of a file
       */
      private boolean readyToShow() {
          return (getFile() != null && mAccount != null && mLayout == R.layout.file_details_fragment);        
      }
  
  
      /**
       * Updates the filename in view
       * @param filename to set
       */
      private void setFilename(String filename) {
          TextView tv = (TextView) getView().findViewById(R.id.fdFilename);
          if (tv != null)
              tv.setText(filename);
      }
  
      /**
       * Updates the MIME type in view
       * @param mimetype to set
       * @param filename
       */
      private void setFiletype(String mimetype, String filename) {
  