Our New URL is http://vaks.in

.

first: [1]
Easy solution to create popup style tooltips on BlackBerry.
Extend TooltipScreen instead of the usual MainScreen, usage:

add(new ButtonField(“myButton”), “My Tooltip text”);
and the source:

import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;
import net.rim.device.api.ui.Field;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.XYRect;
import net.rim.device.api.ui.container.MainScreen;

public class TooltipScreen extends MainScreen {

    TooltipScreen screen = this;
    boolean doRedraw = false;//prevent infinte redrawing
    Vector tooltips = new Vector();//vector to hold tooltip strings
    private Timer tooltipTimer = new Timer();
    private TimerTask tooltipTask;
    boolean alive = false;//is the tooltip alive? used to pop it after our timeout
    int count = 0;//used to calculate time tooltip is displayed
    //tooltip popup colours:
    int backgroundColour = 0xeeeeee;
    int borderColour = 0xaaaaaa;
    int fontColour = 0x666666;
    //the tooltip:
    String tooltip;
    int tooltipWidth;
    int yCoord;
    int xCoord;
    //region parameters:
    XYRect contentArea;
    int contentBottom;
    int contentRight;

    public TooltipScreen() {
        super();

        //when timeout reaches 100ms*20 ie. 2seconds set alive to false and redraw screen:
        tooltipTask = new TimerTask() {

            public void run() {
                if (alive) {
                    count++;
                    if (count == 20) {
                        alive = false;
                        invalidate();
                    }
                }
            }
        };

        tooltipTimer.scheduleAtFixedRate(tooltipTask, 100, 100);

    }

    //override add method adds an empty string to tooltip vector:
    public void add(Field field) {
        tooltips.addElement("");
        super.add(field);
    }

    //custom add method for fields with tooltip: add(myField, "myTooltip");
    public void add(Field field, String tooltip) {
        super.add(field);
        tooltips.addElement(tooltip);
    }

    public void setColours(int backgroundColour, int borderColour, int fontColour) {
        this.backgroundColour = backgroundColour;
        this.borderColour = borderColour;
        this.fontColour = fontColour;
    }

    //reset everything when user changes focus,
    //possibly needs logic to check field has actually changed (for listfields, objectchoicefields etc etc)
    protected boolean navigationMovement(int dx, int dy, int status, int time) {
        count = 0;
        alive = true;
        doRedraw = true;
        return super.navigationMovement(dx, dy, status, time);
    }

    protected void paint(Graphics graphics) {
        super.paint(graphics);
        if (alive) {
            Field focusField = getFieldWithFocus();
            tooltip = (String) tooltips.elementAt(screen.getFieldWithFocusIndex());

            //don't do anything outside the norm unless this field has a tooltip:
            if (!tooltip.equals("")) {
                //get the field content region, this may fall inside the field actual region/coordinates:
                contentArea = focusField.getContentRect();
                contentBottom = contentArea.y + contentArea.height;
                contentRight = contentArea.x + contentArea.width;

                //+4 to accomodate 2 pixel padding on either side:
                tooltipWidth = graphics.getFont().getAdvance(tooltip) + 4;

                yCoord = contentBottom - focusField.getManager().getVerticalScroll();
                //check the tooltip is being drawn fully inside the screen height:
                if (yCoord > (getHeight() - 30)) {
                    yCoord = getHeight() - 30;
                }

                //check the tooltip doesn't get drawn off the right side of the screen:
                if (contentRight + tooltipWidth < getWidth()) {
                    xCoord = contentRight;
                } else {
                    xCoord = getWidth() - tooltipWidth;
                }

                //draw the tooltip
                graphics.setColor(backgroundColour);
                graphics.fillRect(xCoord, yCoord, tooltipWidth, 30);
                graphics.setColor(borderColour);
                graphics.drawRect(xCoord, yCoord, tooltipWidth, 30);
                graphics.setColor(fontColour);
                graphics.drawText(tooltip, xCoord + 2, yCoord);
            }
        }
        //doRedraw logic prevents infinite loop
        if (doRedraw) {
            //System.out.println("redrawing screen: " + System.currentTimeMillis());
            screen.invalidate();
            doRedraw = false;
        }
    }
}

second: [2]

package ..;

/*

Display a 'Tooltip" (String) at a specified location for s specified time
This Tooltip can also be removed.
Note that in my testing, the display time is not consistent.

Following example shows it being added and removed using focus events.

ButtonField bf = new ButtonField("Test") {
    MyTooltip _tooltip;
    protected void onFocus(int direction) {
        if ( _tooltip != null ) {
            _tooltip.removeToolTip();
            _tooltip = null;
        }
        // Display tooltip at 50,50 for 5 seconds
        _tooltip = MyTooltip.addToolTip(UiApplication.getUiApplication(), "Press to test", 50, 50, 5);;
    }
    protected void onUnfocus() {
        if ( _tooltip != null ) {
            // We have displayed a Tooltip - remove it
            _tooltip.removeToolTip();
            _tooltip = null;
        }
    }
 };

*/

