## Tuesday, August 30, 2016

### Identifying deprecated classes and methods in Android Studio with "Recompile with -Xlink:deprecation"

When upgrading an Android project to a newer Android version, Google may deprecate some of the previously used Android classes and methods. By default, the gradle compilation process will only print out a summary message "Some input files use or override a deprecated API", as shown in the Android Studio screenshot below:

To enable the compilation process to print out a verbose message of the deprecated API, one or more of the build.gradle file may need to be edited to add in the -Xlint:deprecation option. In the example, the top most or project level build.gradle file was edited.

1. In Android Studio, open up the project build.gradle file. Scroll to the allprojects section.

2. Add in the gradle.projectsEvaluated sub section with the -Xlint:deprecation option as shown below.

3. Save. Now when building the Android project, the deprecated API will be printed in the console.

## Monday, August 22, 2016

### WebApp for viewing City of Tulsa, Oklahoma's Fire Department's dispatches

Users can make use of this WebApp to monitor the City of Tulsa, Oklahoma's Fire Department fire dispatch data (updated every minute) on a Google Maps backdrop. The incidents are shown as clickable icons with tool tips on Google Maps. Clicking an icon will bring up more details about the incident.

Users can utilise additional built-in Google Maps features such as Street View to immerse themselves into the environment of the incident.

The pane on the right can display a list of the fire incidents. The list can be sorted by category, date-time and address - either in ascending or descending order. Clicking the Maps hyperlink will automatically locate, zoom and center the incident in the Map View.

The WebApp can be launched from this link https://dominoc925-pages.appspot.com/webapp/tulsa911mon/.

## Monday, August 15, 2016

### Use CMake to develop an SQLite Visual Studio C++ application

I wanted to write a Windows 64 bit C++ executable that makes use of a SQLite database using CMake to generate a Visual Studio solution.

Prepare SQLite

1. The simplest way to use SQLite in my code is to download and use the amalgamated source files and binaries from the SQLite website https://www.sqlite.org/download.html.
2. Extract the amalgamated SQLite source files into a folder e.g. c:\path\to\sqlite\include\.

3. Extract the compiled SQLite binaries into a folder e.g. c:\path\to\sqlite\lib\.

4. In order to link the SQLite dll into a C++ executable, the dll needs to have a exported library. This can be done by opening a Visual Studio Command Prompt. Select Start | Visual Studio 2015 | VS2015 x64 Native Tools Command Prompt.
5. In the Command Prompt, change directory to the location of the SQLite binaries e.g. C:\path\to\sqlite\lib\. Type in the LIB command:

C:\> LIB /def:sqlite3.def

The files sqlite3.lib and sqlite3.exp are generated.

1. In your C++ application's root folder e.g. C:\path\to\sqliteexample\, use a text editor to create a CMakeLists.txt file.

2. In the CMakeLists.txt, define the SQLite library name and locations of the headers and library, as shown below.
An example CMakeLists.txt

cmake_minimum_required(VERSION 2.8.6)
project(sqliteexample)

# compile all *.cpp files
file (GLOB SOURCES "src/*.cpp")

# define libraries to link to final executable

# define the sqlite header include file directory
set (SQLITE_INCLUDE ../sqlite/include)

# define the sqlite link library directory

# define the directories to search for libraries
link_directories ( ${SQLITE_LINK_DIR}) # define the directories to search for headers include_directories (include${SQLITE_INCLUDE})

# define the final executable
add_executable(sqliteexample ${SOURCES}) # define the libraries to link to the final executable target_link_libraries (sqliteexample${PROJECT_LINK_LIBS})


Generate the Visual Studio solution files

1. Write the C++ source code e.g. main.cpp in the C++ application source folder e.g. C:\path\to\sqliteexample\src\.
2. Create a build folder underneath the C++ application root folder e.g. C:\path\to\sqliteexample\.
3. Open up the Visual Studio x64 Command Prompt. Change directory to the build folder, e.g. C:\path\to\sqliteexample\build\.
4. In the Command Prompt, type in the cmake command:

C:\> cmake -G "Visual Studio 14 2015 Win64" ..

The Visual Studio solution files are generated.

5. Next, open up the generated Visual Studio solution e.g. sqliteexample.sln in Visual Studio.
6. Select Build | Build Solution to compile your SQLite C++ application.

## Monday, August 8, 2016

### Use CMake to help build and use a Windows dll

I wanted to use Windows c++ classes and use them in another c++ applications through shared Windows DLLs, while using CMake to generate build files and Visual Studio to compile into final executables. I spent some time figuring out how to do it and the following steps illustrate a simple example.

Create a Windows DLL
The first step is to create a Windows DLL and export the functions that will be called by other methods.

Listing of Animal.h
 1 2 3 4 5 6 7 8 9 10 11 #include using namespace std; class Animal { private: string name; public: Animal(string); virtual void print_name(); }; 

