com.squareup.javawriter.JavaWriter Java Examples

private void generateMemento(Set<? extends Element> elements, Element hostActivity, TypeElement activityType)
        throws IOException {
    PackageElement packageElement = processingEnv.getElementUtils().getPackageOf(hostActivity);
    final String simpleClassName = hostActivity.getSimpleName() + "$Memento";
    final String qualifiedClassName = packageElement.getQualifiedName() + "." + simpleClassName;

    log("writing class " + qualifiedClassName);
    JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(
            qualifiedClassName, elements.toArray(new Element[elements.size()]));

    JavaWriter writer = new JavaWriter(sourceFile.openWriter());

    emitClassHeader(packageElement, activityType, writer);

    writer.beginType(qualifiedClassName, "class", EnumSet.of(Modifier.PUBLIC, Modifier.FINAL),
            "Fragment", LIB_PACKAGE + ".MementoMethods");

    emitFields(elements, writer);
    emitConstructor(simpleClassName, writer);
    emitReaderMethod(elements, hostActivity, writer);
    emitWriterMethod(elements, hostActivity, writer);

    writer.endType();
    writer.close();
}
 

@Override
public void writeSource(Writer writer, TypeElement element) throws IOException {
	JavaWriter javaWriter = new JavaWriter(writer);
	javaWriter.setCompressingTypes(true);
	javaWriter.setIndent("\t");

	javaWriter.emitSingleLineComment("Generated by Ollie. Do not modify!");
	javaWriter.emitPackage("ollie");

	writeImports(javaWriter);

	javaWriter.beginType(AdapterHolder.IMPL_CLASS_NAME, "class", METHOD_MODIFIERS, null, "AdapterHolder");

	writeCollections(javaWriter);
	writeStaticInitializations(javaWriter);
	writeGetMigrations(javaWriter);
	writeGetModelAdapter(javaWriter);
	writeGetModelAdapters(javaWriter);
	writeGetTypeAdpater(javaWriter);

	javaWriter.endType();
}
 

@Override
public void writeFieldReadStatement(VariableElement field,
                                    Collection<ExecutableElement> postCreateChildMethods,
                                    JavaWriter writer) throws IOException {
    DeclaredType type = (DeclaredType) field.asType();
    TypeMirror itemType = type.getTypeArguments().get(0);
    TypeMirror itemTypeErasure = processingEnv.getTypeUtils().erasure(itemType);

    String collectionInitializer;
    try {
        collectionInitializer = initializers.findCollectionInitializer(type);
    } catch (InvalidTypeException e) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage(), field);
        collectionInitializer = "null";
    }
    writer.beginControlFlow("if (bundle.containsKey(\"%s\"))", field.getSimpleName());
    writer.emitStatement("object.%s = %s", field.getSimpleName(), collectionInitializer);
    writer.emitStatement(
            "%1$s.readCollectionFromBundle(object.%2$s, bundle, %3$s.class, \"%2$s\")",
            CollectionBundler.class.getCanonicalName(),
            field.getSimpleName(),
            itemTypeErasure);

    writePostCreateChildMethodCalls(field, itemType, postCreateChildMethods, writer);
    writer.endControlFlow();
}
 

private void writeCollections(JavaWriter writer) throws IOException {
	writer.emitField(
			"List<Migration>",
			"MIGRATIONS",
			CONSTANT_MODIFIERS,
			"new ArrayList<Migration>()"
	);
	writer.emitField(
			"Map<Class<? extends Model>, ModelAdapter>",
			"MODEL_ADAPTERS",
			CONSTANT_MODIFIERS,
			"new HashMap<Class<? extends Model>, ModelAdapter>()"
	);
	writer.emitField(
			"Map<Class, TypeAdapter>",
			"TYPE_ADAPTERS",
			CONSTANT_MODIFIERS,
			"new HashMap<Class, TypeAdapter>()"
	);
	writer.emitEmptyLine();
}
 

