/*! \page mod_dev_page Java Development Setup

<!-- NOTE: This doc contains the concepts that apply when developing
any type of module. Information about specific types of modules should
go into the page for that module type. -->

This page describes the basic concepts and setup that are needed for all types of Java modules. It is not needed for Python module development. 

\section mod_dev_setup Basic Setup

\subsection mod_dev_setup_nb NetBeans and Java 

Autopsy is built on top of the NetBeans Rich Client Platform, which makes it easy to make plug-in infrastructures. To do any development, you really need to download NetBeans first. You can in theory develop modules by command line only, but this document assumes that you are using the IDE. Download and install the latest version of the IDE from http://www.netbeans.org. 

Autopsy currently requires Java 1.8.  Ensure that it is installed.

\subsection mod_dev_setup_platform Obtain the Autopsy Platform

Before we can make a module, we must configure NetBeans to know about Autopsy as a platform. This will allow you to access all of the classes and services that Autopsy provides.  There are two ways of configuring the NetBeans IDE to know about Autopsy:

- Download an official release of Autopsy and build against it.  
- Download Autopsy source code, build it, and make a platform to build against. 

\subsubsection mod_dev_setup_platform_rel Using a Released Version

The easiest method for obtaining the platform is to install Autopsy on your computer.  It will have everything that you need. If you installed it in "C:\Program Files\Autopsy", then the platform is in "C:\Program Files\Autopsy\platform".  You can now also download just the ZIP file of the Autopsy release instead of the MSI installer. This maybe more convenient for development situations. 

\subsubsection mod_dev_setup_platform_src Building a Platform from Code

If you want to build against the bleeding edge code and updates that have occurred since the last release, then you must download the latest source code and build it.  This involves getting a full development environment setup. Refer to the wiki page at http://wiki.sleuthkit.org/index.php?title=Autopsy_Developer%27s_Guide for details on getting the source code and a development environment setup.

To use the latest Autopsy source code as your development environment, first follow BUILDING.TXT in the root source repository to properly build and setup Autopsy in NetBeans. 

Once Autopsy has been successfully built, right click on the Autopsy project in NetBeans and select Package as > ZIP Distribution.  Once the ZIP file is created, extract its contents to a directory.  This directory is the platform that you will build against. Note that you will building the module against this built platform.  If you need to make changes to Autopsy infrastructure for your module, then you will need to then make a new ZIP file and configure your module to use it each time. 


\section mod_dev_module Creating a Basic NetBeans Module

The Autopsy modules are encapsulated inside of NetBeans modules. A NetBeans module will be packaged as a single ".nbm" file.  A single NetBeans module can contain many Autopsy modules.  The NetBeans module is what the user will install and provides things like auto-update. 

\subsection mod_dev_mod_nb Creating a NetBeans Module

If this is your first module, then  you will need to make a NetBeans module. If you have already made an Autopsy module and are now working on a second one, you can consider adding it to your previous NetBeans module. 

To make a NetBeans module:
- Open the NetBeans IDE and go to File -> New Project.
- From the list of categories on the left, choose "Java with Ant" and then "NetBeans Modules". Next select "Module" from the list of projects on the right and click Next. 
- In the next panel of the wizard, give the module a name and directory. Select Standalone Module (the default is typically "Add to Suite") so that you build the module as an external module against Autopsy.  You will need to tell NetBeans about the Autopsy platform, so choose the "Manage" button.  Choose the "Add Platform" button and browse to the location of the platform discussed in the previous sections (as a reminder this will either be the location that you installed Autopsy into or where you opened up the ZIP file you created from source).  Click Next.
- Finally, enter the code base name.  We use the same naming convention as used for naming packages (http://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html).  Press Finish. 

\subsubsection mod_dev_mod_nb_config Configuring the NetBeans Module

After the module is created, you will need to do some further configuration. 
<ul>
<li>Right click on the newly created module and choose "Properties".
<li>Verify that the Netbeans Platform is set to the Autopsy Platform.
<li>You will need to configure the module to be dependent on modules from within the Autopsy platform. Go to the "Libraries" area and choose "Add" in the "Module Dependencies" section.  Choose the:
<ul>
<li>"Autopsy-Core" library to get access to the Autopsy services.
<li>NetBeans "Lookup API" library so that your module can be discovered by Autopsy. 
</ul>
\image html projectProperties.png
<li>If you later determine that you need to pull in external JAR files, then you will use the "Wrapped Jar" section to add them in.  
<li>Note, you will also need to come back to this section if you update the platform.  You may need to add a new dependency for the version of the Autopsy-Core that comes with the updated platform. 
<li>Autopsy requires that all modules restart Autopsy after they are installed. Configure your module this way under Build -> Packaging.  Check the box that says Needs Restart on Install.
</ul>
You now have a NetBeans module that is using Autopsy as its build platform.  That means you will have access to all of the services and utilities that Autopsy provides. 


\subsubsection mod_dev_mod_config_other Optional Settings
There are several optional things in the Properties section.  You can add a description and specify the version.  You can do all of this later though and it does not need to be done before you start development. 

A link about the NetBeans versioning scheme can be found here http://wiki.netbeans.org/VersioningPolicy. 
Autopsy follows this scheme and a link to the details can be found at http://wiki.sleuthkit.org/index.php?title=Autopsy_3_Module_Versions.

\subsection mod_dev_mod_other Other Links

For general NetBeans module information, refer to <a href="http://bits.netbeans.org/dev/javadoc/org-openide-modules/org/openide/modules/doc-files/api.html">this guide from NetBeans.org</a>.


\section mod_dev_aut Creating Autopsy Modules

You can now add Autopsy modules into the NetBeans container module.  There are other pages that focus on that and are listed on the main page.  The rest of this document contains info that you will eventually want to come back to though. 
As you will read in the later sections about the different module types, each Autopsy Module is a Java class that extends an interface (the interface depends on the type of module). 


\subsection mod_dev_aut_run1 Running Your Module During Development

When you are developing your Autopsy module, you can simply choose "Run" on the module and it will launch the Autopsy platform with the module enabled in it.  This is also how you can debug the module. If you want to apply changes during debugging and have not changed any method signatures, you can use the "Apply Code Changes" function in NetBeans.

\subsection mod_dev_aut_deploy Deploying Your Module

When you are ready to share your module, create an NBM file by right clicking on the module and selecting "Create NBM".

\subsection mod_dev_aut_install Installing Your Module

To install the module on a non-development environment, launch Autopsy and choose Plugins under the Tools menu. Open the Downloaded tab and click Add Plugins. Navigate to the NBM file and open it. Next, click Install and follow the wizard. 


*/