android/src/com/android/tools/idea/sdk/remote/internal/sources/SdkSources.java - platform/tools/adt/idea - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.tools.idea.sdk.remote.internal.sources;

 import com.android.annotations.concurrency.GuardedBy;
 import com.android.prefs.AndroidLocation;
 import com.android.prefs.AndroidLocation.AndroidLocationException;
 import com.android.sdklib.repository.SdkSysImgConstants;
 import com.android.utils.ILogger;
 import com.google.common.collect.Lists;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.*;
 import java.util.Map.Entry;

 /**
  * A list of sdk-repository and sdk-addon sources, sorted by {@link SdkSourceCategory}.
  */
 public class SdkSources {

   private static final String KEY_COUNT = "count";

   private static final String KEY_SRC = "src";
   private static final String KEY_DISPLAY = "disp";

   private static final String SRC_FILENAME = "repositories.cfg"; //$NON-NLS-1$

   @GuardedBy("itself")
   private final EnumMap<SdkSourceCategory, ArrayList<SdkSource>> mySources =
     new EnumMap<SdkSourceCategory, ArrayList<SdkSource>>(SdkSourceCategory.class);

   public SdkSources() {
   }

   /**
    * Adds a new source to the Sources list.
    * <p/>
    * Implementation detail: {@link SdkSources} doesn't invoke {@link #notifyChangeListeners()}
    * directly. Callers who use {@code add()} are responsible for notifying the listeners once
    * they are done modifying the sources list. The intent is to notify the listeners only once
    * at the end, not for every single addition.
    */
   public void add(SdkSourceCategory category, SdkSource source) {
     synchronized (mySources) {
       ArrayList<SdkSource> list = mySources.get(category);
       if (list == null) {
         list = new ArrayList<SdkSource>();
         mySources.put(category, list);
       }

       list.add(source);
     }
   }

   /**
    * Replaces the current collection of sources corresponding to a particular category with the given collection.
    * <p/>
    * Implementation detail: {@link SdkSources} doesn't invoke {@link #notifyChangeListeners()}
    * directly. Callers who use {@code set()} are responsible for notifying the listeners once
    * they are done modifying the sources list. The intent is to notify the listeners only once
    * at the end, not for every single addition.
    */
   public void set(SdkSourceCategory category, Collection<SdkSource> sources) {
     synchronized (mySources) {
       mySources.put(category, Lists.newArrayList(sources));
     }
   }

   /**
    * Removes a source from the Sources list.
    * <p/>
    * Callers who remove entries are responsible for notifying the listeners using
    * {@link #notifyChangeListeners()} once they are done modifying the sources list.
    */
   public void remove(SdkSource source) {
     synchronized (mySources) {
       Iterator<Entry<SdkSourceCategory, ArrayList<SdkSource>>> it = mySources.entrySet().iterator();
       while (it.hasNext()) {
         Entry<SdkSourceCategory, ArrayList<SdkSource>> entry = it.next();
         ArrayList<SdkSource> list = entry.getValue();

         if (list.remove(source)) {
           if (list.isEmpty()) {
             // remove the entry since the source list became empty
             it.remove();
           }
         }
       }
     }
   }

   /**
    * Removes all the sources in the given category.
    * <p/>
    * Callers who remove entries are responsible for notifying the listeners using
    * {@link #notifyChangeListeners()} once they are done modifying the sources list.
    */
   public void removeAll(SdkSourceCategory category) {
     synchronized (mySources) {
       mySources.remove(category);
     }
   }

   /**
    * Returns a set of all categories that must be displayed. This includes all
    * categories that are to be always displayed as well as all categories which
    * have at least one source.
    * Might return a empty array, but never returns null.
    */
   public SdkSourceCategory[] getCategories() {
     ArrayList<SdkSourceCategory> cats = new ArrayList<SdkSourceCategory>();

     for (SdkSourceCategory cat : SdkSourceCategory.values()) {
       if (cat.getAlwaysDisplay()) {
         cats.add(cat);
       }
       else {
         synchronized (mySources) {
           ArrayList<SdkSource> list = mySources.get(cat);
           if (list != null && !list.isEmpty()) {
             cats.add(cat);
           }
         }
       }
     }

     return cats.toArray(new SdkSourceCategory[cats.size()]);
   }

   /**
    * Returns a new array of sources attached to the given category.
    * Might return an empty array, but never returns null.
    */
   public SdkSource[] getSources(SdkSourceCategory category) {
     synchronized (mySources) {
       ArrayList<SdkSource> list = mySources.get(category);
       if (list == null) {
         return new SdkSource[0];
       }
       else {
         return list.toArray(new SdkSource[list.size()]);
       }
     }
   }

   /**
    * Returns true if there are sources for the given category.
    */
   public boolean hasSources(SdkSourceCategory category) {
     synchronized (mySources) {
       ArrayList<SdkSource> list = mySources.get(category);
       return list != null && !list.isEmpty();
     }
   }

   /**
    * Returns an array of the sources across all categories. This is never null.
    */
   public SdkSource[] getAllSources() {
     synchronized (mySources) {
       int n = 0;

       for (ArrayList<SdkSource> list : mySources.values()) {
         n += list.size();
       }

       SdkSource[] sources = new SdkSource[n];

       int i = 0;
       for (ArrayList<SdkSource> list : mySources.values()) {
         for (SdkSource source : list) {
           sources[i++] = source;
         }
       }

       return sources;
     }
   }

   /**
    * Each source keeps a local cache of whatever it loaded recently.
    * This calls {@link SdkSource#clearPackages()} on all the available sources,
    * and the next call to {@link SdkSource#getPackages()} will actually reload
    * the remote package list.
    */
   public void clearAllPackages() {
     synchronized (mySources) {
       for (ArrayList<SdkSource> list : mySources.values()) {
         for (SdkSource source : list) {
           source.clearPackages();
         }
       }
     }
   }

   /**
    * Returns the category of a given source, or null if the source is unknown.
    * <p/>
    * Note that this method uses object identity to find a given source, and does
    * not identify sources by their URL like {@link #hasSourceUrl(SdkSource)} does.
    * <p/>
    * The search is O(N), which should be acceptable on the expectedly small source list.
    */
   public SdkSourceCategory getCategory(SdkSource source) {
     if (source != null) {
       synchronized (mySources) {
         for (Entry<SdkSourceCategory, ArrayList<SdkSource>> entry : mySources.entrySet()) {
           if (entry.getValue().contains(source)) {
             return entry.getKey();
           }
         }
       }
     }
     return null;
   }

   /**
    * Returns true if there's already a similar source in the sources list
    * under any category.
    * <p/>
    * Important: The match is NOT done on object identity.
    * Instead, this searches for a <em>similar</em> source, based on
    * {@link SdkSource#equals(Object)} which compares the source URLs.
    * <p/>
    * The search is O(N), which should be acceptable on the expectedly small source list.
    */
   public boolean hasSourceUrl(SdkSource source) {
     synchronized (mySources) {
       for (ArrayList<SdkSource> list : mySources.values()) {
         for (SdkSource s : list) {
           if (s.equals(source)) {
             return true;
           }
         }
       }
       return false;
     }
   }

   /**
    * Returns true if there's already a similar source in the sources list
    * under the specified category.
    * <p/>
    * Important: The match is NOT done on object identity.
    * Instead, this searches for a <em>similar</em> source, based on
    * {@link SdkSource#equals(Object)} which compares the source URLs.
    * <p/>
    * The search is O(N), which should be acceptable on the expectedly small source list.
    */
   public boolean hasSourceUrl(SdkSourceCategory category, SdkSource source) {
     synchronized (mySources) {
       ArrayList<SdkSource> list = mySources.get(category);
       if (list != null) {
         for (SdkSource s : list) {
           if (s.equals(source)) {
             return true;
           }
         }
       }
       return false;
     }
   }

   /**
    * Loads all user sources. This <em>replaces</em> all existing user sources
    * by the ones from the property file.
    * <p/>
    * This calls {@link #notifyChangeListeners()} at the end of the operation.
    */
   public void loadUserAddons(ILogger log) {
     // Implementation detail: synchronize on the sources list to make sure that
     // a- the source list doesn't change while we load/save it, and most important
     // b- to make sure it's not being saved while loaded or the reverse.
     // In most cases we do these operation from the UI thread so it's not really
     // that necessary. This is more a protection in case of someone calls this
     // from a worker thread by mistake.
     synchronized (mySources) {
       // Remove all existing user sources
       removeAll(SdkSourceCategory.USER_ADDONS);

       // Load new user sources from property file
       FileInputStream fis = null;
       try {
         String folder = AndroidLocation.getFolder();
         File f = new File(folder, SRC_FILENAME);
         if (f.exists()) {
           fis = new FileInputStream(f);

           Properties props = new Properties();
           props.load(fis);

           int count = Integer.parseInt(props.getProperty(KEY_COUNT, "0"));

           for (int i = 0; i < count; i++) {
             String url = props.getProperty(String.format("%s%02d", KEY_SRC, i));  //$NON-NLS-1$
             String disp = props.getProperty(String.format("%s%02d", KEY_DISPLAY, i));  //$NON-NLS-1$
             if (url != null) {
               // FIXME: this code originally only dealt with add-on XML sources.
               // Now we'd like it to deal with system-image sources too, but we
               // don't know which kind of object it is (at least not without
               // trying to fetch it.) As a temporary workaround, just take a
               // guess based on the leaf URI name. However ideally what we can
               // simply do is add a checkbox "is system-image XML" in the user
               // dialog and pass this info down here. Another alternative is to
               // make a "dynamic" source object that tries to guess its type once
               // the URI has been fetched.
               SdkSource s;
               if (url.endsWith(SdkSysImgConstants.URL_DEFAULT_FILENAME)) {
                 s = new SdkSysImgSource(url, disp);
               }
               else {
                 s = new SdkAddonSource(url, disp);
               }
               if (!hasSourceUrl(s)) {
                 add(SdkSourceCategory.USER_ADDONS, s);
               }
             }
           }
         }

       }
       catch (NumberFormatException e) {
         log.error(e, null);

       }
       catch (AndroidLocationException e) {
         log.error(e, null);

       }
       catch (IOException e) {
         log.error(e, null);

       }
       finally {
         if (fis != null) {
           try {
             fis.close();
           }
           catch (IOException e) {
           }
         }
       }
     }
   }

   /**
    * Saves all the user sources.
    *
    * @param log Logger. Cannot be null.
    */
   public void saveUserAddons(ILogger log) {
     // See the implementation detail note in loadUserAddons() about the synchronization.
     synchronized (mySources) {
       FileOutputStream fos = null;
       try {
         String folder = AndroidLocation.getFolder();
         File f = new File(folder, SRC_FILENAME);

         fos = new FileOutputStream(f);

         Properties props = new Properties();

         int count = 0;
         for (SdkSource s : getSources(SdkSourceCategory.USER_ADDONS)) {
           props.setProperty(String.format("%s%02d", KEY_SRC, count), //$NON-NLS-1$
                             s.getUrl());
           if (s.getUiName() != null) {
             props.setProperty(String.format("%s%02d", KEY_DISPLAY, count), //$NON-NLS-1$
                               s.getUiName());
           }
           count++;
         }
         props.setProperty(KEY_COUNT, Integer.toString(count));

         props.store(fos, "## User Sources for Android SDK Manager");  //$NON-NLS-1$

       }
       catch (AndroidLocationException e) {
         log.error(e, null);

       }
       catch (IOException e) {
         log.error(e, null);

       }
       finally {
         if (fos != null) {
           try {
             fos.close();
           }
           catch (IOException e) {
           }
         }
       }
     }
   }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.tools.idea.sdk.remote.internal.sources;

	import com.android.annotations.concurrency.GuardedBy;
	import com.android.prefs.AndroidLocation;
	import com.android.prefs.AndroidLocation.AndroidLocationException;
	import com.android.sdklib.repository.SdkSysImgConstants;
	import com.android.utils.ILogger;
	import com.google.common.collect.Lists;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.util.*;
	import java.util.Map.Entry;

	/**
	* A list of sdk-repository and sdk-addon sources, sorted by {@link SdkSourceCategory}.
	*/
	public class SdkSources {

	private static final String KEY_COUNT = "count";

	private static final String KEY_SRC = "src";
	private static final String KEY_DISPLAY = "disp";

	private static final String SRC_FILENAME = "repositories.cfg"; //$NON-NLS-1$

	@GuardedBy("itself")
	private final EnumMap<SdkSourceCategory, ArrayList<SdkSource>> mySources =
	new EnumMap<SdkSourceCategory, ArrayList<SdkSource>>(SdkSourceCategory.class);

	public SdkSources() {
	}

	/**
	* Adds a new source to the Sources list.
	* <p/>
	* Implementation detail: {@link SdkSources} doesn't invoke {@link #notifyChangeListeners()}
	* directly. Callers who use {@code add()} are responsible for notifying the listeners once
	* they are done modifying the sources list. The intent is to notify the listeners only once
	* at the end, not for every single addition.
	*/
	public void add(SdkSourceCategory category, SdkSource source) {
	synchronized (mySources) {
	ArrayList<SdkSource> list = mySources.get(category);
	if (list == null) {
	list = new ArrayList<SdkSource>();
	mySources.put(category, list);
	}

	list.add(source);
	}
	}

	/**
	* Replaces the current collection of sources corresponding to a particular category with the given collection.
	* <p/>
	* Implementation detail: {@link SdkSources} doesn't invoke {@link #notifyChangeListeners()}
	* directly. Callers who use {@code set()} are responsible for notifying the listeners once
	* they are done modifying the sources list. The intent is to notify the listeners only once
	* at the end, not for every single addition.
	*/
	public void set(SdkSourceCategory category, Collection<SdkSource> sources) {
	synchronized (mySources) {
	mySources.put(category, Lists.newArrayList(sources));
	}
	}

	/**
	* Removes a source from the Sources list.
	* <p/>
	* Callers who remove entries are responsible for notifying the listeners using
	* {@link #notifyChangeListeners()} once they are done modifying the sources list.
	*/
	public void remove(SdkSource source) {
	synchronized (mySources) {
	Iterator<Entry<SdkSourceCategory, ArrayList<SdkSource>>> it = mySources.entrySet().iterator();
	while (it.hasNext()) {
	Entry<SdkSourceCategory, ArrayList<SdkSource>> entry = it.next();
	ArrayList<SdkSource> list = entry.getValue();

	if (list.remove(source)) {
	if (list.isEmpty()) {
	// remove the entry since the source list became empty
	it.remove();
	}
	}
	}
	}
	}

	/**
	* Removes all the sources in the given category.
	* <p/>
	* Callers who remove entries are responsible for notifying the listeners using
	* {@link #notifyChangeListeners()} once they are done modifying the sources list.
	*/
	public void removeAll(SdkSourceCategory category) {
	synchronized (mySources) {
	mySources.remove(category);
	}
	}

	/**
	* Returns a set of all categories that must be displayed. This includes all
	* categories that are to be always displayed as well as all categories which
	* have at least one source.
	* Might return a empty array, but never returns null.
	*/
	public SdkSourceCategory[] getCategories() {
	ArrayList<SdkSourceCategory> cats = new ArrayList<SdkSourceCategory>();

	for (SdkSourceCategory cat : SdkSourceCategory.values()) {
	if (cat.getAlwaysDisplay()) {
	cats.add(cat);
	}
	else {
	synchronized (mySources) {
	ArrayList<SdkSource> list = mySources.get(cat);
	if (list != null && !list.isEmpty()) {
	cats.add(cat);
	}
	}
	}
	}

	return cats.toArray(new SdkSourceCategory[cats.size()]);
	}

	/**
	* Returns a new array of sources attached to the given category.
	* Might return an empty array, but never returns null.
	*/
	public SdkSource[] getSources(SdkSourceCategory category) {
	synchronized (mySources) {
	ArrayList<SdkSource> list = mySources.get(category);
	if (list == null) {
	return new SdkSource[0];
	}
	else {
	return list.toArray(new SdkSource[list.size()]);
	}
	}
	}

	/**
	* Returns true if there are sources for the given category.
	*/
	public boolean hasSources(SdkSourceCategory category) {
	synchronized (mySources) {
	ArrayList<SdkSource> list = mySources.get(category);
	return list != null && !list.isEmpty();
	}
	}

	/**
	* Returns an array of the sources across all categories. This is never null.
	*/
	public SdkSource[] getAllSources() {
	synchronized (mySources) {
	int n = 0;

	for (ArrayList<SdkSource> list : mySources.values()) {
	n += list.size();
	}

	SdkSource[] sources = new SdkSource[n];

	int i = 0;
	for (ArrayList<SdkSource> list : mySources.values()) {
	for (SdkSource source : list) {
	sources[i++] = source;
	}
	}

	return sources;
	}
	}

	/**
	* Each source keeps a local cache of whatever it loaded recently.
	* This calls {@link SdkSource#clearPackages()} on all the available sources,
	* and the next call to {@link SdkSource#getPackages()} will actually reload
	* the remote package list.
	*/
	public void clearAllPackages() {
	synchronized (mySources) {
	for (ArrayList<SdkSource> list : mySources.values()) {
	for (SdkSource source : list) {
	source.clearPackages();
	}
	}
	}
	}

	/**
	* Returns the category of a given source, or null if the source is unknown.
	* <p/>
	* Note that this method uses object identity to find a given source, and does
	* not identify sources by their URL like {@link #hasSourceUrl(SdkSource)} does.
	* <p/>
	* The search is O(N), which should be acceptable on the expectedly small source list.
	*/
	public SdkSourceCategory getCategory(SdkSource source) {
	if (source != null) {
	synchronized (mySources) {
	for (Entry<SdkSourceCategory, ArrayList<SdkSource>> entry : mySources.entrySet()) {
	if (entry.getValue().contains(source)) {
	return entry.getKey();
	}
	}
	}
	}
	return null;
	}

	/**
	* Returns true if there's already a similar source in the sources list
	* under any category.
	* <p/>
	* Important: The match is NOT done on object identity.
	* Instead, this searches for a <em>similar</em> source, based on
	* {@link SdkSource#equals(Object)} which compares the source URLs.
	* <p/>
	* The search is O(N), which should be acceptable on the expectedly small source list.
	*/
	public boolean hasSourceUrl(SdkSource source) {
	synchronized (mySources) {
	for (ArrayList<SdkSource> list : mySources.values()) {
	for (SdkSource s : list) {
	if (s.equals(source)) {
	return true;
	}
	}
	}
	return false;
	}
	}

	/**
	* Returns true if there's already a similar source in the sources list
	* under the specified category.
	* <p/>
	* Important: The match is NOT done on object identity.
	* Instead, this searches for a <em>similar</em> source, based on
	* {@link SdkSource#equals(Object)} which compares the source URLs.
	* <p/>
	* The search is O(N), which should be acceptable on the expectedly small source list.
	*/
	public boolean hasSourceUrl(SdkSourceCategory category, SdkSource source) {
	synchronized (mySources) {
	ArrayList<SdkSource> list = mySources.get(category);
	if (list != null) {
	for (SdkSource s : list) {
	if (s.equals(source)) {
	return true;
	}
	}
	}
	return false;
	}
	}

	/**
	* Loads all user sources. This <em>replaces</em> all existing user sources
	* by the ones from the property file.
	* <p/>
	* This calls {@link #notifyChangeListeners()} at the end of the operation.
	*/
	public void loadUserAddons(ILogger log) {
	// Implementation detail: synchronize on the sources list to make sure that
	// a- the source list doesn't change while we load/save it, and most important
	// b- to make sure it's not being saved while loaded or the reverse.
	// In most cases we do these operation from the UI thread so it's not really
	// that necessary. This is more a protection in case of someone calls this
	// from a worker thread by mistake.
	synchronized (mySources) {
	// Remove all existing user sources
	removeAll(SdkSourceCategory.USER_ADDONS);

	// Load new user sources from property file
	FileInputStream fis = null;
	try {
	String folder = AndroidLocation.getFolder();
	File f = new File(folder, SRC_FILENAME);
	if (f.exists()) {
	fis = new FileInputStream(f);

	Properties props = new Properties();
	props.load(fis);

	int count = Integer.parseInt(props.getProperty(KEY_COUNT, "0"));

	for (int i = 0; i < count; i++) {
	String url = props.getProperty(String.format("%s%02d", KEY_SRC, i)); //$NON-NLS-1$
	String disp = props.getProperty(String.format("%s%02d", KEY_DISPLAY, i)); //$NON-NLS-1$
	if (url != null) {
	// FIXME: this code originally only dealt with add-on XML sources.
	// Now we'd like it to deal with system-image sources too, but we
	// don't know which kind of object it is (at least not without
	// trying to fetch it.) As a temporary workaround, just take a
	// guess based on the leaf URI name. However ideally what we can
	// simply do is add a checkbox "is system-image XML" in the user
	// dialog and pass this info down here. Another alternative is to
	// make a "dynamic" source object that tries to guess its type once
	// the URI has been fetched.
	SdkSource s;
	if (url.endsWith(SdkSysImgConstants.URL_DEFAULT_FILENAME)) {
	s = new SdkSysImgSource(url, disp);
	}
	else {
	s = new SdkAddonSource(url, disp);
	}
	if (!hasSourceUrl(s)) {
	add(SdkSourceCategory.USER_ADDONS, s);
	}
	}
	}
	}

	}
	catch (NumberFormatException e) {
	log.error(e, null);

	}
	catch (AndroidLocationException e) {
	log.error(e, null);

	}
	catch (IOException e) {
	log.error(e, null);

	}
	finally {
	if (fis != null) {
	try {
	fis.close();
	}
	catch (IOException e) {
	}
	}
	}
	}
	}

	/**
	* Saves all the user sources.
	*
	* @param log Logger. Cannot be null.
	*/
	public void saveUserAddons(ILogger log) {
	// See the implementation detail note in loadUserAddons() about the synchronization.
	synchronized (mySources) {
	FileOutputStream fos = null;
	try {
	String folder = AndroidLocation.getFolder();
	File f = new File(folder, SRC_FILENAME);

	fos = new FileOutputStream(f);

	Properties props = new Properties();

	int count = 0;
	for (SdkSource s : getSources(SdkSourceCategory.USER_ADDONS)) {
	props.setProperty(String.format("%s%02d", KEY_SRC, count), //$NON-NLS-1$
	s.getUrl());
	if (s.getUiName() != null) {
	props.setProperty(String.format("%s%02d", KEY_DISPLAY, count), //$NON-NLS-1$
	s.getUiName());
	}
	count++;
	}
	props.setProperty(KEY_COUNT, Integer.toString(count));

	props.store(fos, "## User Sources for Android SDK Manager"); //$NON-NLS-1$

	}
	catch (AndroidLocationException e) {
	log.error(e, null);

	}
	catch (IOException e) {
	log.error(e, null);

	}
	finally {
	if (fos != null) {
	try {
	fos.close();
	}
	catch (IOException e) {
	}
	}
	}
	}
	}
	}