/*
* Copyright (C) 2013 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.wizard;
import com.android.sdklib.BuildToolInfo;
import com.android.tools.idea.templates.KeystoreUtils;
import com.android.tools.idea.templates.RepositoryUrlManager;
import com.android.tools.idea.templates.TemplateMetadata;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.containers.HashSet;
import org.jetbrains.android.sdk.AndroidSdkData;
import org.jetbrains.android.sdk.AndroidSdkUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.*;
import static com.android.tools.idea.templates.KeystoreUtils.getOrCreateDefaultDebugKeystore;
import static com.android.tools.idea.templates.RepositoryUrlManager.*;
import static com.android.tools.idea.templates.TemplateMetadata.*;
/**
* Value object which holds the current state of the wizard pages for the
* {@link com.android.tools.idea.wizard.NewModuleWizard}
*
* Deprecated. Use {@link ScopedStateStore} instead.
*/
@Deprecated
public class NewModuleWizardState extends TemplateWizardState {
private static final Logger LOG = Logger.getInstance(NewModuleWizardState.class);
public static final String ATTR_CREATE_ACTIVITY = "createActivity";
public static final String ATTR_PROJECT_LOCATION = "projectLocation";
public static final String APP_NAME = "app";
public static final String LIB_NAME = "lib";
public static final String MODULE_IMPORT_NAME = "Import Existing Project";
public static final String ARCHIVE_IMPORT_NAME = "Import .JAR or .AAR Package";
/**
* State for the template wizard, used to embed an activity template
*/
protected final TemplateWizardState myActivityTemplateState;
/**
* Modules that will be imported.
*/
private Map<String, VirtualFile> myModulesToImport;
/**
* Map from a template name to the wizard path that has provided this template.
*/
private Map<String, WizardPath> myTemplateToPathMap = new HashMap<String, WizardPath>();
/**
* The active wizard path.
*/
private WizardPath myActiveWizardPath;
private WizardPath myDefaultPath;
public NewModuleWizardState() {
myActivityTemplateState = new TemplateWizardState();
myHidden.add(ATTR_PROJECT_LOCATION);
myHidden.remove(ATTR_IS_LIBRARY_MODULE);
put(ATTR_IS_LAUNCHER, false);
put(ATTR_CREATE_ICONS, false);
put(ATTR_IS_NEW_PROJECT, true);
put(ATTR_CREATE_ACTIVITY, true);
put(ATTR_IS_LIBRARY_MODULE, false);
putSdkDependentParams();
try {
myActivityTemplateState.put(ATTR_DEBUG_KEYSTORE_SHA1, KeystoreUtils.sha1(getOrCreateDefaultDebugKeystore()));
}
catch (Exception e) {
LOG.info("Could not compute SHA1 hash of debug keystore.", e);
}
myActivityTemplateState.myHidden.add(ATTR_PACKAGE_NAME);
myActivityTemplateState.myHidden.add(ATTR_APP_TITLE);
myActivityTemplateState.myHidden.add(ATTR_MIN_API);
myActivityTemplateState.myHidden.add(ATTR_MIN_API_LEVEL);
myActivityTemplateState.myHidden.add(ATTR_TARGET_API);
myActivityTemplateState.myHidden.add(ATTR_TARGET_API_STRING);
myActivityTemplateState.myHidden.add(ATTR_BUILD_API);
myActivityTemplateState.myHidden.add(ATTR_BUILD_API_STRING);
myActivityTemplateState.myHidden.add(ATTR_COPY_ICONS);
myActivityTemplateState.myHidden.add(ATTR_IS_LAUNCHER);
myActivityTemplateState.myHidden.add(ATTR_PARENT_ACTIVITY_CLASS);
myActivityTemplateState.myHidden.add(ATTR_ACTIVITY_TITLE);
updateParameters();
}
public static boolean isAndroidTemplate(@Nullable TemplateMetadata templateMetadata) {
return templateMetadata != null && templateMetadata.getParameter(ATTR_MIN_API) != null;
}
public void setDefaultWizardPath(WizardPath defaultPath) {
myDefaultPath = defaultPath;
}
public void templateChanged(@Nullable Project project, String templateName) {
setTemplateName(templateName);
if (templateName.equals(TemplateWizardModuleBuilder.LIB_TEMPLATE_NAME)) {
put(ATTR_IS_LIBRARY_MODULE, true);
put(ATTR_IS_LAUNCHER, false);
put(ATTR_CREATE_ICONS, false);
// Hide the create icons checkbox
myHidden.add(ATTR_CREATE_ICONS);
} else if (templateName.equals(TemplateWizardModuleBuilder.APP_TEMPLATE_NAME)) {
put(ATTR_IS_LIBRARY_MODULE, false);
put(ATTR_IS_LAUNCHER, true);
put(ATTR_CREATE_ICONS, true);
// Show the create icons checkbox
myHidden.remove(ATTR_CREATE_ICONS);
}
if (myHidden.contains(ATTR_APP_TITLE)) {
// If the app title is hidden, set it to the existing app title
assert project != null : "Cannot be adding a module to a unknown project";
put(ATTR_APP_TITLE, project.getName());
}
}
private void setTemplateName(@Nullable String templateName) {
myActiveWizardPath = myTemplateToPathMap.get(templateName);
}
@NotNull
public WizardPath getActiveWizardPath() {
return myActiveWizardPath != null ? myActiveWizardPath : myDefaultPath;
}
public void putSdkDependentParams() {
final AndroidSdkData sdkData = AndroidSdkUtils.tryToChooseAndroidSdk();
BuildToolInfo buildTool = sdkData != null ? sdkData.getLatestBuildTool() : null;
if (buildTool != null) {
// If buildTool is null, the template will use buildApi instead, which might be good enough.
put(ATTR_BUILD_TOOLS_VERSION, buildTool.getRevision().toString());
}
if (sdkData != null) {
// Gradle expects a platform-neutral path
put(ATTR_SDK_DIR, FileUtil.toSystemIndependentName(sdkData.getPath()));
}
}
@NotNull
public TemplateWizardState getActivityTemplateState() {
return myActivityTemplateState;
}
/**
* Call this to update the list of dependencies to be compiled into the template
*/
public void updateDependencies() {
// Take care of dependencies selected through the wizard
Set<String> dependencySet = new HashSet<String>();
if (myParameters.containsKey(ATTR_DEPENDENCIES_LIST)) {
dependencySet.addAll((Collection<String>)get(ATTR_DEPENDENCIES_LIST));
}
RepositoryUrlManager urlManager = RepositoryUrlManager.get();
// Support Library
if ((get(ATTR_FRAGMENTS_EXTRA) != null && Boolean.parseBoolean(get(ATTR_FRAGMENTS_EXTRA).toString())) ||
(get(ATTR_NAVIGATION_DRAWER_EXTRA) != null && Boolean.parseBoolean(get(ATTR_NAVIGATION_DRAWER_EXTRA).toString()))) {
dependencySet.add(urlManager.getLibraryCoordinate(SUPPORT_ID_V4));
}
// AppCompat Library
if (get(ATTR_ACTION_BAR_EXTRA) != null && Boolean.parseBoolean(get(ATTR_ACTION_BAR_EXTRA).toString())) {
dependencySet.add(urlManager.getLibraryCoordinate(APP_COMPAT_ID_V7));
}
// GridLayout Library
if (get(ATTR_GRID_LAYOUT_EXTRA) != null && Boolean.parseBoolean(get(ATTR_GRID_LAYOUT_EXTRA).toString())) {
dependencySet.add(urlManager.getLibraryCoordinate(GRID_LAYOUT_ID_V7));
}
put(ATTR_DEPENDENCIES_LIST, new LinkedList<String>(dependencySet));
}
/**
* Call this to have this state object propagate common parameter values to sub-state objects
* (i.e. states for other template wizards that are part of the same dialog).
*/
public void updateParameters() {
put(ATTR_COPY_ICONS, !Boolean.parseBoolean(get(ATTR_CREATE_ICONS).toString()));
copyParameters(myParameters, myActivityTemplateState.myParameters, ATTR_PACKAGE_NAME, ATTR_APP_TITLE, ATTR_MIN_API, ATTR_MIN_API_LEVEL,
ATTR_TARGET_API, ATTR_TARGET_API_STRING, ATTR_BUILD_API_STRING,
ATTR_BUILD_API, ATTR_COPY_ICONS, ATTR_IS_NEW_PROJECT, ATTR_IS_LAUNCHER, ATTR_CREATE_ACTIVITY,
ATTR_CREATE_ICONS, ATTR_IS_GRADLE,
ATTR_TOP_OUT, ATTR_PROJECT_OUT, ATTR_SRC_OUT, ATTR_TEST_OUT, ATTR_RES_OUT, ATTR_MANIFEST_OUT);
}
protected void copyParameters(@NotNull Map<String, Object> from, @NotNull Map<String, Object> to, String... keys) {
for (String key : keys) {
to.put(key, from.get(key));
}
}
@Nullable
public Map<String, VirtualFile> getModulesToImport() {
return myModulesToImport;
}
public void setModulesToImport(@Nullable Map<String, VirtualFile> modulesToImport) {
myModulesToImport = modulesToImport;
}
public void associateTemplateWithPath(String templateName, WizardPath path) {
myTemplateToPathMap.put(templateName, path);
// Initialize to the first existing wizard path by default.
if (myActiveWizardPath == null) {
myActiveWizardPath = path;
}
}
public boolean isOnDefaultWizardPath() {
return myActiveWizardPath == myDefaultPath;
}
}