Listing of Animal.cpp
 1 2 3 4 5 6 7 8 9 10 #include #include "Animal.h" using namespace std; Animal::Animal(string name):name (name){} void Animal::print_name(){ cout << "Name is " << this->name << endl; } 

The Animal.h and Animal.cpp files are placed in the include and src folders under the [example root folder]\animallib_shared\ folder, as shown below.

The next thing to do is to create the CMakeLists.txt in the Windows DLL project e.g. [example root folder]\animallib_shared\ folder.
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 cmake_minimum_required(VERSION 2.8.6) project (animallib) set (CMAKE_BUILD_TYPE Debug) #include *.h files under include folder and #the project's output folder e.g. Debug include_directories (include ${PROJECT_BINARY_DIR}) #compile all *.cpp source files under src folder file (GLOB SOURCES "src/*.cpp") #output library as animallib.* #output library export file *.lib and #output macro definitions include file include (GenerateExportHeader) add_library(animallib SHARED${SOURCES}) GENERATE_EXPORT_HEADER (animallib BASE_NAME animallib EXPORT_MACRO_NAME animallib_EXPORT EXPORT_FILE_NAME animallib_Export.h STATIC_DEFINE animallib_BUILT_AS_STATIC ) 

Next, we have to modify the header (*.h) and source code (*.cpp) files to add in the Windows export macro animallib_EXPORT and cmake generated header file animallib_Export.h.
Listing of modified animal.h
 1 2 3 4 5 6 7 8 9 10 11 12 13 #include #include "animallib_Export.h" using namespace std; class Animal { private: string name; public: animallib_EXPORT Animal(string); virtual animallib_EXPORT void print_name(); }; 
Listing of modified Animal.cpp

 1 2 3 4 5 6 7 8 9 10 11 12 #include #include "Animal.h" #include "animallib_Export.h" using namespace std; animallib_EXPORT Animal::Animal(string name):name (name){} animallib_EXPORT void Animal::print_name(){ cout << "Name is " << this->name << endl; } 

Open up a Windows Command prompt and change directory to the build folder of the Windows DLL project e.g. [example root folder]\animallib_shared\build\ folder.

Type in the cmake command (assuming cmake is in the PATH environment variable):
C:> cd \path\to\example\animallib_shared\build
C:> cmake ..
 Build files are generated
 The generated build files
Open up the generated Visual Studio solution file [example root folder]\animallib_shared\build\animallib.sln in Visual Studio. Then select Build | Build Solution to compile the Windows DLL.
 Compilation messages
 The generated *.dll and export library *.lib files under [example root folder]\animallib_shared\build\Debug\
Using the Windows DLL in a separate C++ application
Now that the Windows DLL has been generated and the functions exported, the next thing is to use the DLL's classes and functions in an application e.g. UseAnimalLib project under [example root folder]\useanimallib\]

Listing of uselib.cpp

 1 2 3 4 5 6 7 8 9 10 11 12 #include "Animal.h" #include "animallib_Export.h" int main(int argc, char *argv[]){ //Create a new animal instance with name Dog Animal animal("Dog"); //try to call the class's print_name method animal.print_name(); return (0); } 

Then create a CMakeLists.txt file under the [example root folder]\useanimallib\ folder.

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 cmake_minimum_required(VERSION 2.8.6) project (UseAnimalLib) set (EXAMPLE_DIR d:/path/to/example/root/folder) set (PROJECT_LINK_LIBS animallib.dll) link_directories (${EXAMPLE_DIR}/animallib_shared/build/Debug) include_directories (${EXAMPLE_DIR}/animallib_shared/include ${EXAMPLE_DIR}/animallib_shared/build) #compile all *.cpp source files under src folder file (GLOB SOURCES "src/*.cpp") add_executable(uselib${SOURCES}) target_link_libraries (uselib \${PROJECT_LINK_LIBS}) 

Open up a Windows Command Prompt. Change directory to the [example root folder]\useanimallib\build folder.
C:> cd \path\to\example\useanimallib\build
C:> cmake ..

 The build files are generated

 The generated build files
Open up the generated solution file e.g. [example root folder]\useanimallib\build\Debug\uselib.sln using Visual Studio and build the solution.
 Building the solution
The executable that uses the Windows DLL can now be run in a Command Prompt, assuming the DLL is in the PATH environment variable, as shown below.

## Monday, August 1, 2016

### Resolving com.android.build.api.transform.TransformException for task transformClassesWithDexForDebug

I encountered an Android Studio build exception while compiling an Android application to run on a device. The error message is shown in the screen shot below:

The message about classes and Dex gave a huge clue about the cause of the exception; I came across somewhere that there is a limit to the number of classes in a Dex file and Google Play Services use a lot of classes. My app's build.gradle has the dependency to the full com.google.android.gms:play-services:x:x:x file, as shown below.

So one method to reduce the number of classes is to use subsets of the Google Play Services library. Instead of the full com.google.android.gms:play-services dependency, my build.gradle file now has the following dependency line: