1 files changed, 388 insertions, 0 deletions
diff --git a/src/plugins/android.codeutils/src/com/motorola/studio/android/codeutils/codegeneration/DatabaseListActivityGeneratorByTable.java b/src/plugins/android.codeutils/src/com/motorola/studio/android/codeutils/codegeneration/DatabaseListActivityGeneratorByTable.java
new file mode 100644
index 0000000..1c4d9f2
--- /dev/null
+++ b/src/plugins/android.codeutils/src/com/motorola/studio/android/codeutils/codegeneration/DatabaseListActivityGeneratorByTable.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright (C) 2012 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.motorola.studio.android.codeutils.codegeneration;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.SubMonitor;
+import org.eclipse.datatools.modelbase.sql.datatypes.SQLDataType;
+import org.eclipse.datatools.modelbase.sql.tables.Column;
+import org.eclipse.datatools.modelbase.sql.tables.Table;
+import org.eclipse.jface.wizard.IWizardPage;
+
+import com.motorola.studio.android.codeutils.CodeUtilsActivator;
+import com.motorola.studio.android.codeutils.db.utils.DatabaseUtils;
+import com.motorola.studio.android.codeutils.i18n.CodeUtilsNLS;
+import com.motorola.studio.android.common.exception.AndroidException;
+import com.motorola.studio.android.common.log.StudioLogger;
+import com.motorola.studio.android.common.utilities.EclipseUtils;
+import com.motorola.studio.android.model.IDatabaseSampleActivityParametersWizardCollector;
+
+/**
+ * Helper class to create Activity based on Sqlite tables.
+ * It uses one file as template and substitutes parameters enclosed by hash-sign (#)  
+ * Warning: The tables named "ANDROID_METADATA" and "sqlite_sequence" will be ignored as it is an special table in Android apps context.
+ */
+public class DatabaseListActivityGeneratorByTable implements
+        IDatabaseSampleActivityParametersWizardCollector
+{
+
+    private static final String CLASS_EXTENTION_TYPE = "Activity";
+
+    private String databaseName = null;
+
+    private String sqlOpenHelperClassName = null;
+
+    private String sqlOpenHelperPackageName = null;
+
+    private boolean createOpenHelper = false;
+
+    private Table table = null;
+
+    private final List<Column> selectedColumns = new ArrayList<Column>();
+
+    //includes only items that are not default, that is with the java cursor type varies from the return type
+    private static Map<String, String> SQLTYPE_TO_CURSOR_TYPE_METHOD =
+            new HashMap<String, String>();
+
+    private static Map<String, String> SQLTYPE_TO_RETURN_TYPE = new HashMap<String, String>();
+
+    static
+    {
+        SQLTYPE_TO_CURSOR_TYPE_METHOD.put("BLOB", "Byte");
+        SQLTYPE_TO_CURSOR_TYPE_METHOD.put("INTEGER", "Int");
+
+        SQLTYPE_TO_RETURN_TYPE.put("CHAR", "String");
+        SQLTYPE_TO_RETURN_TYPE.put("VARCHAR", "String");
+        SQLTYPE_TO_RETURN_TYPE.put("TEXT", "String");
+        SQLTYPE_TO_RETURN_TYPE.put("SMALLINT", "Short");
+        SQLTYPE_TO_RETURN_TYPE.put("INTEGER", "Integer");
+        SQLTYPE_TO_RETURN_TYPE.put("BIGINT", "Long");
+        SQLTYPE_TO_RETURN_TYPE.put("REAL", "Float");
+        SQLTYPE_TO_RETURN_TYPE.put("FLOAT", "Double");
+        SQLTYPE_TO_RETURN_TYPE.put("DOUBLE", "Double");
+        SQLTYPE_TO_RETURN_TYPE.put("BINARY", "byte[]");
+        SQLTYPE_TO_RETURN_TYPE.put("VARBINARY", "byte[]");
+        SQLTYPE_TO_RETURN_TYPE.put("LONG VARBINARY", "byte[]");
+        SQLTYPE_TO_RETURN_TYPE.put("IMAGE", "byte[]");
+        SQLTYPE_TO_RETURN_TYPE.put("BLOB", "byte[]");
+    }
+
+    /**
+     * @return the table created by this class. 
+     * */
+    @Override
+    public Table getTable()
+    {
+        return this.table;
+    }
+
+    /**
+     * Sets the initial table to be used.
+     * */
+    @Override
+    public void setTable(Table table)
+    {
+        this.table = table;
+    }
+
+    @Override
+    public String getTableName()
+    {
+        return getTable().getName();
+    }
+
+    /**
+     * Authority to access content URI (it is based on package name and content provider name) 
+     * @param packageName the package name of the authority.
+     * @param activityName the activity name of the authority.
+     * @return the authority using package and activity name.
+     */
+    protected String getAuthority(String packageName, String activityName)
+    {
+        return packageName + "." + activityName.toLowerCase();
+    }
+
+    public String getClassName()
+    {
+        String className = getTableName() + CLASS_EXTENTION_TYPE;
+        return className;
+    }
+
+    @Override
+    public String getDatabaseName()
+    {
+        return this.databaseName;
+    }
+
+    @Override
+    public void setDatabaseName(String databaseName)
+    {
+        this.databaseName = databaseName;
+    }
+
+    /**
+     * @return a string representing a list of the column names. 
+     */
+    @Override
+    public String getColumnsNames()
+    {
+        StringBuilder buf = new StringBuilder();
+        String columnsResult = "";
+        for (int i = 0; i < selectedColumns.size(); i++)
+        {
+            int colIndex = i + 1;
+            String colSt = "COL_" + colIndex;
+            if ((colIndex > 1) && (colIndex <= selectedColumns.size()))
+            {
+                colSt = ", " + colSt;
+            }
+            columnsResult += colSt;
+        }
+        buf.append(columnsResult);
+        return buf.toString();
+    }
+
+    /**
+     * @return constants to get on table list
+     */
+    @Override
+    public String getConstColumnsNames()
+    {
+        StringBuilder buf = new StringBuilder();
+
+        ListIterator<Column> columnsIter = selectedColumns.listIterator();
+        int index = 1;
+        String constSt = "private final String ";
+        while (columnsIter.hasNext())
+        {
+            Column column = columnsIter.next();
+            String colSt = constSt + "COL_" + index + " = " + "\"" + column.getName() + "\";";
+            buf.append("\t" + colSt + "\n");
+            index++;
+        }
+        return buf.toString();
+    }
+
+    /**
+     * Creates add columns 
+     * @throws AndroidException when the type of a column is not valid.
+     */
+    @Override
+    public String getCursorValues() throws AndroidException
+    {
+        StringBuilder buf = new StringBuilder();
+
+        ListIterator<Column> columnsIter = selectedColumns.listIterator();
+        Integer index = 1;
+        String templateSt =
+                "#returnType# col#index# = cursor.get#CursorType#(cursor.getColumnIndex(COL_#index#));";
+        while (columnsIter.hasNext())
+        {
+            String cursorSt = templateSt;
+            Column column = columnsIter.next();
+            String columnName = column.getName().toLowerCase();
+            String sqltype = null;
+            SQLDataType type = column.getContainedType();
+            if (type != null)
+            {
+                sqltype = type.getName();
+            }
+            else
+            {
+                throw new AndroidException("Column " + columnName
+                        + " does not have a recognized type");
+            }
+
+            String javaReturnType = SQLTYPE_TO_RETURN_TYPE.get(sqltype);
+            cursorSt = cursorSt.replace("#returnType#", javaReturnType);
+            cursorSt = cursorSt.replaceAll("#index#", index.toString());
+            String getType = "";
+            if (SQLTYPE_TO_CURSOR_TYPE_METHOD.containsKey(sqltype))
+            {
+                //non-default rule
+                getType = SQLTYPE_TO_CURSOR_TYPE_METHOD.get(sqltype);
+            }
+            else
+            {
+                //default rule - getX where X is the java type
+                getType = SQLTYPE_TO_RETURN_TYPE.get(sqltype);
+                getType = getType.replace("[]", "");
+                //change first letter to upper case
+                String firstElem = "" + getType.charAt(0);
+                getType = getType.replace(firstElem, firstElem.toUpperCase());
+            }
+            cursorSt = cursorSt.replaceAll("#CursorType#", getType);
+            index++;
+            buf.append("\t" + cursorSt + "\n");
+        }
+        return buf.toString();
+    }
+
+    /**
+     * Creates add columns to row statements
+     */
+    @Override
+    public String getAddColumnsToRow()
+    {
+        StringBuilder buf = new StringBuilder();
+
+        String constSt = "addToRow(col#index# , row);";
+        for (int i = 0; i < selectedColumns.size(); i++)
+        {
+            String replacedText = constSt.replace("#index#", Integer.toString(i + 1));
+            buf.append("\t" + replacedText + "\n");
+        }
+        return buf.toString();
+    }
+
+    /**
+     * @return a list of wizard pages required to create activities based on database list templates.
+     * */
+    @Override
+    public List<IWizardPage> getWizardPages()
+    {
+        List<IWizardPage> contributedPages = new ArrayList<IWizardPage>();
+        contributedPages.add(new CreateSampleDatabaseActivityPage());
+        contributedPages.add(new CreateSampleDatabaseActivityColumnsPage());
+        contributedPages.add(new DefineSqlOpenHelperPage());
+        return contributedPages;
+    }
+
+    @Override
+    public void setSelectedColumns(List<Column> selectedColumns)
+    {
+        this.selectedColumns.addAll(selectedColumns);
+    }
+
+    /**
+     * Creates Sql Open Helper required to transfer db file and make the activity work correctly
+     */
+    @Override
+    public void createSqlOpenHelper(IProject project, IProgressMonitor monitor)
+    {
+        boolean createOpenHelper = true;
+        boolean createContentProvider = false;
+        boolean isOverrideContentProviders = false;
+        boolean generateDao = false;
+        String contentProvidersPackageName = null; //not used        
+
+        //create deployer
+        try
+        {
+            // sub monitor
+            SubMonitor subMonitor = SubMonitor.convert(monitor, 10);
+
+            DatabaseUtils.createDatabaseManagementClasses(project, databaseName, createOpenHelper,
+                    createContentProvider, sqlOpenHelperPackageName, contentProvidersPackageName,
+                    getSqlOpenHelperClassName(), isOverrideContentProviders, generateDao,
+                    subMonitor.newChild(10), false);
+        }
+        catch (Exception e)
+        {
+            StudioLogger.error(DatabaseListActivityGeneratorByTable.class,
+                    CodeUtilsNLS.DATABASE_DEPLOY_ERROR_DEPLOYING_DATABASE, e);
+            IStatus status =
+                    new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, e.getLocalizedMessage());
+            EclipseUtils.showErrorDialog(CodeUtilsNLS.DATABASE_DEPLOY_ERROR_DEPLOYING_DATABASE,
+                    CodeUtilsNLS.DATABASE_DEPLOY_ERROR_DEPLOYING_DATABASE, status);
+        }
+    }
+
+    @Override
+    public String getSqlOpenHelperClassName()
+    {
+        return this.sqlOpenHelperClassName;
+    }
+
+    @Override
+    public void setSqlOpenHelperClassName(String sqlOpenHelperClassName)
+    {
+        this.sqlOpenHelperClassName = sqlOpenHelperClassName;
+    }
+
+    @Override
+    public void setSqlOpenHelperPackageName(String sqlOpenHelperPackageName)
+    {
+        this.sqlOpenHelperPackageName = sqlOpenHelperPackageName;
+    }
+
+    /**
+     * @return The fully qualified name of the generated class to be used as {@code import} statement.
+     * */
+    @Override
+    public String getImports()
+    {
+        String imports = "";
+        if (createOpenHelper)
+        {
+            imports =
+                    "import " + this.sqlOpenHelperPackageName + "." + this.sqlOpenHelperClassName
+                            + ";";
+        }
+        return imports;
+    }
+
+    /**
+     * @return True if the open helper classes will be created. Otherwise, returns false. 
+     * */
+    @Override
+    public boolean createOpenHelper()
+    {
+        return this.createOpenHelper;
+    }
+
+    /**
+     * Set whether the open helper classes should be created.
+     * */
+    @Override
+    public void setCreateOpenHelper(boolean createOpenHelper)
+    {
+        this.createOpenHelper = createOpenHelper;
+    }
+
+    /**
+     * @return A string representing the necessary code to retrieve an android readable database of the database created in this class. 
+     * */
+    @Override
+    public String getReadableDatabase()
+    {
+        StringBuilder buf = new StringBuilder();
+
+        if (createOpenHelper)
+        {
+            buf.append(sqlOpenHelperClassName + " helper = new " + sqlOpenHelperClassName
+                    + "(getApplicationContext(),true);" + "\n");
+            buf.append("checkDB = helper.getReadableDatabase();" + "\n");
+        }
+        else
+        {
+            buf.append("String myPath = DB_PATH + DB_NAME;" + "\n");
+            buf.append("checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);"
+                    + "\n");
+        }
+        return buf.toString();
+    }
+}