/*
* Copyright (C) 2010 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.sdklib.internal.project;
import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.io.IAbstractFile;
import com.android.io.IAbstractFolder;
import com.android.io.StreamException;
import com.google.common.io.Closeables;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
/**
* A modifiable and savable copy of a {@link ProjectProperties}.
* <p/>This copy gives access to modification method such as {@link #setProperty(String, String)}
* and {@link #removeProperty(String)}.
*
* To get access to an instance, use {@link ProjectProperties#makeWorkingCopy()} or
* {@link ProjectProperties#create(IAbstractFolder, PropertyType)}.
*/
public class ProjectPropertiesWorkingCopy extends ProjectProperties {
private static final Map<String, String> COMMENT_MAP = new HashMap<String, String>();
static {
// 1-------10--------20--------30--------40--------50--------60--------70--------80
COMMENT_MAP.put(PROPERTY_TARGET,
"# Project target.\n");
COMMENT_MAP.put(PROPERTY_SPLIT_BY_DENSITY,
"# Indicates whether an apk should be generated for each density.\n");
COMMENT_MAP.put(PROPERTY_SDK,
"# location of the SDK. This is only used by Ant\n" +
"# For customization when using a Version Control System, please read the\n" +
"# header note.\n");
COMMENT_MAP.put(PROPERTY_PACKAGE,
"# Package of the application being exported\n");
COMMENT_MAP.put(PROPERTY_VERSIONCODE,
"# Major version code\n");
COMMENT_MAP.put(PROPERTY_PROJECTS,
"# List of the Android projects being used for the export.\n" +
"# The list is made of paths that are relative to this project,\n" +
"# using forward-slash (/) as separator, and are separated by colons (:).\n");
}
/**
* Sets a new properties. If a property with the same name already exists, it is replaced.
* @param name the name of the property.
* @param value the value of the property.
*/
public synchronized void setProperty(String name, String value) {
mProperties.put(name, value);
}
/**
* Removes a property and returns its previous value (or null if the property did not exist).
* @param name the name of the property to remove.
*/
public synchronized String removeProperty(String name) {
return mProperties.remove(name);
}
/**
* Merges all properties from the given file into the current properties.
* <p/>
* This emulates the Ant behavior: existing properties are <em>not</em> overridden.
* Only new undefined properties become defined.
* <p/>
* Typical usage:
* <ul>
* <li>Create a ProjectProperties with {@code PropertyType#ANT}
* <li>Merge in values using {@code PropertyType#PROJECT}
* <li>The result is that this contains all the properties from default plus those
* overridden by the build.properties file.
* </ul>
*
* @param type One the possible {@link ProjectProperties.PropertyType}s.
* @return this object, for chaining.
*/
public synchronized ProjectPropertiesWorkingCopy merge(PropertyType type) {
if (mProjectFolder.exists() && mType != type) {
IAbstractFile propFile = mProjectFolder.getFile(type.getFilename());
if (propFile.exists()) {
Map<String, String> map = parsePropertyFile(propFile, null /* log */);
if (map != null) {
for (Entry<String, String> entry : map.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
if (!mProperties.containsKey(key) && value != null) {
mProperties.put(key, value);
}
}
}
}
}
return this;
}
/**
* Saves the property file, using UTF-8 encoding.
* @throws IOException
* @throws StreamException
*/
public synchronized void save() throws IOException, StreamException {
IAbstractFile toSave = mProjectFolder.getFile(mType.getFilename());
// write the whole file in a byte array before dumping it in the file. This
// This is so that if the file already existing
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(baos, SdkConstants.INI_CHARSET);
if (toSave.exists()) {
InputStream contentStream = toSave.getContents();
InputStreamReader isr = null;
BufferedReader reader = null;
try {
contentStream = toSave.getContents();
//noinspection IOResourceOpenedButNotSafelyClosed
isr = new InputStreamReader(contentStream, SdkConstants.INI_CHARSET);
//noinspection IOResourceOpenedButNotSafelyClosed
reader = new BufferedReader(isr);
// since we're reading the existing file and replacing values with new ones, or skipping
// removed values, we need to record what properties have been visited, so that
// we can figure later what new properties need to be added at the end of the file.
Set<String> visitedProps = new HashSet<String>();
String line = null;
while ((line = reader.readLine()) != null) {
// check if this is a line containing a property.
if (!line.isEmpty() && line.charAt(0) != '#') {
Matcher m = PATTERN_PROP.matcher(line);
if (m.matches()) {
String key = m.group(1);
String value = m.group(2);
// record the prop
visitedProps.add(key);
// check if this property must be removed.
if (mType.isRemovedProperty(key)) {
value = null;
} else if (mProperties.containsKey(key)) { // if the property still exists.
// put the new value.
value = mProperties.get(key);
} else {
// property doesn't exist. Check if it's a known property.
// if it's a known one, we'll remove it, otherwise, leave it untouched.
if (mType.isKnownProperty(key)) {
value = null;
}
}
// if the value is still valid, write it down.
if (value != null) {
writeValue(writer, key, value, false /*addComment*/);
}
} else {
// the line was wrong, let's just ignore it so that it's removed from the
// file.
}
} else {
// non-property line: just write the line in the output as-is.
writer.append(line).append('\n');
}
}
// now add the new properties.
for (Entry<String, String> entry : mProperties.entrySet()) {
if (!visitedProps.contains(entry.getKey())) {
String value = entry.getValue();
if (value != null) {
writeValue(writer, entry.getKey(), value, true /*addComment*/);
}
}
}
} finally {
try {
Closeables.close(reader, true /* swallowIOException */);
} catch (IOException e) {
// cannot happen
}
try {
Closeables.close(isr, true /* swallowIOException */);
} catch (IOException e) {
// cannot happen
}
try {
Closeables.close(contentStream, true /* swallowIOException */);
} catch (IOException e) {
// cannot happen
}
}
} else {
// new file, just write it all
// write the header (can be null, for example for PropertyType.LEGACY_BUILD)
if (mType.getHeader() != null) {
writer.write(mType.getHeader());
}
// write the properties.
for (Entry<String, String> entry : mProperties.entrySet()) {
String value = entry.getValue();
if (value != null) {
writeValue(writer, entry.getKey(), value, true /*addComment*/);
}
}
}
writer.flush();
// now put the content in the file.
OutputStream filestream = toSave.getOutputStream();
filestream.write(baos.toByteArray());
filestream.flush();
filestream.close();
}
private void writeValue(OutputStreamWriter writer, String key, String value,
boolean addComment) throws IOException {
if (addComment) {
String comment = COMMENT_MAP.get(key);
if (comment != null) {
writer.write(comment);
}
}
writer.write(String.format("%s=%s\n", key, escape(value)));
}
/**
* Private constructor.
* <p/>
* Use {@link #load(String, PropertyType)} or {@link #create(String, PropertyType)}
* to instantiate.
*/
ProjectPropertiesWorkingCopy(IAbstractFolder projectFolder, Map<String, String> map,
PropertyType type) {
super(projectFolder, map, type);
}
@NonNull
public ProjectProperties makeReadOnlyCopy() {
// copy the current properties in a new map
Map<String, String> propList = new HashMap<String, String>(mProperties);
return new ProjectProperties(mProjectFolder, propList, mType);
}
}