import net.rim.device.api.ui.UiApplication;
import net.rim.device.api.ui.Manager;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.Font;
import net.rim.device.api.ui.Screen;
import net.rim.device.api.ui.component.LabelField;
import net.rim.device.api.ui.container.VerticalFieldManager;
import net.rim.device.api.ui.container.PopupScreen;

class MyTooltip extends PopupScreen{
    int _x;
    int _y;
    TooltipThread _tooltipThread;

    private MyTooltip(Manager manager) {
        super(manager);
     }
    public void sublayout(int width, int height)    {
        super.sublayout(width,height);
        setPosition(_x,_y);
        System.out.println("Tooltip x: " + Integer.toString(_x) + ", y: " + Integer.toString(_y));
    }
    protected void applyTheme() {
        // Overriden to suppress Border etc.
    }
    public void removeToolTip() {
        if ( _tooltipThread != null ) {
            _tooltipThread.dismiss();
        }
    }
    private void display(UiApplication uiApp, int x, int y, int displayTime) {
        _x = x;
        _y = y;
        _tooltipThread = new TooltipThread(uiApp, this, displayTime);
        _tooltipThread.start();
    }

    public static MyTooltip addToolTip(UiApplication uiApp, String toolTipString, int x, int y, int displayTime) {
        VerticalFieldManager manager = new VerticalFieldManager(Manager.FIELD_VCENTER|Manager.NON_FOCUSABLE) {
            protected void paint(Graphics graphics) {
                graphics.setColor(0x00FFFFFF); // White
                graphics.fillRect(0,0,getWidth(),getHeight());
                graphics.setColor(0x00000000); // Black
                graphics.drawRect(0,0,getWidth(),getHeight());
                super.paint(graphics);
            }
        };
        MyTooltip toolTip = new MyTooltip(manager);
        LabelField label = new LabelField(' ' + toolTipString + ' ', LabelField.NON_FOCUSABLE);
        label.setFont(Font.getDefault().derive(Font.PLAIN, 16));
        toolTip.add(label);
        toolTip.display(uiApp, x, y, displayTime);
        return toolTip;
    }

    class TooltipThread extends Thread {

        Object _notifyObject = new Object(); // Used to allow user to dismiss this Tooltip
        PopupScreen _tooltip; // Screen we are going to display
        UiApplication _ourApplication; // access to pushGlobalScreen and dismissStatus from our Application
        int _displayTime; // in seconds

        public TooltipThread(UiApplication ourApplication, PopupScreen tooltip, int displayTime) {
            _tooltip = tooltip;
            _ourApplication = ourApplication;
            _displayTime = displayTime;
        }

        public void run() {
            _ourApplication.pushGlobalScreen(_tooltip, 999, false);
            synchronized(_notifyObject) {
                try {
                    _notifyObject.wait(_displayTime * 1000);
                } catch (Exception e) {
                }
            };
            _ourApplication.dismissStatus(_tooltip);
        }

        public void dismiss() {
            // notify the waiting object to stop the Thread waiting
            synchronized(_notifyObject) {
                _notifyObject.notify();
            }
        }

    }

}

[1] http://www.naviina.eu/wp/blackberry/390/
[2] http://supportforums.blackberry.com/t5/Java-Development/Problem-with-Tooltip/td-p/102847

This article applies to the following:

• BlackBerry® Device Software 4.2.1 and later

Details

Advanced streaming media

The Mobile Media API (JSR 135) defines advanced APIs that you can use to control media streaming and allow flexibility in development. These APIs can be found in the javax.microedition.media package.

Components of advanced streaming media

The following diagram illustrates the different components and classes that are involved in streaming media and the data flow between a remote media source and the media player.

 

Source Media

The media file that is located on a content server.

 

Download Thread

A thread that connects to the source media and downloads the media file to the media buffer.

Media Buffer

A circular byte buffer for storing downloaded data until it is sent to media player for playback.

SourceStream

An instance of the javax.microedition.media.protocol.SourceStream class. The SourceStream acts as an input stream for the media player by providing methods such as read() and seek().

DataSource

An instance of the javax.microedition.media.protocol.DataSource. DataSource class, and performs the following procedure:

Open a connection to the remote source media.
Start the download thread.
Initialize and return SourceStream objects to play.
Close the connection.

Player

An instance of javax.microedition.media.Player. The Player object plays media content as the content is downloaded. You can initialize a Playerobject by invoking

javax.microedition.media.Manager.createPlayer(DataSource source).

 

Implementation

The code sample that is included this article shows a complete implementation of all the components and classes that are mentioned. The code sample also includes a StreamingPlayer class and a StreamingPlayerListener interface that you can use as an API or extend to meet special use cases.

Implementing the DataSource

DataSource is an abstract class and has six methods. Each of the following methods is invoked by the Player object:

 

