
Chapter 6 Exchanging Messages 6.1 Messaging Messaging is a central location where you can find all types of messaging accounts , which include text messages ( SMS ) and e-mail accounts . To select a messaging account Do one of the following : • Tap Start > All Programs > Messaging . The Account Picker screen then opens and you can select an account . • While you are in a message list of a certain account , for example SMS / MMS , tap Menu > Go To to switch to other messaging accounts . To configure message account settings • Tap Menu > Options on the Account Picker screen ; or • Tap Menu > Tools > Options while you’re in a message list . Account Picker screen 124 Exchanging Messages To automatically add a signature in outgoing messages You can automatically add your name and other information as your signature in outgoing SMS and e-mail messages : Note You need to specify your signature for each type of messaging account . 1. Tap Start > All Programs > Messaging , and then tap Menu > Options . 2. Tap Signatures . 3. Select the desired account . 4. Select the Use signature with this account check box . 5. In the text box , enter your signature . 6. To add the signature when you reply to or forward messages , select the Use when replying and forwarding check box , and then tap OK . To filter the Inbox message list When the SMS/MMS or e-mail Inbox on your device is full of messages , you can filter your Inbox to display only the messages that contain a particular sender or subject you are searching for . To filter your Inbox 1. Tap Start > All Programs > Messaging and then tap a messaging account . 2. Enter the sender name or e-mail subject you want to look for . As you type characters , the message list narrows down to the sequence of characters you have entered . When filtering your e-mail Inbox , for example , entering “ B ” , then “ E ” narrows the list to only the e-mail messages that contain sender names and e-mail subjects that start with “ BE . ” Exchanging Messages 125 6.2 Text Messages Send short text messages ( SMS ) to other mobile phones . If your message is more than 160 characters , it will be sent as two or more separate messages and you will be billed accordingly . Creating and sending a new text message 1. On the Home screen , slide to the Messages tab . 2. Touch the New Message icon ( ) on the upper right side of the screen . 3. To add recipients , enter their mobile phone numbers in the To field , separating the numbers with a semicolon ( ; ) . You can also tap To or tap Menu > Add Recipient to add mobile phone numbers from Contacts . 4. Enter your message . Tips • To choose from preset messages , tap Menu > My Text and tap a desired message . • To check the spelling , tap Menu > Spell Check . 5. When finished , tap Send . Note If you want to know when a text message is received , before sending the message that you are composing , tap Menu > Message Options , then select the Request message delivery notification check box . To always receive a delivery notification , tap Menu > Tools > Options in the text message list , tap SMS / MMS , then select the Request delivery notifications check box . Managing text messages from a contact You can easily read , reply or delete text messages that you received from a certain contact by opening his or her contact details and accessing the Messages tab . 1. On the TouchFLO 3D Home screen , slide to the People tab . 2. Touch All People , and then touch the name of the desired contact . 3. The Contact Details screen then appears . Touch the Messages tab ( ) . 126 Exchanging Messages Lists the exchange of text messages between you and the contact . Enter your reply message here and then touch Send . Touch Menu to forward a text message , delete messages , and more . Managing text messages in the Inbox Text messages that are sent to and received from a contact ( or number ) are grouped as a single thread in your Inbox . Threaded SMS shows your messages to and from a contact in a single conversation thread . To open a thread and view the exchange of text messages 1. In the SMS / MMS Inbox , tap a message thread to open it . Exchanging Messages 127 2. You can tap links in the messages to directly open contact details , access a web site , send e-mail , or call the displayed number . • Tap the sender name to open the Contact Details screen . • If the sender is not in your contacts , tap the mobile phone number to call the number , reply to the sender , or save it as a new contact . Tap a web address to open the link in Opera Mobile . Enter your reply message here . Tap these navigation keys to select a message in the thread . To reply to a text message At the bottom of the screen , type your reply message and then tap Send . To copy a message in the thread to the SIM card 1. In the SMS / MMS Inbox , tap a message thread to open it . 2. Tap the up or down navigation key at the bottom of the on-screen keyboard to select a message in the thread . 3. Tap Menu > Copy to SIM . Notes • You cannot copy a sent message from the thread to the SIM card . • Copying text messages from your device to the SIM card results in duplicate messages in the Inbox when your SIM card is in use . 128 Exchanging Messages To delete a message in the thread 1. In the SMS / MMS Inbox , tap a message thread to open it . 2. Tap the up or down navigation key at the bottom of the on-screen keyboard to select a message in the thread . 3. Tap Menu > Delete . To delete all messages in a thread In the SMS / MMS Inbox , tap and hold a message thread , and then tap Delete . Placing a call to the sender of a text message While reading a text message , you can directly call the sender by pressing the TALK/ SEND button . See “ Making a call from a text message ” in Chapter 2 for details . Exchanging Messages 129 6.3 MMS Sending multimedia messages ( MMS ) to your friends and family is fun and easy . You can include pictures , videos , and audio clips in a multimedia message . Notes • Multimedia messaging is a charged service and has to be provisioned on your mobile phone account . Contact your wireless service provider to have MMS provisioned as part of your calling plan . • Make sure the size of MMS messages that you send is within the limits allowed by your wireless service provider . Changing the MMS settings Check your device to see if it is preconfigured with your wireless service provider’s MMS settings . Add the MMS settings of your wireless service provider if there are no preset MMS settings found on your device . To configure MMS message settings 1. Tap Start > All Programs > Messaging > SMS / MMS . 2. Tap Menu > MMS Options . The Settings screen then appears . 3. In the Preferences tab , choose from the available options according to your needs . 4. Tap the Servers tab and check if your device is preset with MMS server settings . If there are no preset settings , tap New and enter the MMS settings which you obtained from your wireless service provider . Note If your device already has preset MMS settings , it is recommended that you do not change these settings . If you change the preset settings , your device may not be able to send and receive MMS messages . 5. Tap Done . Note If you add several MMS message service providers to the Settings screen , you can choose one as your default provider . Select the provider 's name in the list , then tap Set As Default . 130 Exchanging Messages Creating and sending MMS messages You can compose MMS messages in a combination of slides , where each slide can consist of a photo , video or audio clip , and/or text . To compose an MMS message 1. Tap Start > All Programs > Messaging > SMS / MMS . 2. Tap Menu > New > MMS . 3. When the Choose a MMS screen opens , tap a preset template , or tap Custom to open a blank MMS message . Note If you prefer to start composing from a blank MMS message every time , select the Always choose custom check box . 4. In To , enter the recipient’s phone number or e-mail address directly , or tap To , Cc , or Bcc to choose a phone number or an e-mail address from Contacts . Note You may need to scroll up to see the Cc and Bcc fields . 5. Enter a subject for your message . 6. Tap the Insert icon ( )to insert a photo or video clip . When selecting a photo or video clip , you can : • Tap the photo or video clip to insert it into the MMS message . • Tap • Tap • Tap to take a photo and insert it into the MMS message . to record MMS video and insert it into the MMS message . to quit selection and return to the MMS message . 7. Enter text and insert audio clips by tapping the respective areas . See “ To add text to an MMS message ” and “ To add an audio clip to an MMS message ” for details . 8. To add more slides , tap or tap Menu > Slides > Insert Slide . Repeat steps 5 and 6 to add photos/videos , text , and audio to your slides . 9. Tap Send to send the MMS message . Tip You can also send an MMS message from Pictures & Videos , Album , or the Camera program . Exchanging Messages 131 To add text to an MMS message When you tap Insert text here on your MMS message , an empty screen appears where you can enter your text . You can insert the following types of information : Enter your own text Choose from common words or phrases from the My Text list Include a Favorites link Add an emoticon Insert contact information Insert calendar appointment Tip To edit or delete a phrase on the My Text list , tap and hold a string , and then tap Edit or Delete from the shortcut menu . To add a new phrase , tap New . To add an audio clip to an MMS message You can add one audio clip per slide in your MMS message . 1. Tap Insert audio on your MMS message . By default , the My Documents is shown . Tap My Music or another folder that contains audio files . When navigating folders , tap the down arrow ( ) to return to the upper folder . • Tap to play the audio clip , to pause , or to stop playback . 2. Select an audio file . When selected , you can : • Tap Select to insert it to the MMS message . 132 Exchanging Messages • Tap Note to quit selection and return to your MMS message . To record a new audio clip and add it to your MMS message , tap . The Record popup window then opens . Tap Record to start recording , and Stop to end the recording . Tap Play to listen to the recorded audio clip , then tap Add . The new audio clip is then inserted to the MMS message . Viewing and replying to MMS messages To view an MMS message 1. In the SMS / MMS Inbox , tap the MMS message . 2. In the threaded message , tap the MMS icon ( ) , and then use the playback controls , , and to view the MMS message . 3. Tap Contents to see a list of files included in the message . On the Message Contents screen , you can do the following : • To save a file , select it , and tap Menu > Save . • To save the contents of a text file to the My Text list , tap Menu > Save into My Text . • To associate a photo to one of your contacts , tap Menu > Assign to Contact . To reply to an MMS message 1. In the SMS / MMS Inbox , select the mobile phone number or name of the contact who sent you the MMS message . 2. In the threaded message , tap the MMS message to open and view an MMS message . 3. After viewing the MMS message , tap Menu > Reply > via MMS to reply with an MMS message or tap Menu > Reply > via SMS to reply with a text message . Exchanging Messages 133 To block a phone number from sending you MMS messages If you do not want to receive MMS messages from a particular sender , you can add the sender’s phone number to the MMS Blacklist . 1. When you receive a new MMS message , open and view the message . 2. To avoid receiving multimedia messages from this sender next time , tap Menu > Show > Contact Details . 3. Tap Menu > Save to Blacklist . 4. Tap Done . Tip To unblock a phone number and allow the sender to send you MMS messages , remove the number from the Blacklist . Go to the SMS / MMS Inbox , tap Menu > MMS Options > Blacklist tab , tap and hold the phone number in the Blacklist , and then tap Delete . 6.4 E-mail You can set up the following types of e-mail accounts on your device : • Outlook e-mail that you sync with your computer or the Exchange Server . • E-mail account that you have from an Internet Service Provider ( ISP ) or other e-mail provider . • Web-based e-mail accounts such as Yahoo ! ® Mail Plus , AOL® , and others . • Custom domain e-mail accounts . The e-mail domain name is hosted by a different e-mail provider . For more information , search for “ custom domain e-mail ” in the Help on your device . • Work account that you access using a VPN connection . 134 Exchanging Messages Synchronizing Outlook e-mail with your computer If you have installed the synchronization software on your computer and created a partnership with your device , then your device is ready to send and receive Outlook e-mail . If you have not yet installed the synchronization software nor created a partnership , do so by following the procedures in Chapter 5. Tip To set up your company e-mail account so that you can access Outlook e-mail messages wirelessly , you must set up your device to synchronize via an over-theair connection with your company’s Exchange Server . For more information about synchronizing with your company e-mail server , see Chapter 7. Setting up an Internet e-mail account Use Windows Mobile’s E-mail Setup Wizard to set up a POP3 or IMAP4 e-mail account on your device if you have an e-mail account from an Internet service provider ( ISP ) or other e-mail service provider , or a web-based account such as Yahoo ! Mail Plus or AOL . You can also add a work account that you access using a VPN server connection as a POP3/IMAP4 account . Note You can also set up an Internet e-mail account from the TouchFLO 3D Mail tab using the simplified Mail Setup . See “ Mail ” in Chapter 3 for details . 1. Tap Start > All Programs > Messaging > Setup E-mail . 2. Enter your E-mail address and the Password for your e-mail account and select the Save password option . Tap Next . 3. If e-mail provider settings are found preconfigured on your device , the E-mail Setup wizard shows a successful message . Tap Next . If the settings are not found on your device , select the Try to get e-mail settings automatically from the Internet checkbox to find and download e-mail server settings from the Internet and then tap Next . Note You may be charged when your device connects to the Internet and downloads the e-mail server settings . Exchanging Messages 135 4. Enter Your name and the Account display name and then tap Next . Note If the E-mail Setup wizard was unsuccessful in finding and downloading settings from the Internet , select Internet e-mail from the Your e-mail provider list on the next screen . You will be asked to enter e-mail server settings . See “ To specify e-mail server settings ” for details . 5. In the Automatic Send/Receive list , choose how frequent you want e-mail messages to be automatically sent and downloaded on your device . Note Tap Review all download settings to select download options , set the e-mail format as HTML or plain text , and more . For more information , see “ To customize download and format settings . " 6. Tap Finish . To specify e-mail server settings If Auto Setup is unsuccessful , contact your ISP or e-mail provider for the Incoming mail server and Outgoing mail server settings so you can enter them on your device . Other options that you can select include the following : • Select the Outgoing server requires authentication check box , if required by your provider . • If the outgoing e-mail server requires a different user name and password for sending e-mail , clear the Use the same user name and password for sending e-mail check box . You will be prompted to enter this information . • Tap Advanced Server Settings , then select the Require SSL check boxes if your e-mail provider uses an SSL connection for more secured e-mail . From the Network connection list , select the data connection that you use for connecting to the Internet . 136 Exchanging Messages To customize download and format settings Before you tap Finish when setting up your POP3 or IMAP4 e-mail account , you can tap the Review all download settings link at the bottom of the screen to choose download options , message format , and other settings . Options Automatic Send/Receive Download messages Send/receive when I click Send Description Select a time interval for connecting to the Internet automatically to send and receive messages . Set the number of days of messages that you want to be downloaded to your device . By default , messages are immediately delivered when you tap Send . If you prefer to save outgoing messages to the Outbox folder first , clear the check box . ( In this case , you will need to manually send messages by tapping Menu > Send/Receive ) . This allows your device to data roam when there is a set time interval for connecting to the Internet automatically . Since this may result in higher connection costs , you may want to leave the check box cleared . Choose whether to delete messages from the mail server when you delete them on your device . Select HTML or Plain Text . Select the e-mail download size . If you have large volumes of e-mail , use a lower size or select to download headers only . Use automatic send/ receive schedule when roaming When deleting messages Message format Message download limit Exchanging Messages 137 Creating and sending an e-mail message 1. On the TouchFLO 3D Home screen , slide to the Mail tab . 2. At the right side of the screen , tap an e-mail account you want to use , or slide your finger up or down until you have selected the desired account . 3. Touch the New E-mail icon ( ) . 4. To add recipients , enter their e-mail addresses , separating them with a semicolon ( ; ) . You can also tap To if you want to add e-mail addresses stored in Contacts . 5. Enter a subject and compose your message . After setting up e-mail accounts on your device , you can start sending and receiving e-mail messages . Tips • To choose from preset messages , tap Menu > My Text and tap a desired message . • To check the spelling , tap Menu > Spell Check . 6. To add an attachment to your message , tap Menu > Insert and tap the item you want to attach : Picture , Voice Note , or File . Select the file or picture you want to attach , or record a voice note . 7. When finished composing the message , tap Send . Tips • For more information about entering text and symbols , see Chapter 4. • To set the message priority , tap Menu > Message Options . • If you are working offline , e-mail messages are moved to the Outbox folder and will be sent the next time you connect . 138 Exchanging Messages Viewing and replying to e-mail messages To view an e-mail message 1. On the TouchFLO 3D Home screen , slide to the Mail tab , select the e-mail account , and then tap Inbox . 2. Tap an e-mail to open it . To download a complete e-mail By default , long e-mail messages that you receive contains only the first few kilobytes of the message . When you open an e-mail , it displays only the headers and part of the message . You must download the whole e-mail to view the complete content . To download a complete e-mail message , open the e-mail , and then do one of the following : • Finger-scroll to the end of the message , and tap Get entire message and any attachments ( POP3 e-mail account ) or tap Get the rest of this message ( IMAP4 and Outlook e-mail accounts ) . • Tap Menu > Download Message . Notes • The Fetch Mail feature , which is available for POP3 and IMAP4 Internet e-mail accounts , downloads an entire e-mail without the need for you to perform a full synchronization . This limits the download to just the e-mail message that you want and helps save data cost . Fetch Mail is also available for Outlook E-mail . See “ Instant download through Fetch Mail ” in Chapter 7 for details . • Download may take some time , depending on the speed of your Internet connection , size of the whole e-mail , and whether file attachments are automatically downloaded . Exchanging Messages 139 To download file attachments • POP3 e-mail account : File attachments are automatically downloaded when you download a complete e-mail . • IMAP4 and Outlook e-mail accounts : File attachments appear below the subject of an e-mail message . Tapping an attachment opens the attachment if it has been fully downloaded or marks it for download the next time you send and receive e-mail . You can set automatic download of file attachments . See “ Customizing e-mail settings ” in this chapter for details . To reply to or forward a message 1. On the TouchFLO 3D Home screen , slide to the Mail tab , select the e-mail account , and then tap Inbox . 2. Open the message and tap Menu > Reply , Menu > Reply All , or Menu > Forward . 3. Enter your reply message , and then tap Send . Notes • You can receive and view HTML e-mail messages from any type of e-mail account . The HTML format is retained , without layout shifting or resizing . HTML e-mail support in Outlook Mobile is available only if you are synchronizing your device with Microsoft Exchange Server 2007. • When replying using an Outlook e-mail account , you can customize ActiveSync to exclude addresses , including your own , from being added to the recipient list . Tap Menu > Options in ActiveSync , select the E-mail item , tap Settings , and then tap Advanced . In the My e-mail addresses text box , enter the e-mail addresses that you want to exclude . 140 Exchanging Messages Directly making calls from an e-mail While reading an e-mail , you can directly place a call to the sender , start a conference call , access contact details , and more . • Tap the sender photo or name to open the Contact Details screen . • If the sender is not stored in your contacts , tap the e-mail address to send e-mail or save it as a new contact . • Tap a recipient name to open his or her contact details . • Tap a recipient’s e-mail address to send e-mail or save it as a new contact . Tap this Talk button to call the sender . Tap links in the message body to access a web site , send e-mail , or call the displayed number . Tap the To or Cc button or press TALK/SEND to place a call or start a conference call . See Chapter 2 for details . Note If the sender’s name or e-mail address is shown on the e-mail message with a Search button ( ) and you have an Exchange Server e-mail account set up on your device , you can tap this button to search for the sender from the Company Directory . For more information about finding contacts in the Company Directory , see Chapter 7. Exchanging Messages 141 Synchronizing e-mail messages Synchronizing e-mail messages ensures that new e-mail messages are downloaded to the device Inbox folder , e-mail messages in the Outbox folder are sent , and e-mail messages deleted from the server are removed from your device . The manner in which you synchronize e-mail messages depends on the type of e-mail account you have . To automatically synchronize an Outlook e-mail account 1. Connect your device to your computer through USB or Bluetooth . Otherwise , connect through Wi-Fi , or a data connection if you are synchronizing Outlook e-mail with the Exchange Server . For more information , see Chapter 7. 2. Synchronization automatically begins , and your device sends and receives Outlook e-mail . To manually synchronize your Outlook or Internet e-mail account On the TouchFLO 3D Home screen , slide to the Mail tab , select the e-mail account , and then tap Menu > Send/Receive . Customizing e-mail settings To change the download size and format for Outlook e-mail 1. Disconnect your device from the computer . 2. Tap Start > ActiveSync . 3. Tap Menu > Options , select E-mail , then tap Settings . 4. On the E-mail Sync Options screen : • Under Message format , select HTML or Plain Text . HTML is only available when connected to Microsoft Exchange Server 2007 or later . • Under Download size limit , select the desired e-mail size . 5. Close ActiveSync and reconnect your device to the computer . 142 Exchanging Messages To change the download size and format for Internet e-mail 1. Tap Menu > Options on the Account Picker screen , or tap Menu > Tools > Options while you’re in a message list . 2. Tap your POP3 or IMAP4 Internet e-mail account . 3. Tap Download Size Settings . 4. Under Message format , select HTML or Plain Text . 5. Under Download size limit , select the desired e-mail size . 6. Tap Done . To automatically receive attachments on Outlook e-mail messages 1. Tap Start > ActiveSync . 2. Tap Menu > Options . 3. Tap E-mail > Settings , and then select Include file attachments . To automatically receive attachments on IMAP4 e-mail messages 1. Tap Menu > Options on the Account Picker screen , or tap Menu > Tools > Options while you’re in a message list . 2. Tap the name of your IMAP4 e-mail account . 3. Tap Download Size Settings . 4. In Download attachments : • Select All attachments to always download file attachments ; or • sSelect a file size limit for auto-downloading attachments . 5. Tap Done . To store attachments on the storage card 1. Tap Start > All Programs > Messaging . 2. Tap Menu > Options > Storage tab . 3. Select the When available , use this storage card to store attachments check box . 