@Override
public void writeFieldWriteStatement(VariableElement field, JavaWriter writer)
        throws IOException {
    DeclaredType type = (DeclaredType) field.asType();
    List<? extends TypeMirror> typeArguments = type.getTypeArguments();
    TypeMirror keyType = typeArguments.get(0);
    TypeMirror valueType = typeArguments.get(1);

    writer.beginControlFlow("if (object.%s != null)", field.getSimpleName());
    writer.emitStatement(
            "%1$s.writeMapToBundle(object.%2$s, bundle, %3$s.class, %4$s.class, \"%2$s\")",
            MapBundler.class.getCanonicalName(),
            field.getSimpleName(),
            keyType,
            valueType);
    writer.endControlFlow();
}
 

@Override
public void writeFieldReadStatement(VariableElement field,
                                    Collection<ExecutableElement> postCreateChildMethods,
                                    JavaWriter writer)
        throws IOException {

    writer.emitStatement("object.%s = bundle.getParcelable(\"%s\")",
                         field.getSimpleName(),
                         field.getSimpleName());

    for (ExecutableElement method : postCreateChildMethods) {
        writer.emitStatement("object.%s(object.%s)",
                             method.getSimpleName(),
                             field.getSimpleName());
    }
}
 

private void writeReadFromParcelMethod(JavaWriter writer) throws IOException {
    writer.emitAnnotation(Override.class);
    writer.beginMethod(elementCompressedName, "readFromParcel", Modifiers.PUBLIC, "Parcel",
                       "parcel");

    writer.emitStatement("%s object = new %s()", elementCompressedName, elementCompressedName);
    writer.emitStatement("Bundle bundle = parcel.readBundle()");
    writer.emitStatement("bundle.setClassLoader(%s.class.getClassLoader())",
                         elementCompressedName);
    for (VariableElement field : parceledFields) {
        getSaveStatementWriter(field).writeFieldReadStatement(field,
                                                              postCreateChildMethods,
                                                              writer);
    }
    writer.emitStatement("return object");
    writer.endMethod();
}
 

private void writeWriteToParcelMethod(JavaWriter writer) throws IOException {
    List<String> parameters = new ArrayList<>(4);
    parameters.add(elementCompressedName);
    parameters.add("object");
    parameters.add("Parcel");
    parameters.add("dest");

    writer.emitAnnotation(Override.class);
    writer.beginMethod("void", "writeToParcel", Modifiers.PUBLIC, parameters, null);
    writer.emitStatement("Bundle bundle = new Bundle()");

    for (VariableElement field : parceledFields) {
        getSaveStatementWriter(field).writeFieldWriteStatement(field, writer);
    }

    writer.emitStatement("dest.writeBundle(bundle)");
    writer.endMethod();
}
 

public void generateParceler() throws IOException {

        JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(parcelerName);
        JavaWriter writer = new JavaWriter(sourceFile.openWriter());

        writer.emitPackage(processingEnv.getElementUtils().getPackageOf(
                elementToParcel).getQualifiedName().toString());

        writer.emitImports(getImports());
        writer.emitEmptyLine();
        elementCompressedName = writer.compressType(elementToParcel.getQualifiedName().toString());
        writer.beginType(parcelerName, "class", EnumSet.of(Modifier.PUBLIC, Modifier.FINAL), null,
                         JavaWriter.type(Parceler.class, elementCompressedName));
        writer.emitEmptyLine();

        writeWriteToParcelMethod(writer);
        writer.emitEmptyLine();
        writeReadFromParcelMethod(writer);
        writer.emitEmptyLine();
        writeNewArrayMethod(writer);
        writer.emitEmptyLine();

        writer.endType();
        writer.close();
    }
 

/** Creates the function for mapping a cursor to the object after executing a sql statement */
private void emitMapCursorToObject(JavaWriter javaWriter) throws IOException {
  logger.d("emitMapCursorToObject");

  final String targetClass = getTargetClass();

  javaWriter.beginMethod("List<" + targetClass + ">", $$MAP_OBJECT_FUNCTION,
      EnumSet.of(PUBLIC, STATIC), "Cursor", "cursor", "SQLiteDatabase", "db")
      .emitStatement("List<%s> tableObjects = new LinkedList<%s>()", targetClass, targetClass)
      .beginControlFlow("if (cursor.moveToFirst())")
      .beginControlFlow("while (!cursor.isAfterLast())")
      .emitStatement("%s tableObject = %s(cursor, db)", targetClass, $$MAP_SINGLE_FUNCTION)
      .emitStatement("tableObjects.add(tableObject)")
      .emitStatement("cursor.moveToNext()")
      .endControlFlow()
      .endControlFlow()
      .emitStatement("return tableObjects")
      .endMethod();
}
 

private void writeImports(JavaWriter writer, String modelQualifiedName, Set<ColumnElement> columns)
		throws IOException {

	Set<String> imports = Sets.newHashSet(
			modelQualifiedName,
			"android.content.ContentValues",
			"android.database.Cursor",
			"android.database.sqlite.SQLiteDatabase",
			ModelAdapter.class.getName()
	);

	writer.emitImports(imports);
}
 

private void emitSelectAll(JavaWriter javaWriter) throws IOException {
  logger.d("emitSelectAll");
  javaWriter.beginMethod("Cursor", SELECT_ALL_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      "SQLiteDatabase", "db")
      .emitStatement("return db.rawQuery(\"SELECT * FROM %s\", null)", getTableName())
      .endMethod();
}
 

@Override
public void writeSource(Writer writer, TypeElement element) throws IOException {
	final String simpleName = createSimpleName(element);
	final String modelSimpleName = element.getSimpleName().toString();
	final String modelQualifiedName = element.getQualifiedName().toString();
	final String tableName = element.getAnnotation(Table.class).value();
	final Set<ColumnElement> columns = registry.getColumnElements(element);

	JavaWriter javaWriter = new JavaWriter(writer);
	javaWriter.setCompressingTypes(true);
	javaWriter.setIndent("\t");

	javaWriter.emitSingleLineComment("Generated by Ollie. Do not modify!");
	javaWriter.emitPackage("ollie");

	writeImports(javaWriter, modelQualifiedName, columns);

	javaWriter.beginType(simpleName, "class", MODIFIERS, "ModelAdapter<" + modelSimpleName + ">");

	writeGetModelType(javaWriter, modelSimpleName);
	writeGetTableName(javaWriter, tableName);
	writeGetSchema(javaWriter, tableName, columns);
	writeLoad(javaWriter, modelQualifiedName, columns);
	writeSave(javaWriter, modelQualifiedName, columns);
	writeDelete(javaWriter, modelQualifiedName, tableName);

	javaWriter.endType();
}
 

private void writeStaticInitializations(JavaWriter writer) throws IOException {
	writer.beginInitializer(true);

	List<MigrationElement> migrations = Lists.newArrayList(registry.getMigrationElements());
	if (!migrations.isEmpty()) {
		Collections.sort(migrations);
		for (MigrationElement migration : migrations) {
			writer.emitStatement("MIGRATIONS.add(new %s())",
					migration.getQualifiedName());
		}
		writer.emitEmptyLine();
	}

	List<ModelAdapterElement> modelAdapters = Lists.newArrayList(registry.getModelAdapterElements());
	if (!modelAdapters.isEmpty()) {
		Collections.sort(modelAdapters);
		for (ModelAdapterElement modelAdapter : modelAdapters) {
			writer.emitStatement("MODEL_ADAPTERS.put(%s.class, new %s())",
					modelAdapter.getModelQualifiedName(),
					modelAdapter.getQualifiedName());
		}
		writer.emitEmptyLine();
	}

	List<TypeAdapterElement> typeAdapters = Lists.newArrayList(registry.getTypeAdapterElements());
	if (!typeAdapters.isEmpty()) {
		Collections.sort(typeAdapters);
		for (TypeAdapterElement typeAdapter : typeAdapters) {
			writer.emitStatement("TYPE_ADAPTERS.put(%s.class, new %s())",
					typeAdapter.getDeserializedQualifiedName(),
					typeAdapter.getQualifiedName());
		}
	}

	writer.endInitializer();
	writer.emitEmptyLine();
}
 

/** Creates function for getting an object by value */
private void emitSelectById(JavaWriter javaWriter) throws IOException {
  logger.d("emitSelectById");
  javaWriter.beginMethod(getTargetClass(), $$GET_OBJECT_BY_ID, EnumSet.of(PUBLIC, STATIC), "long",
      "id", "SQLiteDatabase", "db")
      .emitStatement("Cursor cursor = db.rawQuery(\"SELECT * FROM %s WHERE %s  = id\", null)",
          getTableName(), idColumn.getColumnName())
      .emitStatement("%s value = %s(cursor, db).get(0)", getTargetClass(), $$MAP_OBJECT_FUNCTION)
      .emitStatement("cursor.close()")
      .emitStatement("return value")
      .endMethod();
}
 