public void connect()

Opens connections and input/output (I/O) streams

public void disconnect()

Closes connections, I/O streams, and so on

public String getContentType()

Returns the content type of the source media

public SourceStream[] getStreams()

Returns SourceStream objects

public void start()

Starts the download thread and begins downloading data

public void stop()

Stops downloading data

Implementing the SourceStream

public ContentDescriptor getContentDescriptor()

Returns a ContentDescriptor object based on the content type of the media

public long getContentLength()

Returns the content length.

public int getSeekType()

Returns RANDOM_ACCESSIBLE
Allows the Player to seek to nearby locations from the current position. SourceStream RANDOM_ACCESSIBLE must be set because video files can have audio and video at different offsets for each frame and the BlackBerry Device Software requires both for smooth playback. If -1 is returned by getContentLength(), the seek calls will only be to a previous position in the media file.

public int read(byte[] b, int off, int len)

Sends data to the Player.
Blocks or resumes the feed,depending on the status of the buffer

public long seek(long where)

Called by the Player to seek to a point between 0 and the content length
Implementation varies based the following connection types:
HTTP streaming
Uses this method only if seek() is feasible.
seek() point is within the buffered data. Otherwise, return the current position.
FileConnection streaming
Uses this method with mark(), reset() and skip()

public long tell()

Returns the current position in the stream

How to handle user-initiated seek()

There are two types of user-initiated seek calls. In both cases, Player.setMediaTime(long microseconds) must be invoked, which in turn invokesSourceStream.seek(long position).

Seek calls within available data
Invoke seek() within the buffer using mark(), reset() or skip()

Seek calls beyond the data that is available
Block the feed to the Player.
Stop downloading data.
Close the HTTP connection.
Reopen the connection using the HTTP range header to get data from the seek position.
Start downloading using the new connection.
Resume the feed to the Player when buffer contains enough information.

Stream control

Because media is streaming over a wireless network, there must be a mechanism to stop data feed to the Player when the buffer runs out of space due to of network delay. There must also be a way to determine how much of the buffer should be filled before restarting or resuming playback. Downloaded data in the buffer must be held as long as possible to allow for backward seek calls made by the Player, but when buffer is full the data must be discarded to download more data. You can use the following variables to control the feed to the Player:

initialBufferDetermines how much data to buffer before playback starts for the first time. This variable can be determined dynamically by the following criteria:
Connection type
Bit rate
Bandwidth and latency
restartThresholdDetermines when to resume the data feed to the Player based on the data that is available in the buffer. This variable can be determined dynamically by the following criteria:
Connection type
Bit rate
Bandwidth and latency
bufferCapacityDetermines the size of the buffer where data is stored. This variable can be determined dynamically by the following criteria:
Connection type
Bit rate
Bandwidth and latency
If a buffer is too small, it can frequently run out of space.
If a buffer too big, it can waste system resources.
bufferLeakSizeVideo playback requires the Player to seek back from the current position because audio and video data for the same frame are at different offsets. To accommodate this situation, downloaded data is stored until the Player is at the end of the buffer and the buffer is full. This method requires that more data must be downloaded for the playback to continue. In this situation, the oldest data is discarded first to create space for downloading more data.bufferLeakSize determines how much data is discarded each time this occurs.

Creating a Player from a DataSource

To create a Player from a DataSource, use the following code:

Player player = Manager.createPlayer(new MyDataSource());player.start();

 

Downloads

A complete implementation of a streaming media application is available to download. This example application uses the StreamingPlayer class andStreamingPlayerListener class as libraries, and can be used in your application to stream media over HTTP. This application will only play the media files that are supported by the target BlackBerry smartphone. Make sure that you type the web page and content type of your media file on the Options screen of the application before pressing play.

 

Note: The API needs an implementation of a thread safe Circular Byte Buffer. You can copy the implementation as CircularByteBuffer.java to rimx.media.streaming package and then complile the project. For an example, click here.

 

Refer to attachment section below to download the example application, including the libraries.

 

[1] http://supportforums.blackberry.com/t5/Java-Development/Streaming-media-Start-to-finish/ta-p/488255

streamingplayersampleapp__download_pdf_renameto_zip

The sample attached below shows a basic cake ordering system that helps construct a CakeObject that it then converted into a JSON String. This example will help familiarize you with the steps required to implement JSON in your own application as well as determine the benefit of its use and the way different data types are formatted once converted to JSON. It contains two projects, the application and the JSON ME library source code. These will need to be set up so that the application depends on the library in order to compile and test.

[1] http://supportforums.blackberry.com/t5/Java-Development/Sample-Code-Implementing-JSON-in-your-application/ta-p/539659
[2] https://meapplicationdevelopers.dev.java.net/source/browse/meapplicationdevelopers/demobox/mobileajax/lib/json/src/org/json/me/

jsonlib_javame__download_pdf_and_renameto_zip
JSONDemoApp__download_pdf_renameto_zip

