douglasthrift/anttasks/AAPTPackage.java

// AAPT Package Ant Task
//
// Douglas Thrift
//
// $Id$

/*  Copyright 2008 Douglas Thrift
 *
 *  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 net.douglasthrift.anttasks;

import java.io.File;

import java.util.ArrayList;
import java.util.Iterator;

import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.UpToDate;
import org.apache.tools.ant.types.DirSet;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.resources.FileResource;
import org.apache.tools.ant.types.resources.Union;

public class AAPTPackage extends CommandTask
{
        private boolean force_;
        private boolean update_;
        private boolean make_;
        private boolean verbose_;
        private boolean extending_;
        private File manifest_;
        private Path include_;
        private File assets_;
        private File publicDefinitions_;
        private Path resource_;
        private File file_;
        private File java_;
        private ArrayList<DirSet> dirSets_ = new ArrayList<DirSet>();

        public void setForce(boolean force)
        {
                force_ = force;
        }

        public void setUpdate(boolean update)
        {
                update_ = update;
        }

        public void setMake(boolean make)
        {
                make_ = make;
        }

        public void setVerbose(boolean verbose)
        {
                verbose_ = verbose;
        }

        public void setExtending(boolean extending)
        {
                extending_ = extending;
        }

        public void setManifest(File manifest)
        {
                manifest_ = manifest;
        }

        public void setInclude(Path include)
        {
                include_ = include;
        }

        public void setAssets(File assets)
        {
                assets_ = assets;
        }

        public void setPublicDefinitions(File publicDefinitions)
        {
                publicDefinitions_ = publicDefinitions;
        }

        public void setResource(Path resource)
        {
                resource_ = resource;
        }

        public void setFile(File file)
        {
                file_ = file;
        }

        public void setJava(File java)
        {
                java_ = java;
        }

        public void add(DirSet dirSet)
        {
                dirSets_.add(dirSet);
        }

        @Override
        public void execute()
        {
                if (isUpToDate())
                        return;

                command("aapt");
                argument("package");

                if (force_)
                        argument("-f");

                if (update_)
                        argument("-u");

                if (make_)
                        argument("-m");

                if (verbose_)
                        argument("-v");

                if (extending_)
                        argument("-x");

                if (manifest_ != null)
                        arguments("-M", manifest_);

                if (include_ != null)
                        for (Iterator iterator = include_.iterator(); iterator.hasNext();)
                                arguments("-I", iterator.next().toString());

                if (assets_ != null && assets_.exists())
                        arguments("-A", assets_);

                if (publicDefinitions_ != null)
                        arguments("-P", publicDefinitions_);

                if (resource_ != null)
                        for (String resource : resource_.list())
                                arguments("-S", resource);

                if (file_ != null)
                        arguments("-F", file_);

                if (java_ != null)
                        arguments("-J", java_);

                for (DirSet dirSet : dirSets_)
                        for (Iterator iterator = dirSet.iterator(); iterator.hasNext();)
                                argument(iterator.next().toString());

                super.execute();
        }

        private boolean isUpToDate()
        {
                Project project = getProject();
                UpToDate upToDate = (UpToDate)project.createTask("uptodate");
                Union union = upToDate.createSrcResources();

                if (manifest_ != null)
                {
                        FileSet fileSet = (FileSet)project.createDataType("fileset");

                        fileSet.setFile(manifest_);
                        union.add(fileSet);
                }

                if (assets_ != null && assets_.exists())
                {
                        FileSet fileSet = (FileSet)project.createDataType("fileset");

                        fileSet.setDir(assets_);
                        union.add(fileSet);
                }

                if (resource_ != null)
                        union.add(resource_);

                union.addAll(dirSets_);

                // TODO: publicDefinitions_

                if (file_ != null)
                {
                        upToDate.setTargetFile(file_);

                        if (!upToDate.eval())
                                return false;
                }

                if (java_ != null)
                {
                        FileSet fileSet = (FileSet)project.createDataType("fileset");

                        fileSet.setDir(java_);
                        fileSet.setIncludes("**/R.java");

                        if (fileSet.size() == 0)
                                return false;

                        for (Iterator iterator = fileSet.iterator(); iterator.hasNext();)
                        {
                                upToDate.setTargetFile(((FileResource)iterator.next()).getFile());

                                if (!upToDate.eval())
                                        return false;
                        }
                }

                return upToDate.eval();
        }
}
Revision:	1183
Committed:	2009-05-23T22:43:47-07:00 (16 years ago) by douglas
File size:	4555 byte(s)
Log Message:	Multiple resource directories.
#	Content
1	// AAPT Package Ant Task
2	//
3	// Douglas Thrift
4	//
5	// $Id$
6
7	/* Copyright 2008 Douglas Thrift
8	*
9	* Licensed under the Apache License, Version 2.0 (the "License");
10	* you may not use this file except in compliance with the License.
11	* You may obtain a copy of the License at
12	*
13	* http://www.apache.org/licenses/LICENSE-2.0
14	*
15	* Unless required by applicable law or agreed to in writing, software
16	* distributed under the License is distributed on an "AS IS" BASIS,
17	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18	* See the License for the specific language governing permissions and
19	* limitations under the License.
20	*/
21
22	package net.douglasthrift.anttasks;
23
24	import java.io.File;
25
26	import java.util.ArrayList;
27	import java.util.Iterator;
28
29	import org.apache.tools.ant.Project;
30	import org.apache.tools.ant.taskdefs.UpToDate;
31	import org.apache.tools.ant.types.DirSet;
32	import org.apache.tools.ant.types.FileSet;
33	import org.apache.tools.ant.types.Path;
34	import org.apache.tools.ant.types.resources.FileResource;
35	import org.apache.tools.ant.types.resources.Union;
36
37	public class AAPTPackage extends CommandTask
38	{
39	private boolean force_;
40	private boolean update_;
41	private boolean make_;
42	private boolean verbose_;
43	private boolean extending_;
44	private File manifest_;
45	private Path include_;
46	private File assets_;
47	private File publicDefinitions_;
48	private Path resource_;
49	private File file_;
50	private File java_;
51	private ArrayList<DirSet> dirSets_ = new ArrayList<DirSet>();
52
53	public void setForce(boolean force)
54	{
55	force_ = force;
56	}
57
58	public void setUpdate(boolean update)
59	{
60	update_ = update;
61	}
62
63	public void setMake(boolean make)
64	{
65	make_ = make;
66	}
67
68	public void setVerbose(boolean verbose)
69	{
70	verbose_ = verbose;
71	}
72
73	public void setExtending(boolean extending)
74	{
75	extending_ = extending;
76	}
77
78	public void setManifest(File manifest)
79	{
80	manifest_ = manifest;
81	}
82
83	public void setInclude(Path include)
84	{
85	include_ = include;
86	}
87
88	public void setAssets(File assets)
89	{
90	assets_ = assets;
91	}
92
93	public void setPublicDefinitions(File publicDefinitions)
94	{
95	publicDefinitions_ = publicDefinitions;
96	}
97
98	public void setResource(Path resource)
99	{
100	resource_ = resource;
101	}
102
103	public void setFile(File file)
104	{
105	file_ = file;
106	}
107
108	public void setJava(File java)
109	{
110	java_ = java;
111	}
112
113	public void add(DirSet dirSet)
114	{
115	dirSets_.add(dirSet);
116	}
117
118	@Override
119	public void execute()
120	{
121	if (isUpToDate())
122	return;
123
124	command("aapt");
125	argument("package");
126
127	if (force_)
128	argument("-f");
129
130	if (update_)
131	argument("-u");
132
133	if (make_)
134	argument("-m");
135
136	if (verbose_)
137	argument("-v");
138
139	if (extending_)
140	argument("-x");
141
142	if (manifest_ != null)
143	arguments("-M", manifest_);
144
145	if (include_ != null)
146	for (Iterator iterator = include_.iterator(); iterator.hasNext();)
147	arguments("-I", iterator.next().toString());
148
149	if (assets_ != null && assets_.exists())
150	arguments("-A", assets_);
151
152	if (publicDefinitions_ != null)
153	arguments("-P", publicDefinitions_);
154
155	if (resource_ != null)
156	for (String resource : resource_.list())
157	arguments("-S", resource);
158
159	if (file_ != null)
160	arguments("-F", file_);
161
162	if (java_ != null)
163	arguments("-J", java_);
164
165	for (DirSet dirSet : dirSets_)
166	for (Iterator iterator = dirSet.iterator(); iterator.hasNext();)
167	argument(iterator.next().toString());
168
169	super.execute();
170	}
171
172	private boolean isUpToDate()
173	{
174	Project project = getProject();
175	UpToDate upToDate = (UpToDate)project.createTask("uptodate");
176	Union union = upToDate.createSrcResources();
177
178	if (manifest_ != null)
179	{
180	FileSet fileSet = (FileSet)project.createDataType("fileset");
181
182	fileSet.setFile(manifest_);
183	union.add(fileSet);
184	}
185
186	if (assets_ != null && assets_.exists())
187	{
188	FileSet fileSet = (FileSet)project.createDataType("fileset");
189
190	fileSet.setDir(assets_);
191	union.add(fileSet);
192	}
193
194	if (resource_ != null)
195	union.add(resource_);
196
197	union.addAll(dirSets_);
198
199	// TODO: publicDefinitions_
200
201	if (file_ != null)
202	{
203	upToDate.setTargetFile(file_);
204
205	if (!upToDate.eval())
206	return false;
207	}
208
209	if (java_ != null)
210	{
211	FileSet fileSet = (FileSet)project.createDataType("fileset");
212
213	fileSet.setDir(java_);
214	fileSet.setIncludes("**/R.java");
215
216	if (fileSet.size() == 0)
217	return false;
218
219	for (Iterator iterator = fileSet.iterator(); iterator.hasNext();)
220	{
221	upToDate.setTargetFile(((FileResource)iterator.next()).getFile());
222
223	if (!upToDate.eval())
224	return false;
225	}
226	}
227
228	return upToDate.eval();
229	}
230	}