private void writePostCreateChildMethodCalls(VariableElement field,
                                             TypeMirror itemType,
                                             Collection<ExecutableElement>
                                                     postCreateChildMethods,
                                             JavaWriter writer) throws IOException {

    if (!postCreateChildMethods.isEmpty() && metaTypes.isSubtype(itemType, Names.PARCELABLE)) {
        writer.beginControlFlow("for (Object child : object.%s)", field.getSimpleName());
        for (ExecutableElement method : postCreateChildMethods) {
            writer.emitStatement("object.%s(child)", method.getSimpleName());
        }
        writer.endControlFlow();
    }
}
 

/** Creates the function for deleting an object from the table */
private void emitDeleteWithObject(JavaWriter javaWriter) throws IOException {
  logger.d("emitDeleteWithObject");
  javaWriter.beginMethod("void", $$DELETE_OBJECT_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      getTargetClass(), "element", "SQLiteDatabase", "db")
      .emitStatement("%s(element.%s, db)", $$DELETE_OBJECT_FUNCTION, idColumn.getMemberName())
      .endMethod();
}
 

/** Updates the id of the object to the last insert */
private void emitUpdateColumnId(JavaWriter javaWriter) throws IOException {
  logger.d("emitUpdateColumnId");
  // Updates the column id for the last inserted row
  javaWriter.beginMethod("void", $$UPDATE_ID_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      getTargetClass(), "element", "SQLiteDatabase", "db")
      .emitStatement("long id = DatabaseUtils.longForQuery(db, \"%s\", null)",
          String.format(GET_ID_OF_LAST_INSERTED_ROW_SQL, getTableName()))
      .emitStatement("element.%s = id", idColumn.getMemberName())
      .endMethod();
}
 

private void emitParentInsert(JavaWriter javaWriter) throws IOException {
  javaWriter.beginMethod("void", PARENT_INSERT_FUNCTION, EnumSet.of(PUBLIC, STATIC), "long",
      "parentId", String.format("List<%s>", getTargetClass()), "children", "SQLiteDatabase", "db")
      .beginControlFlow("for(%s child : children)", getTargetClass())
      .emitStatement("ContentValues values = new ContentValues()");
  for (TableColumn column : columns) {
    String columnName = column.getColumnName();
    String columnMember = column.getMemberName();
    if (column.getSqlType() == SqliteType.BLOB && !column.isByteArray()) {
      javaWriter.emitStatement("values.put(\"%s\", %s(child.%s))", columnName, SERIALIZE_FUNCTION,
          columnMember);
    } else if (column.isOneToOne()) {
      javaWriter.emitStatement("values.put(\"%s\", %s%s.%s(child.%s))", columnName,
          column.getType(), $$SUFFIX, GET_ID_FUNCTION, columnMember);
    } else if (column.isDate()) {
      javaWriter.emitStatement("values.put(\"%s\", child.%s.getTime())", columnName,
          columnMember);
    } else if (column.getSqlType() == SqliteType.ONE_TO_MANY) {
      javaWriter.emitStatement("%s.%s.%s(%s)", column.getType(), $$SUFFIX, PARENT_INSERT_FUNCTION,
          columnName);
    } else if (column.getSqlType() == SqliteType.ONE_TO_MANY_CHILD) {
      javaWriter.emitStatement("values.put(\"%s\", %s)", columnName, "parentId");
    } else {
      javaWriter.emitStatement("values.put(\"%s\", child.%s)", columnName, columnMember);
    }
  }
  javaWriter.emitStatement("db.insert(\"%s\", null, values)", getTableName())
      .emitStatement("long id = DatabaseUtils.longForQuery(db, \"SELECT ROWID FROM %s "
          + "ORDER BY ROWID DESC LIMIT 1\", null)", getTableName())
      .emitStatement("child.%s = id", idColumn.getMemberName())
      .endControlFlow()
      .endMethod();
}
 