public String[] split(String strString, String strDelimiter)
	{
		int iOccurrences = 0;
		int iIndexOfInnerString = 0;
		int iIndexOfDelimiter = 0;
		int iCounter = 0;

		// Check for null input strings.
		if (strString == null)
		{
			throw new NullPointerException("Input string cannot be null.");
		}
		// Check for null or empty delimiter
		// strings.
		if (strDelimiter.length() <= 0 || strDelimiter == null)
		{
			throw new NullPointerException("Delimeter cannot be null or empty.");
		}

		// If strString begins with delimiter
		// then remove it in
		// order
		// to comply with the desired format.

		if (strString.startsWith(strDelimiter))
		{
			strString = strString.substring(strDelimiter.length());
		}

		// If strString does not end with the
		// delimiter then add it
		// to the string in order to comply with
		// the desired format.
		if (!strString.endsWith(strDelimiter))
		{
			strString += strDelimiter;
		}

		// Count occurrences of the delimiter in
		// the string.
		// Occurrences should be the same amount
		// of inner strings.
		while((iIndexOfDelimiter= strString.indexOf(strDelimiter,iIndexOfInnerString))!=-1)
		{
			iOccurrences += 1;
			iIndexOfInnerString = iIndexOfDelimiter + strDelimiter.length();
		}

		// Declare the array with the correct
		// size.
		String[] strArray = new String[iOccurrences];

		// Reset the indices.
		iIndexOfInnerString = 0;
		iIndexOfDelimiter = 0;

		// Walk across the string again and this
		// time add the
		// strings to the array.
		while((iIndexOfDelimiter= strString.indexOf(strDelimiter,iIndexOfInnerString))!=-1)
		{

			// Add string to
			// array.
			strArray[iCounter] = strString.substring(iIndexOfInnerString, iIndexOfDelimiter);

			// Increment the
			// index to the next
			// character after
			// the next
			// delimiter.
			iIndexOfInnerString = iIndexOfDelimiter + strDelimiter.length();

			// Inc the counter.
			iCounter += 1;
		}
            return strArray;
	}

public String replace(String source, String pattern, String replacement)
	{	

		//If source is null then Stop
		//and return empty String.
		if (source == null)
		{
			return "";
		}

		StringBuffer sb = new StringBuffer();
		//Intialize Index to -1
		//to check against it later
		int idx = -1;
		//Intialize pattern Index
		int patIdx = 0;
		//Search source from 0 to first occurrence of pattern
		//Set Idx equal to index at which pattern is found.
		idx = source.indexOf(pattern, patIdx);
		//If Pattern is found, idx will not be -1 anymore.
		if (idx != -1)
		{
			//append all the string in source till the pattern starts.
			sb.append(source.substring(patIdx, idx));
			//append replacement of the pattern.
			sb.append(replacement);
			//Increase the value of patIdx
			//till the end of the pattern
			patIdx = idx + pattern.length();
			//Append remaining string to the String Buffer.
			sb.append(source.substring(patIdx));
		}
		//Return StringBuffer as a String

                if ( sb.length() == 0)
                {
                    return source;
                }
                else
                {
                    return sb.toString();
                }
	}

public String replaceAll(String source, String pattern, String replacement)
{    

    //If source is null then Stop
    //and retutn empty String.
    if (source == null)
    {
        return "";
    }

    StringBuffer sb = new StringBuffer();
    //Intialize Index to -1
    //to check agaist it later
    int idx = -1;
    //Search source from 0 to first occurrence of pattern
    //Set Idx equal to index at which pattern is found.

    String workingSource = source;

    //Iterate for the Pattern till idx is not be -1.
    while ((idx = workingSource.indexOf(pattern)) != -1)
    {
        //append all the string in source till the pattern starts.
        sb.append(workingSource.substring(0, idx));
        //append replacement of the pattern.
        sb.append(replacement);
        //Append remaining string to the String Buffer.
        sb.append(workingSource.substring(idx + pattern.length()));

        //Store the updated String and check again.
        workingSource = sb.toString();

        //Reset the StringBuffer.
        sb.delete(0, sb.length());
    }

    return workingSource;
}

[1] http://supportforums.blackberry.com/t5/Java-Development/String-Manipulation-split-replace-replaceAll/ta-p/620038

this is the code for the previous version of BlackBerry OS, how to invoke the browser with the raw HTML.

The mechanism for using the BlackBerry Browser to invoke the browser with raw HTML content is shown in the sample code below. The key aspect of the code is the section where you pass in the following string to the browser at the start of the data sequence:

data:text/html;base64,

/*
* RawHTMLBrowserSample.java
*
* © Research In Motion Limited, 2007
* Confidential and proprietary.
*/

import java.io.*;
import javax.microedition.io.*;
import net.rim.blackberry.api.browser.*;
import net.rim.device.api.io.*;
import net.rim.device.api.system.*;
import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;
import net.rim.device.api.ui.container.*;
import net.rim.device.api.util.*;

/**
* A simple example of how to invoke the BlackBerry Browser using
* raw HTML data.
*/
public class RawHTMLBrowserSample extends UiApplication
{
    public static void main( String[] args )
    {
        RawHTMLBrowserSample sample = new RawHTMLBrowserSample();
        sample.enterEventDispatcher();
    }

    /**
    * Create the splash screen and start off the networking
    * thread that will eventually invoke the browser.
    */
    public RawHTMLBrowserSample()
    {
        MainScreen splashScreen = new MainScreen();
        splashScreen.add( new RichTextField( "Please Wait..." ));
        pushScreen( splashScreen );
        MyThread thread = new MyThread();
        thread.start();
    }
    private static class MyThread extends Thread
    {
        public void run()
        {
            try {
            // Open the connection and the input stream. Select your own URL.
            HttpConnection connection = (HttpConnection)Connector.open( "http://www.blackberry.com:80" );
            InputStream input = connection.openInputStream();
            DataBuffer buffer = new DataBuffer();
            byte[] temp = new byte[ 1024 ];
            // Read in the web page to the DataBuffer.
            for( ;; ) {
                int bytesRead = input.read( temp );
                if( bytesRead == -1 ) {
                    break;
                }
                buffer.write( temp, 0, bytesRead );
            }
            input.close();
            connection.close();
            // Create an output stream that will be used by the Base64 code.
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            Base64OutputStream boutput = new Base64OutputStream( output );
            // Write out the special sequence which indicates to the browser
            // that it should treat this as HTML data in base64 format.
            output.write( "data:text/html;base64,".getBytes() );
            boutput.write( buffer.getArray() );
            boutput.flush();
            boutput.close();
            output.flush();
            output.close(); // Invoke the browser with the encoded HTML content.
            BrowserSession bSession = Browser.getDefaultSession();
            bSession.displayPage( output.toString() );
        } catch( IOException e ) {
            System.out.println( "IOException: " + e );
        }
    }
}
}

The browser uses the sequence to base64 decode the string following the comma and displays it in the browser. When displaying the page, images and other items do not appear because the browser cannot fetch them.

This article applies to BlackBerry® Device Software 4.2 and later.

[1] http://www.blackberry.com/knowledgecenterpublic/livelink.exe/fetch/2000/348583/796557/800332/800440/How_To_-_Invoke_the_browser_with_raw_HTML.html?nodeid=1313878&vernum=0?CPID=EMC-DM2007M-37

public static boolean hasCoverage() {
       boolean bisCoverage = CoverageInfo.isCoverageSufficient( CoverageInfo.COVERAGE_BIS_B );
       boolean carrierCoverage = false;
       carrierCoverage = CoverageInfo.isCoverageSufficient( CoverageInfo.COVERAGE_DIRECT );
       return bisCoverage || carrierCoverage;
}

[1] http://us.blackberry.com/developers/platform/pushapi.jsp

The size of files that can be downloaded to the BlackBerry smartphone using the BlackBerry® Mobile Data System (BlackBerry MDS) is limited due to storage availability on the BlackBerry smartphone and the cost of transferring data wirelessly. The BlackBerry MDS uses the Multipurpose Internet Mail Extensions (MIME) type reported by the web server to determine which file limit should be applied. This file limit may also include any additional overhead from the web server, and will apply both before and after transcoding is done by the BlackBerry MDS. BlackBerry MDS provides a response code of 413 if the file size is too big. For standard Hypertext Transfer Protocol (HTTP) file downloading, as is done in the following example, there is no additional overhead or transcoding. For more information on BlackBerry MDS file settings and response code 413, see DB-00623.

HTTP Range request header

If it is supported by the server, the Range header can be used to make individual requests for parts of a file. By keeping these file range requests below the limit of an individual file, larger files can be downloaded in parts and recombined on the BlackBerry smartphone. The file does not have to be separated into chunks on the server using this approach. The following example uses the Range header to request a file in several parts.

Note: The use of response code 206 for partial content and downloading the file correctly is based entirely on calculating the correct byte range to request. The same approach could be used to resume downloading interrupted transfers.

private class DownloadCombiner extends Thread {
    private String remoteName;
    private String localName;
    private int connection;
    private int chunksize;
    public DownloadCombiner(String remoteName,
        String localName, int connection, int chunksize) {
        this.remoteName = remoteName;
        this.localName = localName;
        this.connection = connection;
        this.chunksize = chunksize;
    }
    public void run() {
        try {
            int chunkIndex = 0;
            int totalSize = 0;

            /*
             * File connection
             */
            FileConnection file =(FileConnection)Connector.open(localName);
            if (!file.exists()) {
                file.create();
            file.setWritable(true);
            OutputStream out = file.openOutputStream();

            /*
             * HTTP Connections
             */
            String currentFile = remoteName + connectionType();
            log("Full URL: " + currentFile);
            HttpConnection conn;
            InputStream in;
            int rangeStart = 0;
            int rangeEnd = 0;
            while (true) {
                log("Opening Chunk: " + chunkIndex);
                conn = (HttpConnection) Connector.open(currentFile,
                        Connector.READ_WRITE, true);
                rangeStart = chunkIndex * chunksize;
                rangeEnd = rangeStart + chunksize - 1;
                log("Requesting Range: " + rangeStart +
                     "-" + rangeEnd);
                conn.setRequestProperty("Range", "bytes=" +
                     rangeStart + "-" + rangeEnd);
                int responseCode = conn.getResponseCode();
                if (responseCode != 200 && responseCode != 206)
                {
                    log("Response Code = " + conn.getResponseCode());
                    break;
                }
                log("Retreived Range: " + conn.getHeaderField("Content-Range"));
                in = conn.openInputStream();
                int length = -1;
                byte[] readBlock = new byte[256];
                int fileSize = 0;
                while ((length = in.read(readBlock)) != -1) {
                    out.write(readBlock, 0, length);
                    fileSize += length;
                    Thread.yield(); // Try not to get cut off
                }
                totalSize += fileSize;
                log("Chunk Downloaded: " + fileSize + " Bytes");
                chunkIndex++; // index (range) increase
                in.close();
                conn.close();
                in = null;
                conn = null;
                /*
                 * Pause to allow connections to close and other Threads
                 * to run.
                 */
                 Thread.sleep(1000);
            }
            log("Full file downloaded: " + totalSize + " Bytes");
            out.close();
            file.close();
            log("Wrote file to local storage");
            } catch (Exception e) {
                 log(e.toString());
            }
        }
    private String connectionType() {
        switch (connection) {
            case 1:
                return ";deviceside=false";
            case 2:
                return ";deviceside=true;interface=wifi";
            default:
                return ";deviceside=true";
        }
    }
}

File splitting

A large file can be downloaded to the BlackBerry smartphone by splitting the file into multiple parts and then downloading each part to the microSD card, where the parts can be recombined into the original file.

The following code segment describes a scheme for splitting a file into defined part sizes. The file parts are labeled with the original filename and a part ID.

public void splitFile() throws Exception {
    BufferedInputStream input = new BufferedInputStream(new FileInputStream(_file));
    byte[] readBlock = new byte[_chunksize];
    int chunkFileId = 0;
    int length = -1;
    while ((length = input.read(readBlock)) != -1) {
        String chunkFileName = _file.getName() + "." + chunkFileId++;
        BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(chunkFileName));
        output.write(readBlock, 0, length);
        output.flush();
        output.close();
        System.out.println("Wrote Chunk file " + chunkFileName + " of " + length + " Bytes");
    }
    System.out.println("Completed Splitting " + _file.getName());
}

File downloading

Once the file has been split into a series of parts, each part can be downloaded in order and written out to one file on the microSD card.

Note: The response code is used to determine whether the part exists. If the part does not exist, the downloading process is completed.

private class DownloadCombiner extends Thread {

    private String remoteName;
    private String localName;
    private int connection;

    public DownloadCombiner(String remoteName, String localName) {
        this.remoteName = remoteName;
        this.localName = localName;
    }

    public void run() {
        try {
            int chunkIndex = 0;
            int totalSize = 0;
            FileConnection file = (FileConnection) Connector.open(localName);
            if (!file.exists()) {
                 file.create();
            }
            file.setWritable(true);
            OutputStream out = file.openOutputStream();
            HttpConnection conn;
            InputStream in;
            while (true) {
                 System.out.println("Opening Chunk: " + chunkIndex);
                 String currentFile = remoteName + "." + chunkIndex++;
                 conn = (HttpConnection) Connector.open(currentFile);
                 if (conn.getResponseCode() != 200) {
                     System.out.println("Response Code = " +
                                         conn.getResponseCode());
                     break;
                 }
                 in = conn.openInputStream();
                 int length = -1;
                 byte[] readBlock = new byte[256];
                 int fileSize = 0;
                 while ((length = in.read(readBlock)) != -1) {
                     out.write(readBlock, 0, length);
                     fileSize += length;
                 }
                 totalSize += fileSize;
                 System.out.println("Chunk Downloaded: " + fileSize + " Bytes");
                 in.close();
                 conn.close();
                 in = null;
                 conn = null;
                 Thread.yield(); // allow other threads time
            }
            System.out.println("Full file downloaded: " + totalSize + " Bytes");
            out.close();
            file.close();
            System.out.println("Wrote file to local storage");
        } catch (Exception e) {
            System.err.println(e.toString());
          }
    }
}

[1] http://www.blackberry.com/knowledgecenterpublic/livelink.exe/fetch/2000/348583/800332/800431/How_To_-_Download_large_files_using_the_BlackBerry_Mobile_Data_System.html?nodeid=1371855&vernum=0