/** Creates the function for deleting an object by id */
private void emitDeleteWithId(JavaWriter javaWriter) throws IOException {
  logger.d("emitDeleteWithId");
  javaWriter.beginMethod("void", $$DELETE_OBJECT_FUNCTION, EnumSet.of(PUBLIC, STATIC), "Long",
      "id", "SQLiteDatabase", "db")
      .emitStatement("db.delete(\"%s\", \"%s = \" + id, null)", getTableName(),
          idColumn.getColumnName())
      .endMethod();
}
 

private void writeImports(JavaWriter writer) throws IOException {
	Set<String> imports = Sets.newHashSet(
			ArrayList.class.getName(),
			HashMap.class.getName(),
			List.class.getName(),
			Map.class.getName(),
			AdapterHolder.class.getName(),
			ModelAdapter.class.getName()
	);

	writer.emitImports(imports);
	writer.emitEmptyLine();
}
 

private void writeSave(JavaWriter writer, String modelQualifiedName, Set<ColumnElement> columns) throws
		IOException {

	writer.beginMethod("Long", "save", MODIFIERS, modelQualifiedName, "entity", "SQLiteDatabase", "db");
	writer.emitStatement("ContentValues values = new ContentValues()");

	for (ColumnElement column : columns) {
		final StringBuilder value = new StringBuilder();
		int closeParens = 0;

		if (!column.isModel() && column.requiresTypeAdapter()) {
			closeParens++;
			value.append("(").append(column.getSerializedQualifiedName())
					.append(") Ollie.getTypeAdapter(")
					.append(column.getDeserializedQualifiedName())
					.append(".class).serialize(");
		}

		value.append("entity.").append(column.getFieldName());

		if (column.isModel()) {
			value.append(" != null ? ");
			value.append("entity.").append(column.getFieldName()).append(".id");
			value.append(" : null");
		}

		for (int i = 0; i < closeParens; i++) {
			value.append(")");
		}

		writer.emitStatement("values.put(\"" + column.getColumnName() + "\", " + value.toString() + ")");
	}

	writer.emitStatement("return insertOrUpdate(entity, db, values)");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void writeDelete(JavaWriter writer, String modelQualifiedName, String tableName) throws IOException {
	writer.beginMethod("void", "delete", MODIFIERS, modelQualifiedName, "entity", "SQLiteDatabase", "db");
	writer.emitStatement("db.delete(\"" + tableName + "\", \"" + Model._ID
			+ "=?\", new String[]{entity.id.toString()})");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void emitOneToOneInsert(JavaWriter javaWriter) throws IOException {
  logger.d("emitOneToOneInsert");
  javaWriter.beginMethod("void", INSERT_ONE_TO_ONE, EnumSet.of(PUBLIC, STATIC), getTargetClass(),
      "element", "SQLiteDatabase", "db")
      .emitStatement("%s(element, db)", $$INSERT_OBJECT_FUNCTION)
      .emitStatement("long id = DatabaseUtils.longForQuery(db, \"%s\", null)",
          String.format(GET_ID_OF_LAST_INSERTED_ROW_SQL, getTableName()))
      .emitStatement("element.%s = id", idColumn.getMemberName())
      .endMethod();
}
 

/** Creates the function for updating an object */
private void emitUpdate(JavaWriter javaWriter) throws IOException {
  logger.d("emitUpdate");
  javaWriter.beginMethod("void", $$UPDATE_OBJECT_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      getTargetClass(), "element", "SQLiteDatabase", "db")
      .emitStatement("ContentValues values = new ContentValues()");

  for (TableColumn column : columns) {
    String columnName = column.getColumnName();
    String memberName = column.getMemberName();
    if (column.getSqlType() == SqliteType.BLOB && !column.isByteArray()) {
      javaWriter.emitStatement("values.put(\"%s\", %s(element.%s))", columnName,
          SERIALIZE_FUNCTION, memberName);
    } else if (column.isOneToOne()) {
      javaWriter.emitStatement("values.put(\"%s\", %s%s.%s(element.%s))", columnName,
          column.getType(), $$SUFFIX, GET_ID_FUNCTION, memberName);
    } else if (column.isDate()) {
      javaWriter.emitStatement("values.put(\"%s\", element.%s.getTime())", columnName,
          memberName);
    } else if (column.isOneToMany()) {
      javaWriter.beginControlFlow("for (%s child : element.%s)",
          column.getType().replace("$", "."), column.getColumnName())
          .emitStatement("%s%s.%s(child, db)", column.getType(), $$SUFFIX,
              $$UPDATE_OBJECT_FUNCTION)
          .endControlFlow();
    } else if (column.isOneToManyChild()) {
      // TODO: actually no way of actually updating this value directly add a wrapper?
    } else {
      javaWriter.emitStatement("values.put(\"%s\", element.%s)", columnName, memberName);
    }
  }
  javaWriter.emitStatement("db.update(\"%s\", values, \"%s = \" + element.%s, null)",
      getTableName(), idColumn.getColumnName(), idColumn.getMemberName());
  javaWriter.endMethod();
}
 

private void writeGetModelAdapter(JavaWriter writer) throws IOException {
	writer.beginMethod("<T extends Model> ModelAdapter<T>", "getModelAdapter", METHOD_MODIFIERS,
			"Class<? extends Model>", "cls");
	writer.emitStatement("return MODEL_ADAPTERS.get(cls)");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

/** Creates the function dropping the table */
private void emitDropTable(JavaWriter javaWriter) throws IOException {
  logger.d("emitDropTable");
  javaWriter.beginMethod("void", $$DROP_TABLE_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      "SQLiteDatabase", "db")
      .emitStatement("db.execSQL(\"DROP TABLE IF EXISTS %s\")", getTableName())
      .endMethod();
}
 

/** Create the java functions required for the internal class */
void brewJava(Writer writer) throws IOException {
  logger.d("brewJava");
  JavaWriter javaWriter = new JavaWriter(writer);
  javaWriter.setCompressingTypes(false);

  javaWriter.emitSingleLineComment("Generated code from Shillelagh. Do not modify!") //
      .emitPackage(classPackage) //
      /* Knows nothing of android types, must use strings. */ //
      .emitImports("android.content.ContentValues", "android.database.Cursor", //
          "android.database.DatabaseUtils", "android.database.sqlite.SQLiteDatabase") //
      .emitImports(ShillelaghUtil.class, ByteArrayInputStream.class, ByteArrayOutputStream.class,
          IOException.class, ObjectInputStream.class, ObjectOutputStream.class, LinkedList.class,
          Date.class, List.class) //
      .beginType(className, "class", EnumSet.of(PUBLIC, FINAL));

  if (this.isChildTable) {
    emitParentInsert(javaWriter);
    emitSelectAll(javaWriter);
  }
  emitInsert(javaWriter);
  emitOneToOneInsert(javaWriter);
  emitGetId(javaWriter);
  emitCreateTable(javaWriter);
  emitDropTable(javaWriter);
  emitUpdate(javaWriter);
  emitUpdateColumnId(javaWriter);
  emitDeleteWithId(javaWriter);
  emitDeleteWithObject(javaWriter);
  emitMapCursorToObject(javaWriter);
  emitSingleMap(javaWriter);
  emitSelectById(javaWriter);
  javaWriter.endType();
}
 

public static JavaWriter getJavaWriter( String javaOut, String classPackage, String className ) throws IOException
{
	String directory = javaOut + "/" + classPackage.replace( ".", "/" );
	boolean created = new File( directory ).mkdirs();
	if ( created )
	{
		System.out.println( "Created output directory " + directory );
	}

	String fileName = directory + "/" + className + ".java";
	System.out.println( "Writing generated code to " + fileName );
	return new JavaWriter( new OutputStreamWriter( new FileOutputStream( fileName ), UTF_8 ) );
}
 

private void emitClassHeader(PackageElement packageElement, TypeElement activityType, JavaWriter writer) throws IOException {
    writer.emitPackage(packageElement.getQualifiedName().toString());

    if (isFragmentActivity(activityType)) {
        writer.emitImports("android.support.v4.app.Fragment");
    } else {
        writer.emitImports("android.app.Fragment");
    }
    writer.emitImports("android.app.Activity");
    writer.emitEmptyLine();
}