How To – Obfuscate code in a BlackBerry application [1]

Unlike traditional compilers, the compiler for the BlackBerry platform is highly optimized for a constrained mobile environment where the goal is to minimize the size of the application. The resulting COD file provides a significant amount of obfuscation-like services similar to other true obfuscation packages in an effort to reduce the size of the COD file. For example, the following information is removed from a COD file:

All debug information
Local variable names
Source Line Numbers
Private Method and Members names

Support for obfuscation via third-party tools is not integrated into the JDE. As such, a command line procedure is required to obfuscate COD files for use on BlackBerry wireless devices. This article provides the steps and techniques required to obfuscate a COD file and have it execute properly on the BlackBerry device.

Create an application in the JDE. You should place the project file in a separate directory for ease of use during this process.

Create a temporary directory.

Copy the associated JAR file created by the BlackBerry JDE to the temporary directory.

Extract the contents of the JAR file into the temporary directory using the following command: jar xvf SampleApplication.jar

Delete the COD file (that was extracted as part of the JAR file) and the JAR file. You will replace these files in the following steps.

Obfuscate the class files that are contained in the temporary directory.

Run the pre-verify tool on the contents of the temporary directory using the following command: preverify.exe -verbose -d . -classpath..\lib\net_rim_api.jar;

Run rapc on the obfuscated (and pre-verified) class files to create a COD file. Use the following command:

rapc.exe -verbose import=..\lib\net_rim_api.jar codename=SampleApplication SampleApplication.rapc C:\yourTempDir\SampleApplication.class

This produces a COD file that will work on a device that has its contents obfuscated.

[1] http://www.blackberry.com/knowledgecenterpublic/livelink.exe/fetch/2000/348583/800901/How_To_-_Obfuscate_code_for_a_BlackBerry_application.html?nodeid=1033550&vernum=0

All regex repetition operators are greedy. They try to match as much as possible in a string. Unfortunately, this might not always be a desired effect. Thus, lazy operators are used to solve this problem. They only match the smallest possible pattern and are used by adding a ‘?’ after the respective greedy operator. Alternatively, the ‘U’ modifier may be used to make all repetiton operators lazy. Differentiating between greediness and laziness is key to fully understanding advanced regular expressions.

Greedy Operators

The * operator matches the previous expression 0 or more times. It is a greedy operator. Consider the following expression:

Recall that a . means any character except a new line. The above regular expression is looking for an h1 tag and all of its contents. It uses the . and * operators to constantly match anything inside the tag. This pattern will match:

It returns the whole string. The * operator will continuously match everything — even the middle closing h1 tag — because it is greedy. Matching the whole string is the best it can do.

Lazy Operators

Let’s change the above operator by adding a ‘?’ after it. This will make it lazy:

The regex now fulfills its duty and matches only the first h1 tag. Another greedy operator that uses this same property is {n,}. This matches the previous expression n or more times. If it is used without a question mark, it looks for the most repetitions possible. Otherwise, it starts from n repetitions:

2. Back Referencing

What it does

Back referencing is a way to refer to previously matched patterns inside a regular expression. For example, take a look at this simple regex that matches an expression in quotes:

Unfortunately, this will not correctly match the string. Instead, it will print:

This regular expression matches the opening double quote but finds a different type of quote to close it. This is because it was given the option of picking a double or single quote at the end. In order to fix this, you can use back referencing. The expressions \1, \2, …., \9 hold references to previously captured subpatterns. The first matched quote, in this case, will be held by the variable \1.

How to Use It

In order to apply this concept to the aforementioned example, use \1 in place of the last quote:

This will now correctly return:

Remember that back referencing may also be used by preg_replace. Note that instead of \1 … \9, you should use $1 … $9 … $n (any number of these will work). For example, if you want to replace all paragraph tags with text that represents them, use:

The $1 back reference holds the text inside the paragraph and is being used in the replace pattern itself. This completely valid expression shows an easy way to access matched patterns even while replacing.

3. Named Groups

When using multiple back references, a regular expression can quickly become confusing and hard to understand. An alternative way to back reference is by using named groups. A named group is specified by using (?P<name>pattern), where name is the name of the group and pattern is the regular expression in the group itself. The group can then be referred to by (?P=name). For example, consider the following:

The above expression will create the same effect as the previous back reference example, but by instead using named groups. It is also significantly easier to read.

Named groups are also useful when sifting through the array of matches. The name given to a specific pattern is also the key of the corresponding matches array.

Thus, named groups not only make code easier to read but also organize it.

4. Word Boundaries

Word boundaries are places in a string that come between a word character and a non-word character. The specialty of these boundaries is the fact that they don’t actually match a character. Their length is zero. The \b regular expression matches any word boundary.

Unfortunately, boundaries are so often skimmed over that many do not recognize their real significance. For example, let’s say you want to match the word “import”:

Watch out! Regular expressions can be tricky. The above expression will also match:

You may think it is as simple as adding a space before and after import to prevent these bogus matches:

But what about this case?

When import is at the beginning or the end of a string, the modified regex will fail. Thus, splitting this up into cases is required:

Looking back at our regular expression, it does not take periods or other punctuation into account. Just to match this single word, a regular expressions may look like this:

That’s a lot of code to match just a single word. This is why word boundaries are so significant. To accomplish the above statement and many other variations with word boundaries, all that is necessary is:

This will match every case above and more. \b’s flexibility comes from the fact that it matches a zero-length string. All it matches is an imaginary space between two characters. It checks if one of the characters is a non-word character and the other is a word character. If so, it matches it. If the beginning or end of a string is encountered, \b treats it as a non-word character. Because the i in import is still considered a word character, it will match import.

Note that the opposite of \b is \B. This operator will match the space in-between two word or two non-word characters. Thus, if you would like to match ‘hi’ inside another word, you could use:

5. Atomic Groups

Atomic groups are special regex groups that are non-capturing. They are usually used to increase the efficiency of a regular expression, but may also be applied to eliminate certain matches. An atomic group is specified by using (?>pattern):

When the regex engine matches an atomic group, it will discard backtracting positions that came with all tokens inside it. Consider the word ’smashing’. Using the above regular expression, the regex engine will first try to match the pattern ‘his’ in ’smashing’. It will not find a match. At this point, the atomic group will kick in. The engine will discard all backtracking positions. This means that it will not search for ‘this’ inside ’smashing’. Why? If ‘his’ did not return a match, then obviously ‘this’ (which includes ‘his’) will not return positive either.

The above example did not have many practical uses. We might as well have used /t?his?/ instead. Look at the following:

If the regex engine is given the word ‘engineering’, it will correctly match ‘engineer’. The next word boundary, \b, will not match. Thus, it will move on to the next match: engrave. It realizes that the ‘eng’ matches, but the rest do not. Finally, ‘end’ is attempted and also failed. If you look carefully, you will realize that once the engine matches ‘engineer’ and fails the last word boundary, it can not possibly match ‘engrave’ or ‘end’. These two matches are smaller words than ‘engineer’, and thus the regex engine should not continue with the other trials.

The above is a much better alternative that will save the regex engine time and improve the code’s efficiency.

6. Recursion

Recursion in regular expressions can be used to match nested constructs, such as parentheses, (this (that)), and HTML tags, <div></div>. They require the use of (?R), an operator that matches recursive sub-patterns. Consider the regular expression that matches nested parentheses:

The outermost parentheses in this regular expression match the beginning of the nested constructs. Then comes an optional operator, which can either match non-parenthetical characters (?>[^()]+) or the whole expression again in a sub-pattern, (?R). Notice that this operator is repeated as many times as possible to match all nested parentheses.

Another example of recursion at work is the following:

The above expression combines character groups, greedy operators, back-tracking, and atomic groups to match nested tags. The first parenthesized group ([\w]+) matches the tag name for use later in the regular expression. It then proceeds to match the rest of the tag. The next parenthesized sub-expression is very similar to the one above. It either matches non-tag (?>[^<>]+) characters or recurses over another tag (?R). Finally, the last part of the expression matches the close tag.

7. Callbacks

Certain matches in a pattern may require special modifications. In order to apply multiple or complex changes, callbacks can be used. A callback is used for dynamic substitution Strings in the preg_replace_callback function. They take in a function as a parameter to use when a match is found. This function receives the match array as a parameter and returns a modified string that is used as a replacement.

As an example, consider a regular expression that changes all words to uppercase in a given string. Unfortunately, PHP does not have a regex operator that changes a character to a different case. To accomplish this task, a callback may be used. First, the expression must match all letters that need to be capitalized:

The above uses both word boundaries and character classes to work. Now that we have this expression, we can write a callback function:

upper_case takes in an array of matches and returns the whole matched pattern in uppercase. $matches[0], in this case, represents the letter that needs to be capitalized. All of this can now be put together using the preg_replace_callback function:

That is the power of a simple callback.

8. Commenting

Commenting is not a way to actually match strings, but it is one of the most important parts of regular expressions. As you dive deep into larger, more complex expressions, it becomes hard to decipher what is actually being matched. Using comments in the middle of regular expressions is the perfect way to minimize such confusion.

To place a comment inside a regular expression, use the (?#comment) format. Replace “comment” with the word(s) of your choice:

It is especially important to comment regular expressions that you release to the public. Users of your regex will be able to easily understand and modify the pattern to meet their needs. It can even go so far as to help you decode it when revisiting a program.

Consider using the “x” or (?x) modifier for free-spacing mode with comments. This causes a regular expression to ignore white space between tokens. All spaces can still be represented with [ ] or \ (a backslash and a space):

The above is the same as:

Always create well-documented code.

[1] http://www.smashingmagazine.com/2009/05/06/introduction-to-advanced-regular-expressions/